lib/streamsilk-extractor/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    id("lib-android")
+}
+
+dependencies {
+    implementation(project(":lib:playlist-utils"))
+}

lib/streamsilk-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsilkextractor/JsHunter.kt

@@ -0,0 +1,86 @@
+package eu.kanade.tachiyomi.lib.streamsilkextractor
+
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+import kotlin.math.pow
+
+class JsHunter(private val hunterJS: String) {
+
+    /**
+     * Detects whether the javascript is H.U.N.T.E.R coded.
+     *
+     * @return true if it's H.U.N.T.E.R coded.
+     */
+    fun detect(): Boolean {
+        val p = Pattern.compile("eval\\(function\\(h,u,n,t,e,r\\)")
+        val searchResults = p.matcher(hunterJS)
+        return searchResults.find()
+    }
+
+    /**
+     * Unpack the javascript
+     *
+     * @return the javascript unhunt or null.
+     */
+
+    fun dehunt(): String? {
+        try {
+            val p: Pattern =
+                Pattern.compile(
+                    """\}\("([^"]+)",[^,]+,\s*"([^"]+)",\s*(\d+),\s*(\d+)""",
+                    Pattern.DOTALL
+                )
+            val searchResults: Matcher = p.matcher(hunterJS)
+            if (searchResults.find() && searchResults.groupCount() == 4) {
+                val h = searchResults.group(1)!!.toString()
+                val n = searchResults.group(2)!!.toString()
+                val t = searchResults.group(3)!!.toInt()
+                val e = searchResults.group(4)!!.toInt()
+                return hunter(h, n, t, e)
+            }
+        } catch (e: Exception) {
+            return null
+        }
+        return null
+    }
+
+    private fun duf(d: String, e: Int, f: Int = 10): Int {
+        val str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/"
+        val g = str.toList()
+        val h = g.take(e)
+        val i = g.take(f)
+        val dList = d.reversed().toList()
+        var j = 0.0
+        for ((c, b) in dList.withIndex()) {
+            if (b in h) {
+                j += h.indexOf(b) * e.toDouble().pow(c)
+            }
+        }
+        var k = ""
+        while (j > 0) {
+            k = i[(j % f).toInt()] + k
+            j = (j - j % f) / f
+        }
+        return k.toIntOrNull() ?: 0
+    }
+
+    private fun hunter(h: String, n: String, t: Int, e: Int): String {
+        var result = ""
+        var i = 0
+        while (i < h.length) {
+            var j = 0
+            var s = ""
+            while (h[i] != n[e]) {
+                s += h[i]
+                i++
+            }
+            while (j < n.length) {
+                s = s.replace(n[j], j.digitToChar())
+                j++
+            }
+            result += (duf(s, e) - t).toChar()
+            i++
+        }
+        return result
+    }
+}

lib/streamsilk-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsilkextractor/StreamSilkExtractor.kt

@@ -0,0 +1,62 @@
+package eu.kanade.tachiyomi.lib.streamsilkextractor
+
+import eu.kanade.tachiyomi.animesource.model.Track
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+import okhttp3.internal.commonEmptyHeaders
+import uy.kohesive.injekt.injectLazy
+
+class StreamSilkExtractor(private val client: OkHttpClient, private val headers: Headers = commonEmptyHeaders) {
+
+    private val srcRegex = Regex("var urlPlay =\\s*\"(.*?m3u8.*?)\"")
+
+    private val subsRegex = Regex("jsonUrl = `([^`]*)`")
+
+    private val videoHeaders by lazy {
+        headers.newBuilder()
+            .set("Referer", "$STREAM_SILK_URL/")
+            .set("Origin", STREAM_SILK_URL)
+            .build()
+    }
+
+    private val json: Json by injectLazy()
+
+    private val playlistUtils by lazy { PlaylistUtils(client, videoHeaders) }
+
+    fun videosFromUrl(url: String, prefix: String) = videosFromUrl(url) { "${prefix}StreamSilk:$it" }
+
+    fun videosFromUrl(url: String, videoNameGen: (String) -> String = { quality -> "StreamSilk:$quality" }): List<Video> {
+        val document = client.newCall(GET(url)).execute().asJsoup()
+        val scriptData = document.select("script").firstOrNull { it.html().contains("h,u,n,t,e,r") }?.data() ?: return emptyList()
+        val deHunt = JsHunter(scriptData).dehunt() ?: return emptyList()
+        val link = extractLink(deHunt) ?: return emptyList()
+
+        val subs = buildList {
+            val subUrl = extractSubs(deHunt)
+            if (!subUrl.isNullOrEmpty()) {
+                runCatching {
+                    client.newCall(GET(subUrl, videoHeaders)).execute().body.string()
+                        .let { json.decodeFromString<List<SubtitleDto>>(it) }
+                        .forEach { add(Track(it.file, it.label)) }
+                }
+            }
+        }
+
+        return playlistUtils.extractFromHls(link, videoNameGen = videoNameGen, subtitleList = subs)
+    }
+
+    private fun extractLink(script: String) = srcRegex.find(script)?.groupValues?.get(1)?.trim()
+
+    private fun extractSubs(script: String) = subsRegex.find(script)?.groupValues?.get(1)?.trim()
+
+    @Serializable
+    data class SubtitleDto(val file: String, val label: String)
+}
+
+private const val STREAM_SILK_URL = "https://streamsilk.com"

lib/vidguard-extractor/build.gradle.kts

@@ -0,0 +1,8 @@
+plugins {
+    id("lib-android")
+}
+
+dependencies {
+    implementation(project(":lib:playlist-utils"))
+    implementation("org.mozilla:rhino:1.7.14")
+}

lib/vidguard-extractor/src/main/java/eu/kanade/tachiyomi/lib/vidguardextractor/VidGuardExtractor.kt

@@ -0,0 +1,104 @@
+package eu.kanade.tachiyomi.lib.vidguardextractor
+
+import android.util.Base64
+import android.util.Log
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import okhttp3.OkHttpClient
+import org.mozilla.javascript.Context
+import org.mozilla.javascript.NativeJSON
+import org.mozilla.javascript.NativeObject
+import org.mozilla.javascript.Scriptable
+import uy.kohesive.injekt.injectLazy
+
+class VidGuardExtractor(private val client: OkHttpClient) {
+
+    private val playlistUtils by lazy { PlaylistUtils(client) }
+
+    private val json: Json by injectLazy()
+
+    fun videosFromUrl(url: String, prefix: String) = videosFromUrl(url) { "${prefix}VidGuard:$it" }
+
+    fun videosFromUrl(url: String, videoNameGen: (String) -> String = { quality -> "VidGuard:$quality" }): List<Video> {
+        val res = client.newCall(GET(url)).execute().asJsoup()
+        val scriptData = res.selectFirst("script:containsData(eval)")?.data() ?: return emptyList()
+
+        val jsonStr2 = json.decodeFromString<SvgObject>(runJS2(scriptData))
+        val playlistUrl = sigDecode(jsonStr2.stream)
+
+        return playlistUtils.extractFromHls(playlistUrl, videoNameGen = videoNameGen)
+    }
+
+    private fun sigDecode(url: String): String {
+        val sig = url.split("sig=")[1].split("&")[0]
+        val t = sig.chunked(2)
+            .joinToString("") { (Integer.parseInt(it, 16) xor 2).toChar().toString() }
+            .let {
+                val padding = when (it.length % 4) {
+                    2 -> "=="
+                    3 -> "="
+                    else -> ""
+                }
+                String(Base64.decode((it + padding).toByteArray(Charsets.UTF_8), Base64.DEFAULT))
+            }
+            .dropLast(5)
+            .reversed()
+            .toCharArray()
+            .apply {
+                for (i in indices step 2) {
+                    if (i + 1 < size) {
+                        this[i] = this[i + 1].also { this[i + 1] = this[i] }
+                    }
+                }
+            }
+            .concatToString()
+            .dropLast(5)
+        return url.replace(sig, t)
+    }
+
+    private fun runJS2(hideMyHtmlContent: String): String {
+        var result = ""
+        val r = Runnable {
+            val rhino = Context.enter()
+            rhino.initSafeStandardObjects()
+            rhino.optimizationLevel = -1
+            val scope: Scriptable = rhino.initSafeStandardObjects()
+            scope.put("window", scope, scope)
+            try {
+                rhino.evaluateString(
+                    scope,
+                    hideMyHtmlContent,
+                    "JavaScript",
+                    1,
+                    null,
+                )
+                val svgObject = scope.get("svg", scope)
+                result = if (svgObject is NativeObject) {
+                    NativeJSON.stringify(Context.getCurrentContext(), scope, svgObject, null, null)
+                        .toString()
+                } else {
+                    Context.toString(svgObject)
+                }
+            } catch (e: Exception) {
+                Log.i("Error", e.toString())
+            } finally {
+                Context.exit()
+            }
+        }
+        val t = Thread(ThreadGroup("A"), r, "thread_rhino", 2000000) // StackSize 2Mb: Run in a thread because rhino requires more stack size for large scripts.
+        t.start()
+        t.join()
+        t.interrupt()
+        return result
+    }
+}
+
+@Serializable
+data class SvgObject(
+    val stream: String,
+    val hash: String,
+)

lib/vk-extractor/src/main/java/eu/kanade/tachiyomi/lib/vkextractor/VkExtractor.kt

@@ -20,14 +20,15 @@ class VkExtractor(private val client: OkHttpClient, private val headers: Headers
             .build()
     }
 
-    fun videosFromUrl(url: String, prefix: String = ""): List<Video> {
-        val data = client.newCall(GET(url, documentHeaders)).execute()
-            .body.string()
+    fun videosFromUrl(url: String, prefix: String) = videosFromUrl(url) { "${prefix}Vk:$it" }
+
+    fun videosFromUrl(url: String, videoNameGen: (String) -> String = { quality -> "Vk:$quality" }): List<Video> {
+        val data = client.newCall(GET(url, documentHeaders)).execute().body.string()
 
         return REGEX_VIDEO.findAll(data).map {
             val quality = it.groupValues[1]
             val videoUrl = it.groupValues[2].replace("\\/", "/")
-            Video(videoUrl, "${prefix}vk.com - ${quality}p", videoUrl, videoHeaders)
+            Video(videoUrl, videoNameGen("${quality}p"), videoUrl, videoHeaders)
         }.toList()
     }
 

src/de/animebase/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'Anime-Base'
     extClass = '.AnimeBase'
-    extVersionCode = 25
+    extVersionCode = 26
     isNsfw = true
 }
 
@@ -10,6 +10,7 @@ apply from: "$rootDir/common.gradle"
 dependencies {
     implementation(project(":lib:voe-extractor"))
     implementation(project(":lib:streamwish-extractor"))
+    implementation(project(":lib:vidguard-extractor"))
     implementation(project(":lib:playlist-utils"))
     implementation("dev.datlag.jsunpacker:jsunpacker:1.0.1")
 }

src/de/animebase/src/eu/kanade/tachiyomi/animeextension/de/animebase/AnimeBase.kt

@@ -4,7 +4,6 @@ import android.app.Application
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
 import eu.kanade.tachiyomi.animeextension.de.animebase.extractors.UnpackerExtractor
-import eu.kanade.tachiyomi.animeextension.de.animebase.extractors.VidGuardExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 import eu.kanade.tachiyomi.animesource.model.AnimesPage
@@ -13,6 +12,7 @@ import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
+import eu.kanade.tachiyomi.lib.vidguardextractor.VidGuardExtractor
 import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.network.POST

src/de/animebase/src/eu/kanade/tachiyomi/animeextension/de/animebase/extractors/VidGuardExtractor.kt

@@ -1,124 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.de.animebase.extractors
-
-import android.app.Application
-import android.os.Handler
-import android.os.Looper
-import android.util.Base64
-import android.webkit.JavascriptInterface
-import android.webkit.WebSettings
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.OkHttpClient
-import uy.kohesive.injekt.injectLazy
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-
-class VidGuardExtractor(private val client: OkHttpClient) {
-    private val context: Application by injectLazy()
-    private val handler by lazy { Handler(Looper.getMainLooper()) }
-
-    class JsObject(private val latch: CountDownLatch) {
-        var payload: String = ""
-
-        @JavascriptInterface
-        fun passPayload(passedPayload: String) {
-            payload = passedPayload
-            latch.countDown()
-        }
-    }
-
-    fun videosFromUrl(url: String): List<Video> {
-        val doc = client.newCall(GET(url)).execute().asJsoup()
-        val scriptUrl = doc.selectFirst("script[src*=ad/plugin]")
-            ?.absUrl("src")
-            ?: return emptyList()
-
-        val headers = Headers.headersOf("Referer", url)
-        val script = client.newCall(GET(scriptUrl, headers)).execute()
-            .body.string()
-
-        val sources = getSourcesFromScript(script, url)
-            .takeIf { it.isNotBlank() && it != "undefined" }
-            ?: return emptyList()
-
-        return sources.substringAfter("stream:[").substringBefore("}]")
-            .split('{')
-            .drop(1)
-            .mapNotNull { line ->
-                val resolution = line.substringAfter("Label\":\"").substringBefore('"')
-                val videoUrl = line.substringAfter("URL\":\"").substringBefore('"')
-                    .takeIf(String::isNotBlank)
-                    ?.let(::fixUrl)
-                    ?: return@mapNotNull null
-                Video(videoUrl, "VidGuard - $resolution", videoUrl, headers)
-            }
-    }
-
-    private fun getSourcesFromScript(script: String, url: String): String {
-        val latch = CountDownLatch(1)
-
-        var webView: WebView? = null
-
-        val jsinterface = JsObject(latch)
-
-        handler.post {
-            val webview = WebView(context)
-            webView = webview
-            with(webview.settings) {
-                javaScriptEnabled = true
-                domStorageEnabled = true
-                databaseEnabled = true
-                useWideViewPort = false
-                loadWithOverviewMode = false
-                cacheMode = WebSettings.LOAD_NO_CACHE
-            }
-
-            webview.addJavascriptInterface(jsinterface, "android")
-            webview.webViewClient = object : WebViewClient() {
-                override fun onPageFinished(view: WebView?, url: String?) {
-                    view?.clearCache(true)
-                    view?.clearFormData()
-                    view?.evaluateJavascript(script) {}
-                    view?.evaluateJavascript("window.android.passPayload(JSON.stringify(window.svg))") {}
-                }
-            }
-
-            webview.loadDataWithBaseURL(url, "<html></html>", "text/html", "UTF-8", null)
-        }
-
-        latch.await(5, TimeUnit.SECONDS)
-
-        handler.post {
-            webView?.stopLoading()
-            webView?.destroy()
-            webView = null
-        }
-
-        return jsinterface.payload
-    }
-
-    private fun fixUrl(url: String): String {
-        val httpUrl = url.toHttpUrl()
-        val originalSign = httpUrl.queryParameter("sig")!!
-        val newSign = originalSign.chunked(2).joinToString("") {
-            Char(it.toInt(16) xor 2).toString()
-        }
-            .let { String(Base64.decode(it, Base64.DEFAULT)) }
-            .substring(5)
-            .chunked(2)
-            .reversed()
-            .joinToString("")
-            .substring(5)
-
-        return httpUrl.newBuilder()
-            .removeAllQueryParameters("sig")
-            .addQueryParameter("sig", newSign)
-            .build()
-            .toString()
-    }
-}

src/de/moflixstream/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'Moflix-Stream'
     extClass = '.MoflixStream'
-    extVersionCode = 9
+    extVersionCode = 10
 }
 
 apply from: "$rootDir/common.gradle"
@@ -10,6 +10,7 @@ dependencies {
     implementation(project(':lib:streamvid-extractor'))
     implementation(project(':lib:streamwish-extractor'))
     implementation(project(':lib:streamtape-extractor'))
+    implementation(project(':lib:vidguard-extractor'))
     implementation(project(':lib:playlist-utils'))
     implementation "dev.datlag.jsunpacker:jsunpacker:1.0.1"
 }

src/de/moflixstream/src/eu/kanade/tachiyomi/animeextension/de/moflixstream/MoflixStream.kt

@@ -13,7 +13,6 @@ import eu.kanade.tachiyomi.animeextension.de.moflixstream.dto.SearchDto
 import eu.kanade.tachiyomi.animeextension.de.moflixstream.dto.SeasonPaginationDto
 import eu.kanade.tachiyomi.animeextension.de.moflixstream.dto.VideoResponseDto
 import eu.kanade.tachiyomi.animeextension.de.moflixstream.extractors.UnpackerExtractor
-import eu.kanade.tachiyomi.animeextension.de.moflixstream.extractors.VidGuardExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 import eu.kanade.tachiyomi.animesource.model.AnimesPage
@@ -24,6 +23,7 @@ import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
 import eu.kanade.tachiyomi.lib.streamvidextractor.StreamVidExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
+import eu.kanade.tachiyomi.lib.vidguardextractor.VidGuardExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.parseAs
 import kotlinx.serialization.json.Json

src/de/moflixstream/src/eu/kanade/tachiyomi/animeextension/de/moflixstream/extractors/VidGuardExtractor.kt

@@ -1,124 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.de.moflixstream.extractors
-
-import android.app.Application
-import android.os.Handler
-import android.os.Looper
-import android.util.Base64
-import android.webkit.JavascriptInterface
-import android.webkit.WebSettings
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.OkHttpClient
-import uy.kohesive.injekt.injectLazy
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-
-class VidGuardExtractor(private val client: OkHttpClient) {
-    private val context: Application by injectLazy()
-    private val handler by lazy { Handler(Looper.getMainLooper()) }
-
-    class JsObject(private val latch: CountDownLatch) {
-        var payload: String = ""
-
-        @JavascriptInterface
-        fun passPayload(passedPayload: String) {
-            payload = passedPayload
-            latch.countDown()
-        }
-    }
-
-    fun videosFromUrl(url: String): List<Video> {
-        val doc = client.newCall(GET(url)).execute().asJsoup()
-        val scriptUrl = doc.selectFirst("script[src*=ad/plugin]")
-            ?.absUrl("src")
-            ?: return emptyList()
-
-        val headers = Headers.headersOf("Referer", url)
-        val script = client.newCall(GET(scriptUrl, headers)).execute()
-            .body.string()
-
-        val sources = getSourcesFromScript(script, url)
-            .takeIf { it.isNotBlank() && it != "undefined" }
-            ?: return emptyList()
-
-        return sources.substringAfter("stream:[").substringBefore("}]")
-            .split('{')
-            .drop(1)
-            .mapNotNull { line ->
-                val resolution = line.substringAfter("Label\":\"").substringBefore('"')
-                val videoUrl = line.substringAfter("URL\":\"").substringBefore('"')
-                    .takeIf(String::isNotBlank)
-                    ?.let(::fixUrl)
-                    ?: return@mapNotNull null
-                Video(videoUrl, "VidGuard - $resolution", videoUrl, headers)
-            }
-    }
-
-    private fun getSourcesFromScript(script: String, url: String): String {
-        val latch = CountDownLatch(1)
-
-        var webView: WebView? = null
-
-        val jsinterface = JsObject(latch)
-
-        handler.post {
-            val webview = WebView(context)
-            webView = webview
-            with(webview.settings) {
-                javaScriptEnabled = true
-                domStorageEnabled = true
-                databaseEnabled = true
-                useWideViewPort = false
-                loadWithOverviewMode = false
-                cacheMode = WebSettings.LOAD_NO_CACHE
-            }
-
-            webview.addJavascriptInterface(jsinterface, "android")
-            webview.webViewClient = object : WebViewClient() {
-                override fun onPageFinished(view: WebView?, url: String?) {
-                    view?.clearCache(true)
-                    view?.clearFormData()
-                    view?.evaluateJavascript(script) {}
-                    view?.evaluateJavascript("window.android.passPayload(JSON.stringify(window.svg))") {}
-                }
-            }
-
-            webview.loadDataWithBaseURL(url, "<html></html>", "text/html", "UTF-8", null)
-        }
-
-        latch.await(5, TimeUnit.SECONDS)
-
-        handler.post {
-            webView?.stopLoading()
-            webView?.destroy()
-            webView = null
-        }
-
-        return jsinterface.payload
-    }
-
-    private fun fixUrl(url: String): String {
-        val httpUrl = url.toHttpUrl()
-        val originalSign = httpUrl.queryParameter("sig")!!
-        val newSign = originalSign.chunked(2).joinToString("") {
-            Char(it.toInt(16) xor 2).toString()
-        }
-            .let { String(Base64.decode(it, Base64.DEFAULT)) }
-            .substring(5)
-            .chunked(2)
-            .reversed()
-            .joinToString("")
-            .substring(5)
-
-        return httpUrl.newBuilder()
-            .removeAllQueryParameters("sig")
-            .addQueryParameter("sig", newSign)
-            .build()
-            .toString()
-    }
-}

src/en/oppaistream/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'Oppai Stream'
     extClass = '.OppaiStream'
-    extVersionCode = 5
+    extVersionCode = 6
     isNsfw = true
 }
 

src/en/oppaistream/src/eu/kanade/tachiyomi/animeextension/en/oppaistream/OppaiStream.kt

@@ -14,24 +14,21 @@ import eu.kanade.tachiyomi.animesource.model.SAnime
 import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.Track
 import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.util.asJsoup
 import eu.kanade.tachiyomi.util.parseAs
-import kotlinx.serialization.json.Json
 import okhttp3.FormBody
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
 import okhttp3.Response
-import org.jsoup.nodes.Document
 import org.jsoup.nodes.Element
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import uy.kohesive.injekt.injectLazy
 import java.net.URLEncoder.encode
 
-class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
+class OppaiStream : AnimeHttpSource(), ConfigurableAnimeSource {
 
     override val name = "Oppai Stream"
 
@@ -47,30 +44,18 @@ class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
         Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
     }
 
-    private val json: Json by injectLazy()
+    private val searchAnimeSelector = "div.episode-shown > div > a"
 
     // ============================== Popular ===============================
     override fun popularAnimeRequest(page: Int) = GET("$baseUrl/$SEARCH_PATH?order=views&page=$page&limit=$SEARCH_LIMIT")
 
     override fun popularAnimeParse(response: Response) = searchAnimeParse(response)
 
-    override fun popularAnimeSelector() = searchAnimeSelector()
-
-    override fun popularAnimeFromElement(element: Element) = searchAnimeFromElement(element)
-
-    override fun popularAnimeNextPageSelector() = null
-
     // =============================== Latest ===============================
     override fun latestUpdatesRequest(page: Int) = GET("$baseUrl/$SEARCH_PATH?order=uploaded&page=$page&limit=$SEARCH_LIMIT")
 
     override fun latestUpdatesParse(response: Response) = searchAnimeParse(response)
 
-    override fun latestUpdatesSelector() = searchAnimeSelector()
-
-    override fun latestUpdatesFromElement(element: Element) = searchAnimeFromElement(element)
-
-    override fun latestUpdatesNextPageSelector() = null
-
     // =============================== Search ===============================
     override fun getFilterList() = FILTERS
 
@@ -107,29 +92,23 @@ class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
         return GET(url, headers)
     }
 
-    override fun searchAnimeSelector() = "div.episode-shown > div > a"
-
-    override fun searchAnimeNextPageSelector() = null
-
     override fun searchAnimeParse(response: Response): AnimesPage {
         val document = response.asJsoup()
-        val elements = document.select(searchAnimeSelector())
-
+        val elements = document.select(searchAnimeSelector)
         val anime = elements.map(::searchAnimeFromElement).distinctBy { it.title }
-
         val hasNextPage = elements.size >= SEARCH_LIMIT
-
         return AnimesPage(anime, hasNextPage)
     }
 
-    override fun searchAnimeFromElement(element: Element) = SAnime.create().apply {
+    private fun searchAnimeFromElement(element: Element) = SAnime.create().apply {
         thumbnail_url = element.selectFirst("img.cover-img-in")?.attr("abs:src")
         title = element.selectFirst(".title-ep")!!.text().replace(TITLE_CLEANUP_REGEX, "")
-        setUrlWithoutDomain(element.attr("exur").fixLink())
+        setUrlWithoutDomain(element.attr("exur").ifEmpty { element.attr("href") }.fixLink())
     }
 
     // =========================== Anime Details ============================
-    override fun animeDetailsParse(document: Document) = SAnime.create().apply {
+    override fun animeDetailsParse(response: Response) = SAnime.create().apply {
+        val document = response.asJsoup()
         // Fetch from from Anilist when "Anilist Cover" is selected in settings
         val name = document.selectFirst("div.episode-info > h1")!!.text().substringBefore(" Ep ")
         title = name
@@ -159,10 +138,8 @@ class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
         return doc.select("div.more-same-eps .in-main-gr > a").map(::episodeFromElement).reversed()
     }
 
-    override fun episodeListSelector() = "div.more-same-eps > div > div > a"
-
-    override fun episodeFromElement(element: Element) = SEpisode.create().apply {
-        setUrlWithoutDomain(element.attr("exur").fixLink())
+    private fun episodeFromElement(element: Element) = SEpisode.create().apply {
+        setUrlWithoutDomain(element.attr("exur").ifEmpty { element.attr("href") }.fixLink())
         val num = element.selectFirst("font.ep")?.text() ?: "1"
         name = "Episode $num"
         episode_number = num.toFloatOrNull() ?: 1F
@@ -189,10 +166,6 @@ class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
             }
     }
 
-    override fun videoListSelector() = throw UnsupportedOperationException()
-
-    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
-
     override fun List<Video>.sort(): List<Video> {
         val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
 
@@ -201,8 +174,6 @@ class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
         ).reversed()
     }
 
-    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
-
     // ============================== Settings ==============================
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {
@@ -305,7 +276,7 @@ class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
 
         private const val PREF_QUALITY_KEY = "preferred_quality"
         private const val PREF_QUALITY_TITLE = "Preferred quality"
-        private const val PREF_QUALITY_DEFAULT = "720p"
+        private const val PREF_QUALITY_DEFAULT = "1080p"
         private val PREF_QUALITY_ENTRIES = arrayOf("2160p", "1080p", "720p")
         private val PREF_QUALITY_VALUES = PREF_QUALITY_ENTRIES
 
@@ -319,7 +290,7 @@ class OppaiStream : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
 
         private const val PREF_COVER_QUALITY_KEY = "preferred_cover_quality"
         private const val PREF_COVER_QUALITY_TITLE = "Preferred Anilist cover quality - Beta"
-        private const val PREF_COVER_QUALITY_DEFAULT = "large"
+        private const val PREF_COVER_QUALITY_DEFAULT = "extraLarge"
         private val PREF_COVER_QUALITY_ENTRIES = arrayOf("Extra Large", "Large")
         private val PREF_COVER_QUALITY_VALUES = arrayOf("extraLarge", "large")
     }

src/es/animefenix/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'Animefenix'
     extClass = '.Animefenix'
-    extVersionCode = 39
+    extVersionCode = 40
 }
 
 apply from: "$rootDir/common.gradle"

src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/AnimeFenixFilters.kt

@@ -0,0 +1,161 @@
+package eu.kanade.tachiyomi.animeextension.es.animefenix
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import java.util.Calendar
+
+object AnimeFenixFilters {
+    open class QueryPartFilter(displayName: String, val vals: Array<Pair<String, String>>) : AnimeFilter.Select<String>(
+        displayName,
+        vals.map { it.first }.toTypedArray(),
+    ) {
+        fun toQueryPart(name: String) = vals[state].second.takeIf { it.isNotEmpty() }?.let { "&$name=${vals[state].second}" } ?: run { "" }
+    }
+
+    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
+
+    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
+
+    private inline fun <reified R> AnimeFilterList.parseCheckbox(
+        options: Array<Pair<String, String>>,
+        name: String,
+    ): String {
+        return (this.getFirst<R>() as CheckBoxFilterList).state
+            .mapNotNull { checkbox ->
+                if (checkbox.state) {
+                    options.find { it.first == checkbox.name }!!.second
+                } else {
+                    null
+                }
+            }.joinToString("&$name[]=").let {
+                if (it.isBlank()) {
+                    ""
+                } else {
+                    "&$name[]=$it"
+                }
+            }
+    }
+
+    private inline fun <reified R> AnimeFilterList.asQueryPart(name: String): String {
+        return (this.getFirst<R>() as QueryPartFilter).toQueryPart(name)
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return this.filterIsInstance<R>().first()
+    }
+
+    private fun String.changePrefix() = this.takeIf { it.startsWith("&") }?.let { this.replaceFirst("&", "?") } ?: run { this }
+
+    data class FilterSearchParams(val filter: String = "") { fun getQuery() = filter.changePrefix() }
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+        return FilterSearchParams(
+            filters.parseCheckbox<GenresFilter>(AnimeFenixFiltersData.GENRES, "genero") +
+                filters.parseCheckbox<YearsFilter>(AnimeFenixFiltersData.YEARS, "year") +
+                filters.parseCheckbox<TypesFilter>(AnimeFenixFiltersData.TYPES, "type") +
+                filters.parseCheckbox<StateFilter>(AnimeFenixFiltersData.STATE, "estado") +
+                filters.asQueryPart<SortFilter>("order"),
+        )
+    }
+
+    val FILTER_LIST get() = AnimeFilterList(
+        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
+        GenresFilter(),
+        YearsFilter(),
+        TypesFilter(),
+        StateFilter(),
+        SortFilter(),
+    )
+
+    class GenresFilter : CheckBoxFilterList("Género", AnimeFenixFiltersData.GENRES.map { CheckBoxVal(it.first, false) })
+
+    class YearsFilter : CheckBoxFilterList("Año", AnimeFenixFiltersData.YEARS.map { CheckBoxVal(it.first, false) })
+
+    class TypesFilter : CheckBoxFilterList("Tipo", AnimeFenixFiltersData.TYPES.map { CheckBoxVal(it.first, false) })
+
+    class StateFilter : CheckBoxFilterList("Estado", AnimeFenixFiltersData.STATE.map { CheckBoxVal(it.first, false) })
+
+    class SortFilter : QueryPartFilter("Orden", AnimeFenixFiltersData.SORT)
+
+    private object AnimeFenixFiltersData {
+        val YEARS = (1990..Calendar.getInstance().get(Calendar.YEAR)).map { Pair("$it", "$it") }.reversed().toTypedArray()
+
+        val TYPES = arrayOf(
+            Pair("TV", "tv"),
+            Pair("Película", "movie"),
+            Pair("Especial", "special"),
+            Pair("OVA", "ova"),
+            Pair("DONGHUA", "donghua"),
+        )
+
+        val STATE = arrayOf(
+            Pair("Emisión", "1"),
+            Pair("Finalizado", "2"),
+            Pair("Próximamente", "3"),
+            Pair("En Cuarentena", "4"),
+        )
+
+        val SORT = arrayOf(
+            Pair("Por Defecto", "default"),
+            Pair("Recientemente Actualizados", "updated"),
+            Pair("Recientemente Agregados", "added"),
+            Pair("Nombre A-Z", "title"),
+            Pair("Calificación", "likes"),
+            Pair("Más Vistos", "visits"),
+        )
+
+        val GENRES = arrayOf(
+            Pair("Acción", "accion"),
+            Pair("Ángeles", "angeles"),
+            Pair("Artes Marciales", "artes-marciales"),
+            Pair("Aventura", "aventura"),
+            Pair("Ciencia Ficción", "Ciencia Ficción"),
+            Pair("Comedia", "comedia"),
+            Pair("Cyberpunk", "cyberpunk"),
+            Pair("Demonios", "demonios"),
+            Pair("Deportes", "deportes"),
+            Pair("Dragones", "dragones"),
+            Pair("Drama", "drama"),
+            Pair("Ecchi", "ecchi"),
+            Pair("Escolares", "escolares"),
+            Pair("Fantasía", "fantasia"),
+            Pair("Gore", "gore"),
+            Pair("Harem", "harem"),
+            Pair("Histórico", "historico"),
+            Pair("Horror", "horror"),
+            Pair("Infantil", "infantil"),
+            Pair("Isekai", "isekai"),
+            Pair("Josei", "josei"),
+            Pair("Juegos", "juegos"),
+            Pair("Magia", "magia"),
+            Pair("Mecha", "mecha"),
+            Pair("Militar", "militar"),
+            Pair("Misterio", "misterio"),
+            Pair("Música", "Musica"),
+            Pair("Ninjas", "ninjas"),
+            Pair("Parodia", "parodia"),
+            Pair("Policía", "policia"),
+            Pair("Psicológico", "psicologico"),
+            Pair("Recuerdos de la vida", "Recuerdos de la vida"),
+            Pair("Romance", "romance"),
+            Pair("Samurai", "samurai"),
+            Pair("Sci-Fi", "sci-fi"),
+            Pair("Seinen", "seinen"),
+            Pair("Shoujo", "shoujo"),
+            Pair("Shoujo Ai", "shoujo-ai"),
+            Pair("Shounen", "shounen"),
+            Pair("Slice of life", "slice-of-life"),
+            Pair("Sobrenatural", "sobrenatural"),
+            Pair("Space", "space"),
+            Pair("Spokon", "spokon"),
+            Pair("Steampunk", "steampunk"),
+            Pair("Superpoder", "superpoder"),
+            Pair("Thriller", "thriller"),
+            Pair("Vampiro", "vampiro"),
+            Pair("Yaoi", "yaoi"),
+            Pair("Yuri", "yuri"),
+            Pair("Zombies", "zombies"),
+        )
+    }
+}

src/es/animefenix/src/eu/kanade/tachiyomi/animeextension/es/animefenix/Animefenix.kt

@@ -5,7 +5,6 @@ import android.content.SharedPreferences
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-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
@@ -84,38 +83,12 @@ class Animefenix : ConfigurableAnimeSource, AnimeHttpSource() {
     override fun latestUpdatesParse(response: Response) = popularAnimeParse(response)
 
     override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val yearFilter = filters.find { it is YearFilter } as YearFilter
-        val stateFilter = filters.find { it is StateFilter } as StateFilter
-        val typeFilter = filters.find { it is TypeFilter } as TypeFilter
-        val orderByFilter = filters.find { it is OrderByFilter } as OrderByFilter
-
-        val genreFilter = (filters.find { it is TagFilter } as TagFilter).state.filter { it.state }
-
-        var filterUrl = "$baseUrl/animes?"
-        if (query.isNotBlank()) {
-            filterUrl += "&q=$query"
-        } // search by name
-        if (genreFilter.isNotEmpty()) {
-            genreFilter.forEach {
-                filterUrl += "&genero[]=${it.name}"
-            }
-        } // search by genre
-        if (yearFilter.state.isNotBlank()) {
-            filterUrl += "&year[]=${yearFilter.state}"
-        } // search by year
-        if (stateFilter.state != 0) {
-            filterUrl += "&estado[]=${stateFilter.toUriPart()}"
-        } // search by state
-        if (typeFilter.state != 0) {
-            filterUrl += "&type[]=${typeFilter.toUriPart()}"
-        } // search by type
-        filterUrl += "&order=${orderByFilter.toUriPart()}"
-        filterUrl += "&page=$page" // add page
+        val params = AnimeFenixFilters.getSearchParameters(filters)
 
         return when {
-            genreFilter.isEmpty() || yearFilter.state.isNotBlank() ||
-                stateFilter.state != 0 || typeFilter.state != 0 || query.isNotBlank() -> GET(filterUrl, headers)
-            else -> GET("$baseUrl/animes?order=likes&page=$page ")
+            query.isNotBlank() -> GET("$baseUrl/animes?q=$query&page=$page", headers)
+            params.filter.isNotBlank() -> GET("$baseUrl/animes${params.getQuery()}&page=$page", headers)
+            else -> GET("$baseUrl/animes?order=likes&page=$page")
         }
     }
 
@@ -273,110 +246,7 @@ class Animefenix : ConfigurableAnimeSource, AnimeHttpSource() {
         }
     }
 
-    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        TagFilter("Generos", checkboxesFrom(genreList)),
-        StateFilter(),
-        TypeFilter(),
-        OrderByFilter(),
-        YearFilter(),
-    )
-
-    private val genreList = arrayOf(
-        Pair("Acción", "acción"),
-        Pair("Aventura", "aventura"),
-        Pair("Angeles", "angeles"),
-        Pair("Artes Marciales", "artes-marciales"),
-        Pair("Ciencia Ficcion", "ciencia-ficcion"),
-        Pair("Comedia", "comedia"),
-        Pair("Cyberpunk", "cyberpunk"),
-        Pair("Demonios", "demonios"),
-        Pair("Deportes", "deportes"),
-        Pair("Dragones", "dragones"),
-        Pair("Drama", "drama"),
-        Pair("Ecchi", "ecchi"),
-        Pair("Escolares", "escolares"),
-        Pair("Fantasía", "fantasía"),
-        Pair("Gore", "gore"),
-        Pair("Harem", "harem"),
-        Pair("Historico", "historico"),
-        Pair("Horror", "horror"),
-        Pair("Infantil", "infantil"),
-        Pair("Isekai", "isekai"),
-        Pair("Josei", "josei"),
-        Pair("Juegos", "juegos"),
-        Pair("Magia", "magia"),
-        Pair("Mecha", "mecha"),
-        Pair("Militar", "militar"),
-        Pair("Misterio", "misterio"),
-        Pair("Música", "música"),
-        Pair("Ninjas", "ninjas"),
-        Pair("Parodias", "parodias"),
-        Pair("Policia", "policia"),
-        Pair("Psicológico", "psicológico"),
-        Pair("Recuerdos de la vida", "recuerdos-de-la-vida"),
-        Pair("Romance", "romance"),
-        Pair("Samurai", "samurai"),
-        Pair("Sci-Fi", "sci-fi"),
-        Pair("Seinen", "seinen"),
-        Pair("Shoujo", "shoujo"),
-        Pair("Shonen", "shonen"),
-        Pair("Slice of life", "slice-of-life"),
-        Pair("Sobrenatural", "sobrenatural"),
-        Pair("Space", "space"),
-        Pair("Spokon", "spokon"),
-        Pair("SteamPunk", "steampunk"),
-        Pair("SuperPoder", "superpoder"),
-        Pair("Vampiros", "vampiros"),
-        Pair("Yaoi", "yaoi"),
-        Pair("Yuri", "yuri"),
-    )
-
-    private fun checkboxesFrom(tagArray: Array<Pair<String, String>>): List<TagCheckBox> = tagArray.map { TagCheckBox(it.second) }
-
-    class TagCheckBox(tag: String) : AnimeFilter.CheckBox(tag, false)
-
-    class TagFilter(name: String, checkBoxes: List<TagCheckBox>) : AnimeFilter.Group<TagCheckBox>(name, checkBoxes)
-
-    private class YearFilter : AnimeFilter.Text("Año")
-
-    private class StateFilter : UriPartFilter(
-        "Estado",
-        arrayOf(
-            Pair("<Seleccionar>", ""),
-            Pair("Emision", "1"),
-            Pair("Finalizado", "2"),
-            Pair("Proximamente", "3"),
-            Pair("En Cuarentena", "4"),
-        ),
-    )
-
-    private class TypeFilter : UriPartFilter(
-        "Tipo",
-        arrayOf(
-            Pair("<Seleccionar>", ""),
-            Pair("TV", "tv"),
-            Pair("Pelicula", "movie"),
-            Pair("Especial", "special"),
-            Pair("OVA", "ova"),
-        ),
-    )
-
-    private class OrderByFilter : UriPartFilter(
-        "Ordenar Por",
-        arrayOf(
-            Pair("Por defecto", "default"),
-            Pair("Recientemente Actualizados", "updated"),
-            Pair("Recientemente Agregados", "added"),
-            Pair("Nombre A-Z", "title"),
-            Pair("Calificación", "likes"),
-            Pair("Más vistos", "visits"),
-        ),
-    )
-
-    private open class UriPartFilter(displayName: String, val vals: Array<Pair<String, String>>) :
-        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
-        fun toUriPart() = vals[state].second
-    }
+    override fun getFilterList(): AnimeFilterList = AnimeFenixFilters.FILTER_LIST
 
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {

src/es/animeflv/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeFLV'
     extClass = '.AnimeFlv'
-    extVersionCode = 56
+    extVersionCode = 57
 }
 
 apply from: "$rootDir/common.gradle"

src/es/animeflv/src/eu/kanade/tachiyomi/animeextension/es/animeflv/AnimeFlv.kt

@@ -5,7 +5,6 @@ import android.content.SharedPreferences
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 import eu.kanade.tachiyomi.animesource.model.SAnime
 import eu.kanade.tachiyomi.animesource.model.SEpisode
@@ -132,116 +131,16 @@ class AnimeFlv : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
     override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
 
     override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val filterList = if (filters.isEmpty()) getFilterList() else filters
-        val genreFilter = filterList.find { it is GenreFilter } as GenreFilter
-        val stateFilter = filterList.find { it is StateFilter } as StateFilter
-        val typeFilter = filterList.find { it is TypeFilter } as TypeFilter
-        val orderByFilter = filterList.find { it is OrderByFilter } as OrderByFilter
-        var uri = "$baseUrl/browse?"
-        uri += if (query.isNotBlank()) "&q=$query" else ""
-        uri += if (genreFilter.state != 0) "&genre[]=${genreFilter.toUriPart()}" else ""
-        uri += if (stateFilter.state != 0) "&status[]=${stateFilter.toUriPart()}" else ""
-        uri += if (typeFilter.state != 0) "&type[]=${typeFilter.toUriPart()}" else ""
-        uri += "&order=${orderByFilter.toUriPart()}"
-        uri += "&page=$page"
+        val params = AnimeFlvFilters.getSearchParameters(filters)
+
         return when {
-            query.isNotBlank() || genreFilter.state != 0 || stateFilter.state != 0 || orderByFilter.state != 0 || typeFilter.state != 0 -> GET(uri)
-            else -> GET("$baseUrl/browse?page=$page&order=rating")
+            query.isNotBlank() -> GET("$baseUrl/browse?q=$query&page=$page")
+            params.filter.isNotBlank() -> GET("$baseUrl/browse${params.getQuery()}&page=$page")
+            else -> popularAnimeRequest(page)
         }
     }
 
-    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
-        GenreFilter(),
-        StateFilter(),
-        TypeFilter(),
-        OrderByFilter(),
-    )
-
-    private class GenreFilter : UriPartFilter(
-        "Géneros",
-        arrayOf(
-            Pair("<Selecionar>", "all"),
-            Pair("Todo", "all"),
-            Pair("Acción", "accion"),
-            Pair("Artes Marciales", "artes_marciales"),
-            Pair("Aventuras", "aventura"),
-            Pair("Carreras", "carreras"),
-            Pair("Ciencia Ficción", "ciencia_ficcion"),
-            Pair("Comedia", "comedia"),
-            Pair("Demencia", "demencia"),
-            Pair("Demonios", "demonios"),
-            Pair("Deportes", "deportes"),
-            Pair("Drama", "drama"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Escolares", "escolares"),
-            Pair("Espacial", "espacial"),
-            Pair("Fantasía", "fantasia"),
-            Pair("Harem", "harem"),
-            Pair("Historico", "historico"),
-            Pair("Infantil", "infantil"),
-            Pair("Josei", "josei"),
-            Pair("Juegos", "juegos"),
-            Pair("Magia", "magia"),
-            Pair("Mecha", "mecha"),
-            Pair("Militar", "militar"),
-            Pair("Misterio", "misterio"),
-            Pair("Música", "musica"),
-            Pair("Parodia", "parodia"),
-            Pair("Policía", "policia"),
-            Pair("Psicológico", "psicologico"),
-            Pair("Recuentos de la vida", "recuentos_de_la_vida"),
-            Pair("Romance", "romance"),
-            Pair("Samurai", "samurai"),
-            Pair("Seinen", "seinen"),
-            Pair("Shoujo", "shoujo"),
-            Pair("Shounen", "shounen"),
-            Pair("Sobrenatural", "sobrenatural"),
-            Pair("Superpoderes", "superpoderes"),
-            Pair("Suspenso", "suspenso"),
-            Pair("Terror", "terror"),
-            Pair("Vampiros", "vampiros"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-        ),
-    )
-
-    private class StateFilter : UriPartFilter(
-        "Estado",
-        arrayOf(
-            Pair("<Seleccionar>", ""),
-            Pair("En emisión", "1"),
-            Pair("Finalizado", "2"),
-            Pair("Próximamente", "3"),
-        ),
-    )
-
-    private class TypeFilter : UriPartFilter(
-        "Tipo",
-        arrayOf(
-            Pair("<Seleccionar>", ""),
-            Pair("TV", "tv"),
-            Pair("Película", "movie"),
-            Pair("Especial", "special"),
-            Pair("OVA", "ova"),
-        ),
-    )
-
-    private class OrderByFilter : UriPartFilter(
-        "Ordenar Por",
-        arrayOf(
-            Pair("Por defecto", "default"),
-            Pair("Recientemente Actualizados", "updated"),
-            Pair("Recientemente Agregados", "added"),
-            Pair("Nombre A-Z", "title"),
-            Pair("Calificación", "rating"),
-        ),
-    )
-
-    private open class UriPartFilter(displayName: String, val vals: Array<Pair<String, String>>) :
-        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
-        fun toUriPart() = vals[state].second
-    }
+    override fun getFilterList(): AnimeFilterList = AnimeFlvFilters.FILTER_LIST
 
     override fun searchAnimeFromElement(element: Element) = popularAnimeFromElement(element)
 

src/es/animeflv/src/eu/kanade/tachiyomi/animeextension/es/animeflv/AnimeFlvFilters.kt

@@ -0,0 +1,148 @@
+package eu.kanade.tachiyomi.animeextension.es.animeflv
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import java.util.Calendar
+
+object AnimeFlvFilters {
+    open class QueryPartFilter(displayName: String, val vals: Array<Pair<String, String>>) : AnimeFilter.Select<String>(
+        displayName,
+        vals.map { it.first }.toTypedArray(),
+    ) {
+        fun toQueryPart(name: String) = vals[state].second.takeIf { it.isNotEmpty() }?.let { "&$name=${vals[state].second}" } ?: run { "" }
+    }
+
+    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
+
+    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
+
+    private inline fun <reified R> AnimeFilterList.parseCheckbox(
+        options: Array<Pair<String, String>>,
+        name: String,
+    ): String {
+        return (this.getFirst<R>() as CheckBoxFilterList).state
+            .mapNotNull { checkbox ->
+                if (checkbox.state) {
+                    options.find { it.first == checkbox.name }!!.second
+                } else {
+                    null
+                }
+            }.joinToString("&$name[]=").let {
+                if (it.isBlank()) {
+                    ""
+                } else {
+                    "&$name[]=$it"
+                }
+            }
+    }
+
+    private inline fun <reified R> AnimeFilterList.asQueryPart(name: String): String {
+        return (this.getFirst<R>() as QueryPartFilter).toQueryPart(name)
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return this.filterIsInstance<R>().first()
+    }
+
+    private fun String.changePrefix() = this.takeIf { it.startsWith("&") }?.let { this.replaceFirst("&", "?") } ?: run { this }
+
+    data class FilterSearchParams(val filter: String = "") { fun getQuery() = filter.changePrefix() }
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+        return FilterSearchParams(
+            filters.parseCheckbox<GenresFilter>(AnimeFlvFiltersData.GENRES, "genre") +
+                filters.parseCheckbox<YearsFilter>(AnimeFlvFiltersData.YEARS, "year") +
+                filters.parseCheckbox<TypesFilter>(AnimeFlvFiltersData.TYPES, "type") +
+                filters.parseCheckbox<StateFilter>(AnimeFlvFiltersData.STATE, "status") +
+                filters.asQueryPart<SortFilter>("order"),
+        )
+    }
+
+    val FILTER_LIST get() = AnimeFilterList(
+        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
+        GenresFilter(),
+        YearsFilter(),
+        TypesFilter(),
+        StateFilter(),
+        SortFilter(),
+    )
+
+    class GenresFilter : CheckBoxFilterList("Género", AnimeFlvFiltersData.GENRES.map { CheckBoxVal(it.first, false) })
+
+    class YearsFilter : CheckBoxFilterList("Año", AnimeFlvFiltersData.YEARS.map { CheckBoxVal(it.first, false) })
+
+    class TypesFilter : CheckBoxFilterList("Tipo", AnimeFlvFiltersData.TYPES.map { CheckBoxVal(it.first, false) })
+
+    class StateFilter : CheckBoxFilterList("Estado", AnimeFlvFiltersData.STATE.map { CheckBoxVal(it.first, false) })
+
+    class SortFilter : QueryPartFilter("Orden", AnimeFlvFiltersData.SORT)
+
+    private object AnimeFlvFiltersData {
+        val YEARS = (1990..Calendar.getInstance().get(Calendar.YEAR)).map { Pair("$it", "$it") }.reversed().toTypedArray()
+
+        val TYPES = arrayOf(
+            Pair("TV", "tv"),
+            Pair("Película", "movie"),
+            Pair("Especial", "special"),
+            Pair("OVA", "ova"),
+        )
+
+        val STATE = arrayOf(
+            Pair("En emisión", "1"),
+            Pair("Finalizado", "2"),
+            Pair("Próximamente", "3"),
+        )
+
+        val SORT = arrayOf(
+            Pair("Por Defecto", "default"),
+            Pair("Recientemente Actualizados", "updated"),
+            Pair("Recientemente Agregados", "added"),
+            Pair("Nombre A-Z", "title"),
+            Pair("Calificación", "rating"),
+        )
+
+        val GENRES = arrayOf(
+            Pair("Acción", "accion"),
+            Pair("Artes Marciales", "artes-marciales"),
+            Pair("Aventuras", "aventura"),
+            Pair("Carreras", "carreras"),
+            Pair("Ciencia Ficción", "ciencia-ficcion"),
+            Pair("Comedia", "comedia"),
+            Pair("Demencia", "demencia"),
+            Pair("Demonios", "demonios"),
+            Pair("Deportes", "deportes"),
+            Pair("Drama", "drama"),
+            Pair("Ecchi", "ecchi"),
+            Pair("Escolares", "escolares"),
+            Pair("Espacial", "espacial"),
+            Pair("Fantasía", "fantasia"),
+            Pair("Harem", "harem"),
+            Pair("Historico", "historico"),
+            Pair("Infantil", "infantil"),
+            Pair("Josei", "josei"),
+            Pair("Juegos", "juegos"),
+            Pair("Magia", "magia"),
+            Pair("Mecha", "mecha"),
+            Pair("Militar", "militar"),
+            Pair("Misterio", "misterio"),
+            Pair("Música", "musica"),
+            Pair("Parodia", "parodia"),
+            Pair("Policía", "policia"),
+            Pair("Psicológico", "psicologico"),
+            Pair("Recuentos de la vida", "recuentos-de-la-vida"),
+            Pair("Romance", "romance"),
+            Pair("Samurai", "samurai"),
+            Pair("Seinen", "seinen"),
+            Pair("Shoujo", "shoujo"),
+            Pair("Shounen", "shounen"),
+            Pair("Sobrenatural", "sobrenatural"),
+            Pair("Superpoderes", "superpoderes"),
+            Pair("Suspenso", "suspenso"),
+            Pair("Terror", "terror"),
+            Pair("Vampiros", "vampiros"),
+            Pair("Yaoi", "yaoi"),
+            Pair("Yuri", "yuri"),
+        )
+    }
+}

src/es/asialiveaction/build.gradle

@@ -1,27 +1,15 @@
 ext {
     extName = 'AsiaLiveAction'
     extClass = '.AsiaLiveAction'
-    extVersionCode = 31
+    extVersionCode = 32
 }
 
 apply from: "$rootDir/common.gradle"
 
 dependencies {
-    implementation(project(':lib:vudeo-extractor'))
-    implementation(project(':lib:uqload-extractor'))
-    implementation(project(':lib:streamwish-extractor'))
     implementation(project(':lib:filemoon-extractor'))
-    implementation(project(':lib:streamlare-extractor'))
-    implementation(project(':lib:yourupload-extractor'))
-    implementation(project(':lib:streamtape-extractor'))
-    implementation(project(':lib:dood-extractor'))
-    implementation(project(':lib:voe-extractor'))
     implementation(project(':lib:okru-extractor'))
-    implementation(project(':lib:mp4upload-extractor'))
-    implementation(project(':lib:mixdrop-extractor'))
-    implementation(project(':lib:burstcloud-extractor'))
-    implementation(project(':lib:fastream-extractor'))
-    implementation(project(':lib:upstream-extractor'))
-    implementation(project(':lib:streamhidevid-extractor'))
+    implementation(project(':lib:streamwish-extractor'))
     implementation(project(':lib:vk-extractor'))
+    implementation(project(':lib:vidguard-extractor'))
 }

src/es/asialiveaction/src/eu/kanade/tachiyomi/animeextension/es/asialiveaction/AsiaLiveAction.kt

@@ -4,7 +4,6 @@ import android.app.Application
 import android.content.SharedPreferences
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animeextension.es.asialiveaction.extractors.VidGuardExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
 import eu.kanade.tachiyomi.animesource.model.AnimeFilter
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
@@ -12,31 +11,20 @@ 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.ParsedAnimeHttpSource
-import eu.kanade.tachiyomi.lib.burstcloudextractor.BurstCloudExtractor
-import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
-import eu.kanade.tachiyomi.lib.fastreamextractor.FastreamExtractor
 import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
-import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
-import eu.kanade.tachiyomi.lib.streamhidevidextractor.StreamHideVidExtractor
-import eu.kanade.tachiyomi.lib.streamlareextractor.StreamlareExtractor
-import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
+import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
-import eu.kanade.tachiyomi.lib.upstreamextractor.UpstreamExtractor
-import eu.kanade.tachiyomi.lib.uqloadextractor.UqloadExtractor
+import eu.kanade.tachiyomi.lib.vidguardextractor.VidGuardExtractor
 import eu.kanade.tachiyomi.lib.vkextractor.VkExtractor
-import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
-import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
-import kotlinx.serialization.json.Json
-import okhttp3.HttpUrl.Companion.toHttpUrl
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import okhttp3.Request
 import okhttp3.Response
 import org.jsoup.nodes.Document
 import org.jsoup.nodes.Element
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import uy.kohesive.injekt.injectLazy
 import java.util.Calendar
 
 class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
@@ -47,9 +35,7 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override val lang = "es"
 
-    override val supportsLatest = true
-
-    private val json: Json by injectLazy()
+    override val supportsLatest = false
 
     private val preferences: SharedPreferences by lazy {
         Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
@@ -61,13 +47,16 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         private val QUALITY_LIST = arrayOf("1080", "720", "480", "360")
 
         private const val PREF_SERVER_KEY = "preferred_server"
-        private const val PREF_SERVER_DEFAULT = "FileLions"
+        private const val PREF_SERVER_DEFAULT = "Vk"
         private val SERVER_LIST = arrayOf(
-            "YourUpload", "Voe", "Mp4Upload", "Doodstream",
-            "Upload", "BurstCloud", "Upstream", "StreamTape",
-            "Fastream", "Filemoon", "StreamWish", "VidGuard",
-            "Amazon", "AmazonES", "Fireload", "FileLions",
-            "vk.com",
+            "Filemoon",
+            "StreamWish",
+            "VidGuard",
+            "Amazon",
+            "AmazonES",
+            "FileLions",
+            "Vk",
+            "Okru",
         )
     }
 
@@ -86,24 +75,23 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
     override fun popularAnimeNextPageSelector(): String = "div.TpRwCont main div a.next.page-numbers"
 
     override fun animeDetailsParse(document: Document): SAnime {
-        val anime = SAnime.create()
-        anime.thumbnail_url = document.selectFirst("header div.Image figure img")!!.attr("src").trim().replace("//", "https://")
-        anime.title = document.selectFirst("header div.asia-post-header h1.Title")!!.text()
-        anime.description = document.selectFirst("header div.asia-post-main div.Description p:nth-child(2), header div.asia-post-main div.Description p")!!.text().removeSurrounding("\"")
-        anime.genre = document.select("div.asia-post-main p.Info span.tags a").joinToString { it.text() }
-        val year = document.select("header div.asia-post-main p.Info span.Date a").text().toInt()
         val currentYear = Calendar.getInstance().get(Calendar.YEAR)
-        anime.status = when {
+        return SAnime.create().apply {
+            thumbnail_url = document.selectFirst("header div.Image figure img")?.attr("abs:src")?.getHdImg()
+            title = document.selectFirst("header div.asia-post-header h1.Title")!!.text()
+            description = document.selectFirst("header div.asia-post-main div.Description p:nth-child(2), header div.asia-post-main div.Description p")!!.text().removeSurrounding("\"")
+            genre = document.select("div.asia-post-main p.Info span.tags a").joinToString { it.text() }
+            artist = document.selectFirst("#elenco a span")?.text()
+            val year = document.select("header div.asia-post-main p.Info span.Date a").text().toInt()
+            status = when {
                 year < currentYear -> SAnime.COMPLETED
                 year == currentYear -> SAnime.ONGOING
                 else -> SAnime.UNKNOWN
             }
-        return anime
+        }
     }
 
-    override fun episodeListParse(response: Response): List<SEpisode> {
-        return super.episodeListParse(response).reversed()
-    }
+    override fun episodeListParse(response: Response) = super.episodeListParse(response).reversed()
 
     override fun episodeListSelector() = "#ep-list div.TPTblCn span a, #ep-list div.TPTblCn .accordion"
 
@@ -131,9 +119,7 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         }
     }
 
-    private fun getNumberFromEpsString(epsStr: String): String {
-        return epsStr.filter { it.isDigit() }
-    }
+    private fun getNumberFromEpsString(epsStr: String): String = epsStr.filter { it.isDigit() }
 
     private fun fetchUrls(text: String?): List<String> {
         if (text.isNullOrEmpty()) return listOf()
@@ -143,27 +129,30 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val videoList = mutableListOf<Video>()
-        document.select("script:containsData(var videos)").forEach { script ->
-            fetchUrls(script.data()).map { url ->
-                try {
-                    serverVideoResolver(url).also(videoList::addAll)
-                } catch (_: Exception) {}
-            }
-        }
-        return videoList
+
+        return document.select("script:containsData(var videos)")
+            .flatMap { fetchUrls(it.data()) }
+            .parallelCatchingFlatMapBlocking { serverVideoResolver(it) }
     }
 
+    /*--------------------------------Video extractors------------------------------------*/
+    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
+    private val streamWishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val vidGuardExtractor by lazy { VidGuardExtractor(client) }
+    private val vkExtractor by lazy { VkExtractor(client, headers) }
+    private val okruExtractor by lazy { OkruExtractor(client) }
+
     private fun serverVideoResolver(url: String): List<Video> {
-        val videoList = mutableListOf<Video>()
-        val embedUrl = url.lowercase()
-        try {
-            if (embedUrl.contains("voe")) {
-                VoeExtractor(client).videosFromUrl(url).also(videoList::addAll)
-            }
-            if ((embedUrl.contains("amazon") || embedUrl.contains("amz")) && !embedUrl.contains("disable")) {
+        return when {
+            arrayOf("vk").any(url) -> vkExtractor.videosFromUrl(url)
+            arrayOf("ok.ru", "okru").any(url) -> okruExtractor.videosFromUrl(url)
+            arrayOf("wishembed", "streamwish", "strwish", "wish").any(url) -> streamWishExtractor.videosFromUrl(url, videoNameGen = { "StreamWish:$it" })
+            arrayOf("filemoon", "moonplayer").any(url) -> filemoonExtractor.videosFromUrl(url, prefix = "Filemoon:")
+            arrayOf("vembed", "guard", "listeamed", "bembed", "vgfplay").any(url) -> vidGuardExtractor.videosFromUrl(url)
+            arrayOf("filelions", "lion", "fviplions").any(url) -> streamWishExtractor.videosFromUrl(url, videoNameGen = { "FileLions:$it" })
+            !url.contains("disable") && (arrayOf("amazon", "amz").any(url)) -> {
                 val body = client.newCall(GET(url)).execute().asJsoup()
-                if (body.select("script:containsData(var shareId)").toString().isNotBlank()) {
+                return if (body.select("script:containsData(var shareId)").toString().isNotBlank()) {
                     val shareId = body.selectFirst("script:containsData(var shareId)")!!.data()
                         .substringAfter("shareId = \"").substringBefore("\"")
                     val amazonApiJson = client.newCall(GET("https://www.amazon.com/drive/v1/shares/$shareId?resourceVersion=V2&ContentType=JSON&asset=ALL"))
@@ -173,70 +162,13 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
                         client.newCall(GET("https://www.amazon.com/drive/v1/nodes/$epId/children?resourceVersion=V2&ContentType=JSON&limit=200&sort=%5B%22kind+DESC%22%2C+%22modifiedDate+DESC%22%5D&asset=ALL&tempLink=true&shareId=$shareId"))
                             .execute().asJsoup()
                     val videoUrl = amazonApi.toString().substringAfter("\"FOLDER\":").substringAfter("tempLink\":\"").substringBefore("\"")
-                    videoList.add(Video(videoUrl, "Amazon", videoUrl))
+                    listOf(Video(videoUrl, "Amazon", videoUrl))
+                } else {
+                    emptyList()
                 }
             }
-            if (embedUrl.contains("filemoon") || embedUrl.contains("moonplayer")) {
-                val vidHeaders = headers.newBuilder()
-                    .add("Origin", "https://${url.toHttpUrl().host}")
-                    .add("Referer", "https://${url.toHttpUrl().host}/")
-                    .build()
-                FilemoonExtractor(client).videosFromUrl(url, prefix = "Filemoon:", headers = vidHeaders).also(videoList::addAll)
+            else -> emptyList()
         }
-            if (embedUrl.contains("uqload")) {
-                UqloadExtractor(client).videosFromUrl(url).also(videoList::addAll)
-            }
-            if (embedUrl.contains("mp4upload")) {
-                Mp4uploadExtractor(client).videosFromUrl(url, headers).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("wishembed") ||
-                embedUrl.contains("streamwish") ||
-                embedUrl.contains("strwish") ||
-                embedUrl.contains("wish") ||
-                embedUrl.contains("sfastwish")
-            ) {
-                val docHeaders = headers.newBuilder()
-                    .add("Origin", "https://${url.toHttpUrl().host}")
-                    .add("Referer", "https://${url.toHttpUrl().host}/")
-                    .build()
-                StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "StreamWish:$it" }).also(videoList::addAll)
-            }
-            if (embedUrl.contains("doodstream") || embedUrl.contains("dood.")) {
-                val url2 = url.replace("https://doodstream.com/e/", "https://dood.to/e/")
-                DoodExtractor(client).videoFromUrl(url2, "DoodStream", false)?.let { videoList.add(it) }
-            }
-            if (embedUrl.contains("streamlare")) {
-                StreamlareExtractor(client).videosFromUrl(url).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("yourupload") || embedUrl.contains("upload")) {
-                YourUploadExtractor(client).videoFromUrl(url, headers = headers).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("burstcloud") || embedUrl.contains("burst")) {
-                BurstCloudExtractor(client).videoFromUrl(url, headers = headers).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("fastream")) {
-                FastreamExtractor(client, headers).videosFromUrl(url).also(videoList::addAll)
-            }
-            if (embedUrl.contains("upstream")) {
-                UpstreamExtractor(client).videosFromUrl(url).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape")) {
-                StreamTapeExtractor(client).videoFromUrl(url)?.let { videoList.add(it) }
-            }
-            if (embedUrl.contains("ahvsh") || embedUrl.contains("streamhide") || embedUrl.contains("hide")) {
-                StreamHideVidExtractor(client).videosFromUrl(url).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("filelions") || embedUrl.contains("lion") || embedUrl.contains("fviplions")) {
-                StreamWishExtractor(client, headers).videosFromUrl(url, videoNameGen = { "FileLions:$it" }).also(videoList::addAll)
-            }
-            if (embedUrl.contains("vembed") || embedUrl.contains("guard")) {
-                VidGuardExtractor(client).videosFromUrl(url).also(videoList::addAll)
-            }
-            if (embedUrl.contains("vk")) {
-                VkExtractor(client, headers).videosFromUrl(url).also(videoList::addAll)
-            }
-        } catch (_: Exception) { }
-        return videoList
     }
 
     override fun videoListSelector() = throw UnsupportedOperationException()
@@ -305,9 +237,7 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         fun toUriPart() = vals[state].second
     }
 
-    override fun searchAnimeFromElement(element: Element): SAnime {
-        return popularAnimeFromElement(element)
-    }
+    override fun searchAnimeFromElement(element: Element) = popularAnimeFromElement(element)
 
     override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
 
@@ -321,6 +251,17 @@ class AsiaLiveAction : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override fun latestUpdatesSelector() = popularAnimeSelector()
 
+    private fun Array<String>.any(url: String): Boolean = this.any { url.contains(it, ignoreCase = true) }
+
+    private fun String?.getHdImg(): String? {
+        if (this.isNullOrEmpty() || !this.contains("tmdb")) return this
+
+        val pattern = """(https:\/\/image\.tmdb\.org\/t\/p\/)([\w_]+)(\/[^\s]*)""".toRegex()
+        return pattern.replace(this) { matchResult ->
+            "${matchResult.groupValues[1]}w500${matchResult.groupValues[3]}"
+        }
+    }
+
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {
             key = PREF_QUALITY_KEY

src/es/asialiveaction/src/eu/kanade/tachiyomi/animeextension/es/asialiveaction/extractors/VidGuardExtractor.kt

@@ -1,124 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.es.asialiveaction.extractors
-
-import android.app.Application
-import android.os.Handler
-import android.os.Looper
-import android.util.Base64
-import android.webkit.JavascriptInterface
-import android.webkit.WebSettings
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.OkHttpClient
-import uy.kohesive.injekt.injectLazy
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-
-class VidGuardExtractor(private val client: OkHttpClient) {
-    private val context: Application by injectLazy()
-    private val handler by lazy { Handler(Looper.getMainLooper()) }
-
-    class JsObject(private val latch: CountDownLatch) {
-        var payload: String = ""
-
-        @JavascriptInterface
-        fun passPayload(passedPayload: String) {
-            payload = passedPayload
-            latch.countDown()
-        }
-    }
-
-    fun videosFromUrl(url: String): List<Video> {
-        val doc = client.newCall(GET(url)).execute().asJsoup()
-        val scriptUrl = doc.selectFirst("script[src*=ad/plugin]")
-            ?.absUrl("src")
-            ?: return emptyList()
-
-        val headers = Headers.headersOf("Referer", url)
-        val script = client.newCall(GET(scriptUrl, headers)).execute()
-            .body.string()
-
-        val sources = getSourcesFromScript(script, url)
-            .takeIf { it.isNotBlank() && it != "undefined" }
-            ?: return emptyList()
-
-        return sources.substringAfter("stream:[").substringBefore("}]")
-            .split('{')
-            .drop(1)
-            .mapNotNull { line ->
-                val resolution = line.substringAfter("Label\":\"").substringBefore('"')
-                val videoUrl = line.substringAfter("URL\":\"").substringBefore('"')
-                    .takeIf(String::isNotBlank)
-                    ?.let(::fixUrl)
-                    ?: return@mapNotNull null
-                Video(videoUrl, "VidGuard:$resolution", videoUrl, headers)
-            }
-    }
-
-    private fun getSourcesFromScript(script: String, url: String): String {
-        val latch = CountDownLatch(1)
-
-        var webView: WebView? = null
-
-        val jsinterface = JsObject(latch)
-
-        handler.post {
-            val webview = WebView(context)
-            webView = webview
-            with(webview.settings) {
-                javaScriptEnabled = true
-                domStorageEnabled = true
-                databaseEnabled = true
-                useWideViewPort = false
-                loadWithOverviewMode = false
-                cacheMode = WebSettings.LOAD_NO_CACHE
-            }
-
-            webview.addJavascriptInterface(jsinterface, "android")
-            webview.webViewClient = object : WebViewClient() {
-                override fun onPageFinished(view: WebView?, url: String?) {
-                    view?.clearCache(true)
-                    view?.clearFormData()
-                    view?.evaluateJavascript(script) {}
-                    view?.evaluateJavascript("window.android.passPayload(JSON.stringify(window.svg))") {}
-                }
-            }
-
-            webview.loadDataWithBaseURL(url, "<html></html>", "text/html", "UTF-8", null)
-        }
-
-        latch.await(5, TimeUnit.SECONDS)
-
-        handler.post {
-            webView?.stopLoading()
-            webView?.destroy()
-            webView = null
-        }
-
-        return jsinterface.payload
-    }
-
-    private fun fixUrl(url: String): String {
-        val httpUrl = url.toHttpUrl()
-        val originalSign = httpUrl.queryParameter("sig")!!
-        val newSign = originalSign.chunked(2).joinToString("") {
-            Char(it.toInt(16) xor 2).toString()
-        }
-            .let { String(Base64.decode(it, Base64.DEFAULT)) }
-            .substring(5)
-            .chunked(2)
-            .reversed()
-            .joinToString("")
-            .substring(5)
-
-        return httpUrl.newBuilder()
-            .removeAllQueryParameters("sig")
-            .addQueryParameter("sig", newSign)
-            .build()
-            .toString()
-    }
-}

src/es/cine24h/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'Cine24h'
     extClass = '.Cine24h'
-    extVersionCode = 1
+    extVersionCode = 2
 }
 
 apply from: "$rootDir/common.gradle"
@@ -11,4 +11,5 @@ dependencies {
     implementation(project(':lib:dood-extractor'))
     implementation(project(':lib:filemoon-extractor'))
     implementation(project(':lib:voe-extractor'))
+    implementation(project(':lib:vidguard-extractor'))
 }

src/es/cine24h/src/eu/kanade/tachiyomi/animeextension/es/cine24h/Cine24h.kt

@@ -15,6 +15,7 @@ import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
 import eu.kanade.tachiyomi.lib.fastreamextractor.FastreamExtractor
 import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
+import eu.kanade.tachiyomi.lib.vidguardextractor.VidGuardExtractor
 import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
@@ -153,6 +154,7 @@ open class Cine24h : ConfigurableAnimeSource, AnimeHttpSource() {
     private val filemoonExtractor by lazy { FilemoonExtractor(client) }
     private val doodExtractor by lazy { DoodExtractor(client) }
     private val voeExtractor by lazy { VoeExtractor(client) }
+    private val vidGuardExtractor by lazy { VidGuardExtractor(client) }
 
     private fun serverVideoResolver(url: String): List<Video> {
         val embedUrl = url.lowercase()
@@ -161,9 +163,10 @@ open class Cine24h : ConfigurableAnimeSource, AnimeHttpSource() {
                 val link = if (url.contains("emb.html")) "https://fastream.to/embed-${url.split("/").last()}.html" else url
                 FastreamExtractor(client, headers).videosFromUrl(link)
             }
-            embedUrl.contains("filemoon") || embedUrl.contains("moonplayer") -> filemoonExtractor.videosFromUrl(url, prefix = "Filemoon:")
-            embedUrl.contains("voe") -> voeExtractor.videosFromUrl(url)
-            embedUrl.contains("dood") -> doodExtractor.videosFromUrl(url)
+            arrayOf("filemoon", "moonplayer").any(url) -> filemoonExtractor.videosFromUrl(url, prefix = "Filemoon:")
+            arrayOf("voe").any(url) -> voeExtractor.videosFromUrl(url)
+            arrayOf("doodstream", "dood.", "ds2play", "doods.").any(url) -> doodExtractor.videosFromUrl(url)
+            arrayOf("vembed", "guard", "listeamed", "bembed", "vgfplay").any(url) -> vidGuardExtractor.videosFromUrl(url)
             else -> emptyList()
         }
     }
@@ -236,6 +239,8 @@ open class Cine24h : ConfigurableAnimeSource, AnimeHttpSource() {
         return !attr(attrName).contains("data:image/")
     }
 
+    private fun Array<String>.any(url: String): Boolean = this.any { url.contains(it, ignoreCase = true) }
+
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {
             key = PREF_SERVER_KEY

src/es/hackstore/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'Hackstore'
     extClass = '.Hackstore'
-    extVersionCode = 12
+    extVersionCode = 13
 }
 
 apply from: "$rootDir/common.gradle"

src/es/hackstore/src/eu/kanade/tachiyomi/animeextension/es/hackstore/Hackstore.kt

@@ -83,6 +83,27 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
             Pair("Peliculas", "peliculas"),
             Pair("Series", "series"),
             Pair("Animes", "animes"),
+            Pair("Acción", "genero/accion"),
+            Pair("Action & Adventure", "genero/action-adventure"),
+            Pair("Animación", "genero/animacion"),
+            Pair("Aventura", "genero/aventura"),
+            Pair("Bélica", "genero/belica"),
+            Pair("Ciencia ficción", "genero/ciencia-ficcion"),
+            Pair("Comedia", "genero/comedia"),
+            Pair("Crimen", "genero/crimen"),
+            Pair("Documental", "genero/documental"),
+            Pair("Drama", "genero/drama"),
+            Pair("Familia", "genero/familia"),
+            Pair("Fantasía", "genero/fantasia"),
+            Pair("Historia", "genero/historia"),
+            Pair("Misterio", "genero/misterio"),
+            Pair("Música", "genero/musica"),
+            Pair("Occidental", "genero/occidental"),
+            Pair("Película de TV", "genero/pelicula-de-tv"),
+            Pair("Romance", "genero/romance"),
+            Pair("Suspense", "genero/suspense"),
+            Pair("Suspenso", "genero/suspenso"),
+            Pair("Terror", "genero/terror"),
         ),
     )
     private open class UriPartFilter(displayName: String, val vals: Array<Pair<String, String>>) :

src/es/pelisplushd/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'Pelisplushd'
     extClass = '.PelisplushdFactory'
-    extVersionCode = 57
+    extVersionCode = 58
 }
 
 apply from: "$rootDir/common.gradle"
@@ -23,5 +23,7 @@ dependencies {
     implementation(project(':lib:fastream-extractor'))
     implementation(project(':lib:upstream-extractor'))
     implementation(project(':lib:streamhidevid-extractor'))
+    implementation(project(':lib:streamsilk-extractor'))
+    implementation(project(':lib:vidguard-extractor'))
     implementation "dev.datlag.jsunpacker:jsunpacker:1.0.1"
 }

src/es/pelisplushd/src/eu/kanade/tachiyomi/animeextension/es/pelisplushd/Pelisplushd.kt

@@ -20,15 +20,16 @@ import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
 import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
 import eu.kanade.tachiyomi.lib.streamhidevidextractor.StreamHideVidExtractor
 import eu.kanade.tachiyomi.lib.streamlareextractor.StreamlareExtractor
+import eu.kanade.tachiyomi.lib.streamsilkextractor.StreamSilkExtractor
 import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.upstreamextractor.UpstreamExtractor
 import eu.kanade.tachiyomi.lib.uqloadextractor.UqloadExtractor
+import eu.kanade.tachiyomi.lib.vidguardextractor.VidGuardExtractor
 import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
 import okhttp3.Response
 import org.jsoup.nodes.Document
@@ -57,6 +58,7 @@ open class Pelisplushd(override val name: String, override val baseUrl: String)
             "YourUpload", "BurstCloud", "Voe", "Mp4Upload", "Doodstream",
             "Upload", "BurstCloud", "Upstream", "StreamTape", "Amazon",
             "Fastream", "Filemoon", "StreamWish", "Okru", "Streamlare",
+            "VidGuard",
         )
 
         private val REGEX_LINK = "https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&//=]*)".toRegex()
@@ -115,15 +117,15 @@ open class Pelisplushd(override val name: String, override val baseUrl: String)
 
             if (apiResponse.isSuccessful) {
                 val encryptedList = if (docResponse.select("iframe").any()) {
-                    listOf(docResponse.select("iframe").attr("src"))
+                    listOf("" to docResponse.select("iframe").attr("src"))
                 } else {
                     docResponse.select("#PlayerDisplay div[class*=\"OptionsLangDisp\"] div[class*=\"ODDIV\"] div[class*=\"OD\"] li")
-                        .map { it.attr("onclick") }
+                        .map { it.attr("data-lang").getLang() to it.attr("onclick") }
                 }
 
                 encryptedList.flatMap {
                     runCatching {
-                        val url = it.substringAfter("go_to_player('")
+                        val url = it.second.substringAfter("go_to_player('")
                             .substringAfter("go_to_playerVast('")
                             .substringBefore("?cover_url=")
                             .substringBefore("')")
@@ -142,7 +144,7 @@ open class Pelisplushd(override val name: String, override val baseUrl: String)
                             url
                         }
 
-                        serverVideoResolver(realUrl)
+                        serverVideoResolver(realUrl, it.first)
                     }.getOrNull() ?: emptyList()
                 }.also(videoList::addAll)
             }
@@ -150,20 +152,31 @@ open class Pelisplushd(override val name: String, override val baseUrl: String)
         return videoList
     }
 
-    private fun serverVideoResolver(url: String): List<Video> {
-        val embedUrl = url.lowercase()
+    /*--------------------------------Video extractors------------------------------------*/
+    private val voeExtractor by lazy { VoeExtractor(client) }
+    private val okruExtractor by lazy { OkruExtractor(client) }
+    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
+    private val uqloadExtractor by lazy { UqloadExtractor(client) }
+    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
+    private val streamWishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val doodExtractor by lazy { DoodExtractor(client) }
+    private val streamlareExtractor by lazy { StreamlareExtractor(client) }
+    private val yourUploadExtractor by lazy { YourUploadExtractor(client) }
+    private val burstCloudExtractor by lazy { BurstCloudExtractor(client) }
+    private val fastreamExtractor by lazy { FastreamExtractor(client, headers) }
+    private val upstreamExtractor by lazy { UpstreamExtractor(client) }
+    private val streamTapeExtractor by lazy { StreamTapeExtractor(client) }
+    private val streamHideVidExtractor by lazy { StreamHideVidExtractor(client) }
+    private val streamSilkExtractor by lazy { StreamSilkExtractor(client) }
+    private val vidGuardExtractor by lazy { VidGuardExtractor(client) }
+
+    fun serverVideoResolver(url: String, prefix: String = ""): List<Video> {
         return runCatching {
             when {
-                embedUrl.contains("voe") -> VoeExtractor(client).videosFromUrl(url)
-                embedUrl.contains("ok.ru") || embedUrl.contains("okru") -> OkruExtractor(client).videosFromUrl(url)
-                embedUrl.contains("filemoon") || embedUrl.contains("moonplayer") -> {
-                    val vidHeaders = headers.newBuilder()
-                        .add("Origin", "https://${url.toHttpUrl().host}")
-                        .add("Referer", "https://${url.toHttpUrl().host}/")
-                        .build()
-                    FilemoonExtractor(client).videosFromUrl(url, prefix = "Filemoon:", headers = vidHeaders)
-                }
-                !embedUrl.contains("disable") && (embedUrl.contains("amazon") || embedUrl.contains("amz")) -> {
+                arrayOf("voe").any(url) -> voeExtractor.videosFromUrl(url, "$prefix ")
+                arrayOf("ok.ru", "okru").any(url) -> okruExtractor.videosFromUrl(url, prefix)
+                arrayOf("filemoon", "moonplayer").any(url) -> filemoonExtractor.videosFromUrl(url, prefix = "$prefix Filemoon:")
+                !url.contains("disable") && (arrayOf("amazon", "amz").any(url)) -> {
                     val body = client.newCall(GET(url)).execute().asJsoup()
                     return if (body.select("script:containsData(var shareId)").toString().isNotBlank()) {
                         val shareId = body.selectFirst("script:containsData(var shareId)")!!.data()
@@ -175,32 +188,29 @@ open class Pelisplushd(override val name: String, override val baseUrl: String)
                             client.newCall(GET("https://www.amazon.com/drive/v1/nodes/$epId/children?resourceVersion=V2&ContentType=JSON&limit=200&sort=%5B%22kind+DESC%22%2C+%22modifiedDate+DESC%22%5D&asset=ALL&tempLink=true&shareId=$shareId"))
                                 .execute().asJsoup()
                         val videoUrl = amazonApi.toString().substringAfter("\"FOLDER\":").substringAfter("tempLink\":\"").substringBefore("\"")
-                        listOf(Video(videoUrl, "Amazon", videoUrl))
+                        listOf(Video(videoUrl, "$prefix Amazon", videoUrl))
                     } else {
                         emptyList()
                     }
                 }
-                embedUrl.contains("uqload") -> UqloadExtractor(client).videosFromUrl(url)
-                embedUrl.contains("mp4upload") -> Mp4uploadExtractor(client).videosFromUrl(url, headers)
-                embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish") -> {
-                    val docHeaders = headers.newBuilder()
-                        .add("Origin", "https://streamwish.to")
-                        .add("Referer", "https://streamwish.to/")
-                        .build()
-                    StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "StreamWish:$it" })
+                arrayOf("uqload").any(url) -> uqloadExtractor.videosFromUrl(url, prefix)
+                arrayOf("mp4upload").any(url) -> mp4uploadExtractor.videosFromUrl(url, headers, prefix = "$prefix ")
+                arrayOf("wishembed", "streamwish", "strwish", "wish").any(url) -> {
+                    streamWishExtractor.videosFromUrl(url, videoNameGen = { "$prefix StreamWish:$it" })
                 }
-                embedUrl.contains("doodstream") || embedUrl.contains("dood.") || embedUrl.contains("ds2play") || embedUrl.contains("doods.") -> {
+                arrayOf("doodstream", "dood.", "ds2play", "doods.").any(url) -> {
                     val url2 = url.replace("https://doodstream.com/e/", "https://d0000d.com/e/")
-                    listOf(DoodExtractor(client).videoFromUrl(url2, "DoodStream")!!)
+                    doodExtractor.videosFromUrl(url2, "$prefix DoodStream")
                 }
-                embedUrl.contains("streamlare") -> StreamlareExtractor(client).videosFromUrl(url)
-                embedUrl.contains("yourupload") || embedUrl.contains("upload") -> YourUploadExtractor(client).videoFromUrl(url, headers = headers)
-                embedUrl.contains("burstcloud") || embedUrl.contains("burst") -> BurstCloudExtractor(client).videoFromUrl(url, headers = headers)
-                embedUrl.contains("fastream") -> FastreamExtractor(client, headers).videosFromUrl(url, prefix = "Fastream:")
-                embedUrl.contains("upstream") -> UpstreamExtractor(client).videosFromUrl(url)
-                embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape") -> listOf(StreamTapeExtractor(client).videoFromUrl(url, quality = "StreamTape")!!)
-                embedUrl.contains("ahvsh") || embedUrl.contains("streamhide") || embedUrl.contains("guccihide") ||
-                    embedUrl.contains("streamvid") || embedUrl.contains("vidhide") -> StreamHideVidExtractor(client).videosFromUrl(url)
+                arrayOf("streamlare").any(url) -> streamlareExtractor.videosFromUrl(url, prefix)
+                arrayOf("yourupload", "upload").any(url) -> yourUploadExtractor.videoFromUrl(url, headers = headers, prefix = "$prefix ")
+                arrayOf("burstcloud", "burst").any(url) -> burstCloudExtractor.videoFromUrl(url, headers = headers, prefix = "$prefix ")
+                arrayOf("fastream").any(url) -> fastreamExtractor.videosFromUrl(url, prefix = "$prefix Fastream:")
+                arrayOf("upstream").any(url) -> upstreamExtractor.videosFromUrl(url, prefix = "$prefix ")
+                arrayOf("streamsilk").any(url) -> streamSilkExtractor.videosFromUrl(url, videoNameGen = { "$prefix StreamSilk:$it" })
+                arrayOf("streamtape", "stp", "stape").any(url) -> streamTapeExtractor.videosFromUrl(url, quality = "$prefix StreamTape")
+                arrayOf("ahvsh", "streamhide", "guccihide", "streamvid", "vidhide").any(url) -> streamHideVidExtractor.videosFromUrl(url, prefix = "$prefix ")
+                arrayOf("vembed", "guard", "listeamed", "bembed", "vgfplay").any(url) -> vidGuardExtractor.videosFromUrl(url, prefix = "$prefix ")
                 else -> emptyList()
             }
         }.getOrNull() ?: emptyList()
@@ -306,6 +316,17 @@ open class Pelisplushd(override val name: String, override val baseUrl: String)
         fun toUriPart() = vals[state].second
     }
 
+    fun String.getLang(): String {
+        return when {
+            arrayOf("0", "lat").any(this) -> "[LAT]"
+            arrayOf("1", "cast").any(this) -> "[CAST]"
+            arrayOf("2", "eng", "sub").any(this) -> "[SUB]"
+            else -> ""
+        }
+    }
+
+    private fun Array<String>.any(url: String): Boolean = this.any { url.contains(it, ignoreCase = true) }
+
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {
             key = PREF_SERVER_KEY

src/es/pelisplushd/src/eu/kanade/tachiyomi/animeextension/es/pelisplushd/Pelisplusph.kt

@@ -7,23 +7,8 @@ import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 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.lib.burstcloudextractor.BurstCloudExtractor
-import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
-import eu.kanade.tachiyomi.lib.fastreamextractor.FastreamExtractor
-import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
-import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
-import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
-import eu.kanade.tachiyomi.lib.streamhidevidextractor.StreamHideVidExtractor
-import eu.kanade.tachiyomi.lib.streamlareextractor.StreamlareExtractor
-import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
-import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
-import eu.kanade.tachiyomi.lib.upstreamextractor.UpstreamExtractor
-import eu.kanade.tachiyomi.lib.uqloadextractor.UqloadExtractor
-import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
-import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
 import okhttp3.Response
 import org.jsoup.nodes.Document
@@ -141,45 +126,6 @@ class Pelisplusph(override val name: String, override val baseUrl: String) : Pel
         }
     }
 
-    private fun serverVideoResolver(url: String, prefix: String = ""): List<Video> {
-        val embedUrl = url.lowercase()
-        return runCatching {
-            when {
-                embedUrl.contains("voe") -> VoeExtractor(client).videosFromUrl(url, prefix)
-                embedUrl.contains("ok.ru") || embedUrl.contains("okru") -> OkruExtractor(client).videosFromUrl(url, prefix)
-                embedUrl.contains("filemoon") || embedUrl.contains("moonplayer") -> {
-                    val vidHeaders = headers.newBuilder()
-                        .add("Origin", "https://${url.toHttpUrl().host}")
-                        .add("Referer", "https://${url.toHttpUrl().host}/")
-                        .build()
-                    FilemoonExtractor(client).videosFromUrl(url, prefix = "$prefix Filemoon:", headers = vidHeaders)
-                }
-                embedUrl.contains("uqload") -> UqloadExtractor(client).videosFromUrl(url, prefix = prefix)
-                embedUrl.contains("mp4upload") -> Mp4uploadExtractor(client).videosFromUrl(url, headers, prefix = prefix)
-                embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish") -> {
-                    val docHeaders = headers.newBuilder()
-                        .add("Origin", "https://streamwish.to")
-                        .add("Referer", "https://streamwish.to/")
-                        .build()
-                    StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "$prefix StreamWish:$it" })
-                }
-                embedUrl.contains("doodstream") || embedUrl.contains("dood.") || embedUrl.contains("ds2play") || embedUrl.contains("doods.") -> {
-                    val url2 = url.replace("https://doodstream.com/e/", "https://dood.to/e/")
-                    listOf(DoodExtractor(client).videoFromUrl(url2, "$prefix DoodStream")!!)
-                }
-                embedUrl.contains("streamlare") -> StreamlareExtractor(client).videosFromUrl(url, prefix = prefix)
-                embedUrl.contains("yourupload") || embedUrl.contains("upload") -> YourUploadExtractor(client).videoFromUrl(url, headers = headers, prefix = prefix)
-                embedUrl.contains("burstcloud") || embedUrl.contains("burst") -> BurstCloudExtractor(client).videoFromUrl(url, headers = headers, prefix = prefix)
-                embedUrl.contains("fastream") -> FastreamExtractor(client, headers).videosFromUrl(url, prefix = "$prefix Fastream:")
-                embedUrl.contains("upstream") -> UpstreamExtractor(client).videosFromUrl(url, prefix = prefix)
-                embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape") -> listOf(StreamTapeExtractor(client).videoFromUrl(url, quality = "$prefix StreamTape")!!)
-                embedUrl.contains("ahvsh") || embedUrl.contains("streamhide") || embedUrl.contains("guccihide") ||
-                    embedUrl.contains("streamvid") || embedUrl.contains("vidhide") -> StreamHideVidExtractor(client).videosFromUrl(url, "$prefix ")
-                else -> emptyList()
-            }
-        }.getOrNull() ?: emptyList()
-    }
-
     override fun List<Video>.sort(): List<Video> {
         val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
         val server = preferences.getString(PREF_SERVER_KEY, PREF_SERVER_DEFAULT)!!

src/es/pelisplushd/src/eu/kanade/tachiyomi/animeextension/es/pelisplushd/Pelisplusto.kt

@@ -8,20 +8,6 @@ import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 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.lib.burstcloudextractor.BurstCloudExtractor
-import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
-import eu.kanade.tachiyomi.lib.fastreamextractor.FastreamExtractor
-import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
-import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
-import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
-import eu.kanade.tachiyomi.lib.streamhidevidextractor.StreamHideVidExtractor
-import eu.kanade.tachiyomi.lib.streamlareextractor.StreamlareExtractor
-import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
-import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
-import eu.kanade.tachiyomi.lib.upstreamextractor.UpstreamExtractor
-import eu.kanade.tachiyomi.lib.uqloadextractor.UqloadExtractor
-import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
-import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
 import kotlinx.serialization.json.Json
@@ -29,7 +15,6 @@ import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.jsonArray
 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
@@ -129,6 +114,7 @@ class Pelisplusto(override val name: String, override val baseUrl: String) : Pel
         val document = response.asJsoup()
         val regIsUrl = "https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&//=]*)".toRegex()
         return document.select(".bg-tabs ul li").flatMap {
+            val prefix = it.parent()?.parent()?.selectFirst("button")?.ownText()?.lowercase()?.getLang()
             val decode = String(Base64.decode(it.attr("data-server"), Base64.DEFAULT))
 
             val url = if (!regIsUrl.containsMatchIn(decode)) {
@@ -143,7 +129,7 @@ class Pelisplusto(override val name: String, override val baseUrl: String) : Pel
             }.replace("https://sblanh.com", "https://lvturbo.com")
                 .replace(Regex("([a-zA-Z0-9]{0,8}[a-zA-Z0-9_-]+)=https:\\/\\/ww3.pelisplus.to.*"), "")
 
-            serverVideoResolver(videoUrl)
+            serverVideoResolver(videoUrl, prefix ?: "")
         }
     }
 
@@ -159,62 +145,6 @@ class Pelisplusto(override val name: String, override val baseUrl: String) : Pel
         ).reversed()
     }
 
-    private fun serverVideoResolver(url: String): List<Video> {
-        val embedUrl = url.lowercase()
-        return runCatching {
-            when {
-                embedUrl.contains("voe") -> VoeExtractor(client).videosFromUrl(url)
-                embedUrl.contains("ok.ru") || embedUrl.contains("okru") -> OkruExtractor(client).videosFromUrl(url)
-                embedUrl.contains("filemoon") || embedUrl.contains("moonplayer") -> {
-                    val vidHeaders = headers.newBuilder()
-                        .add("Origin", "https://${url.toHttpUrl().host}")
-                        .add("Referer", "https://${url.toHttpUrl().host}/")
-                        .build()
-                    FilemoonExtractor(client).videosFromUrl(url, prefix = "Filemoon:", headers = vidHeaders)
-                }
-                !embedUrl.contains("disable") && (embedUrl.contains("amazon") || embedUrl.contains("amz")) -> {
-                    val body = client.newCall(GET(url)).execute().asJsoup()
-                    return if (body.select("script:containsData(var shareId)").toString().isNotBlank()) {
-                        val shareId = body.selectFirst("script:containsData(var shareId)")!!.data()
-                            .substringAfter("shareId = \"").substringBefore("\"")
-                        val amazonApiJson = client.newCall(GET("https://www.amazon.com/drive/v1/shares/$shareId?resourceVersion=V2&ContentType=JSON&asset=ALL"))
-                            .execute().asJsoup()
-                        val epId = amazonApiJson.toString().substringAfter("\"id\":\"").substringBefore("\"")
-                        val amazonApi =
-                            client.newCall(GET("https://www.amazon.com/drive/v1/nodes/$epId/children?resourceVersion=V2&ContentType=JSON&limit=200&sort=%5B%22kind+DESC%22%2C+%22modifiedDate+DESC%22%5D&asset=ALL&tempLink=true&shareId=$shareId"))
-                                .execute().asJsoup()
-                        val videoUrl = amazonApi.toString().substringAfter("\"FOLDER\":").substringAfter("tempLink\":\"").substringBefore("\"")
-                        listOf(Video(videoUrl, "Amazon", videoUrl))
-                    } else {
-                        emptyList()
-                    }
-                }
-                embedUrl.contains("uqload") -> UqloadExtractor(client).videosFromUrl(url)
-                embedUrl.contains("mp4upload") -> Mp4uploadExtractor(client).videosFromUrl(url, headers)
-                embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish") -> {
-                    val docHeaders = headers.newBuilder()
-                        .add("Origin", "https://streamwish.to")
-                        .add("Referer", "https://streamwish.to/")
-                        .build()
-                    StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "StreamWish:$it" })
-                }
-                embedUrl.contains("doodstream") || embedUrl.contains("dood.") || embedUrl.contains("ds2play") || embedUrl.contains("doods.") -> {
-                    val url2 = url.replace("https://doodstream.com/e/", "https://dood.to/e/")
-                    listOf(DoodExtractor(client).videoFromUrl(url2, "DoodStream")!!)
-                }
-                embedUrl.contains("streamlare") -> StreamlareExtractor(client).videosFromUrl(url)
-                embedUrl.contains("yourupload") || embedUrl.contains("upload") -> YourUploadExtractor(client).videoFromUrl(url, headers = headers)
-                embedUrl.contains("burstcloud") || embedUrl.contains("burst") -> BurstCloudExtractor(client).videoFromUrl(url, headers = headers)
-                embedUrl.contains("fastream") -> FastreamExtractor(client, headers).videosFromUrl(url, prefix = "Fastream:")
-                embedUrl.contains("upstream") -> UpstreamExtractor(client).videosFromUrl(url)
-                embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape") -> listOf(StreamTapeExtractor(client).videoFromUrl(url, quality = "StreamTape")!!)
-                embedUrl.contains("ahvsh") || embedUrl.contains("streamhide") || embedUrl.contains("guccihide") ||
-                    embedUrl.contains("streamvid") || embedUrl.contains("vidhide") -> StreamHideVidExtractor(client).videosFromUrl(url)
-                else -> emptyList()
-            }
-        }.getOrNull() ?: emptyList()
-    }
-
     override fun getFilterList(): AnimeFilterList = AnimeFilterList(
         AnimeFilter.Header("La busqueda por genero ignora los otros filtros"),
         GenreFilter(),

src/es/tioanimeh/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'TioanimeH'
     extClass = '.TioanimeHFactory'
-    extVersionCode = 18
+    extVersionCode = 19
 }
 
 apply from: "$rootDir/common.gradle"
@@ -10,4 +10,6 @@ dependencies {
     implementation(project(':lib:yourupload-extractor'))
     implementation(project(':lib:okru-extractor'))
     implementation(project(':lib:voe-extractor'))
+    implementation(project(':lib:mixdrop-extractor'))
+    implementation(project(':lib:vidguard-extractor'))
 }

src/es/tioanimeh/src/eu/kanade/tachiyomi/animeextension/es/tioanimeh/TioAnimeHFilters.kt

@@ -0,0 +1,208 @@
+package eu.kanade.tachiyomi.animeextension.es.tioanimeh
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter.CheckBox
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import java.util.Calendar
+
+object TioAnimeHFilters {
+    open class QueryPartFilter(displayName: String, val vals: Array<Pair<String, String>>) : AnimeFilter.Select<String>(
+        displayName,
+        vals.map { it.first }.toTypedArray(),
+    ) {
+        fun toQueryPart(name: String) = vals[state].second.takeIf { it.isNotEmpty() }?.let { "&$name=${vals[state].second}" } ?: run { "" }
+    }
+
+    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
+
+    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
+
+    private inline fun <reified R> AnimeFilterList.parseCheckbox(
+        options: Array<Pair<String, String>>,
+        name: String,
+    ): String {
+        return (this.getFirst<R>() as CheckBoxFilterList).state
+            .mapNotNull { checkbox ->
+                if (checkbox.state) {
+                    options.find { it.first == checkbox.name }!!.second
+                } else {
+                    null
+                }
+            }.joinToString("&$name[]=").let {
+                if (it.isBlank()) {
+                    ""
+                } else {
+                    "&$name[]=$it"
+                }
+            }
+    }
+
+    private inline fun <reified R> AnimeFilterList.asQueryPart(name: String): String {
+        return (this.getFirst<R>() as QueryPartFilter).toQueryPart(name)
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return this.filterIsInstance<R>().first()
+    }
+
+    private fun String.changePrefix() = this.takeIf { it.startsWith("&") }?.let { this.replaceFirst("&", "?") } ?: run { this }
+
+    data class FilterSearchParams(val filter: String = "") { fun getQuery() = filter.changePrefix() }
+
+    private fun Array<Pair<String, String>>.toCheckBoxVal(): List<CheckBox> = map { CheckBoxVal(it.first, false) }
+
+    private fun String.addSuffix(): String = takeIf { it.isNotBlank() }?.let { "$it,${Calendar.getInstance().get(Calendar.YEAR)}" } ?: this
+
+    internal fun getSearchParameters(filters: AnimeFilterList, origen: TioAnimeHFiltersData.ORIGEN): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+
+        val strFilter = buildString {
+            when (origen) {
+                TioAnimeHFiltersData.ORIGEN.ANIME -> {
+                    append(filters.parseCheckbox<TypesFilter>(TioAnimeHFiltersData.TYPES, "type"))
+                    append(filters.parseCheckbox<AnimeGenresFilter>(TioAnimeHFiltersData.ANIME_GENRES, "genero"))
+                    append(filters.asQueryPart<YearsFilter>("year").addSuffix())
+                    append(filters.asQueryPart<StatesFilter>("status"))
+                    append(filters.asQueryPart<SortFilter>("sort"))
+                }
+                else -> {
+                    append(filters.asQueryPart<HentaiGenresFilter>("genero"))
+                }
+            }
+        }
+
+        return FilterSearchParams(strFilter)
+    }
+
+    private val ANIME_FILTER_LIST get() = AnimeFilterList(
+        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
+        TypesFilter(),
+        AnimeGenresFilter(),
+        YearsFilter(),
+        StatesFilter(),
+        SortFilter(),
+    )
+
+    private val HENTAI_FILTER_LIST get() = AnimeFilterList(
+        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
+        HentaiGenresFilter(),
+    )
+
+    fun getFilterList(origen: TioAnimeHFiltersData.ORIGEN) = when (origen) {
+        TioAnimeHFiltersData.ORIGEN.ANIME -> ANIME_FILTER_LIST
+        else -> HENTAI_FILTER_LIST
+    }
+
+    class TypesFilter : CheckBoxFilterList("Tipo", TioAnimeHFiltersData.TYPES.toCheckBoxVal())
+
+    class AnimeGenresFilter : CheckBoxFilterList("Género", TioAnimeHFiltersData.ANIME_GENRES.toCheckBoxVal())
+
+    class HentaiGenresFilter : QueryPartFilter("Género", TioAnimeHFiltersData.HENTAI_GENRES)
+
+    class YearsFilter : QueryPartFilter("Año", TioAnimeHFiltersData.YEARS)
+
+    class StatesFilter : QueryPartFilter("Estado", TioAnimeHFiltersData.STATES)
+
+    class SortFilter : QueryPartFilter("Orden", TioAnimeHFiltersData.SORT)
+
+    object TioAnimeHFiltersData {
+        val YEARS = arrayOf(Pair("Todos", "")) + (1950..Calendar.getInstance().get(Calendar.YEAR)).map { Pair("$it", "$it") }.reversed().toTypedArray()
+
+        val TYPES = arrayOf(
+            Pair("TV", "0"),
+            Pair("Película", "1"),
+            Pair("OVA", "2"),
+            Pair("Especial", "3"),
+        )
+
+        val ANIME_GENRES = arrayOf(
+            Pair("Acción", "accion"),
+            Pair("Artes Marciales", "artes-marciales"),
+            Pair("Aventuras", "aventura"),
+            Pair("Carreras", "carreras"),
+            Pair("Ciencia Ficción", "ciencia-ficcion"),
+            Pair("Comedia", "comedia"),
+            Pair("Demencia", "demencia"),
+            Pair("Demonios", "demonios"),
+            Pair("Deportes", "deportes"),
+            Pair("Drama", "drama"),
+            Pair("Ecchi", "ecchi"),
+            Pair("Escolares", "escolares"),
+            Pair("Espacial", "espacial"),
+            Pair("Fantasía", "fantasia"),
+            Pair("Harem", "harem"),
+            Pair("Historico", "historico"),
+            Pair("Infantil", "infantil"),
+            Pair("Josei", "josei"),
+            Pair("Juegos", "juegos"),
+            Pair("Magia", "magia"),
+            Pair("Mecha", "mecha"),
+            Pair("Militar", "militar"),
+            Pair("Misterio", "misterio"),
+            Pair("Música", "musica"),
+            Pair("Parodia", "parodia"),
+            Pair("Policía", "policia"),
+            Pair("Psicológico", "psicologico"),
+            Pair("Recuentos de la vida", "recuentos-de-la-vida"),
+            Pair("Romance", "romance"),
+            Pair("Samurai", "samurai"),
+            Pair("Seinen", "seinen"),
+            Pair("Shoujo", "shoujo"),
+            Pair("Shounen", "shounen"),
+            Pair("Sobrenatural", "sobrenatural"),
+            Pair("Superpoderes", "superpoderes"),
+            Pair("Suspenso", "suspenso"),
+            Pair("Terror", "terror"),
+            Pair("Vampiros", "vampiros"),
+            Pair("Yaoi", "yaoi"),
+            Pair("Yuri", "yuri"),
+        )
+
+        val HENTAI_GENRES = arrayOf(
+            Pair("Ahegao", "ahegao"),
+            Pair("Anal", "anal"),
+            Pair("Bestialidad", "bestialidad"),
+            Pair("Bondage", "bondage"),
+            Pair("Chikan", "chikan"),
+            Pair("Comedia", "comedia"),
+            Pair("Enfermeras", "enfermeras"),
+            Pair("Escolar", "escolar"),
+            Pair("Fantasia", "fantasia"),
+            Pair("Futanari", "futanari"),
+            Pair("Gangbang", "gangbang"),
+            Pair("Harem", "harem"),
+            Pair("Incesto", "incesto"),
+            Pair("Vamp", "vamp"),
+            Pair("Maids", "maids"),
+            Pair("Milf", "milf"),
+            Pair("Netorare", "netorare"),
+            Pair("Masturbacion", "masturbacion"),
+            Pair("Romance", "romance"),
+            Pair("Shota", "shota"),
+            Pair("Tentaculos", "tentaculos"),
+            Pair("Tetonas", "tetonas"),
+            Pair("Violacion", "violacion"),
+            Pair("Virgenes", "virgenes"),
+            Pair("Yaoi", "yaoi"),
+            Pair("Yuri", "yuri"),
+            Pair("Demonios", "demonios"),
+            Pair("Felacion", "felacion"),
+        )
+
+        val STATES = arrayOf(
+            Pair("Finalizado", "2"),
+            Pair("En emisión", "1"),
+            Pair("Próximamente", "3"),
+        )
+
+        val SORT = arrayOf(
+            Pair("Mas Reciente", "recent"),
+            Pair("Menos Reciente", "-recent"),
+        )
+
+        enum class ORIGEN {
+            ANIME,
+            HENTAI,
+        }
+    }
+}

src/es/tioanimeh/src/eu/kanade/tachiyomi/animeextension/es/tioanimeh/TioanimeH.kt

@@ -4,19 +4,20 @@ import android.app.Application
 import android.content.SharedPreferences
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animeextension.es.tioanimeh.extractors.VidGuardExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 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.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.lib.mixdropextractor.MixDropExtractor
 import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
+import eu.kanade.tachiyomi.lib.vidguardextractor.VidGuardExtractor
 import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import okhttp3.Request
 import okhttp3.Response
 import org.jsoup.nodes.Document
@@ -54,21 +55,21 @@ open class TioanimeH(override val name: String, override val baseUrl: String) :
     override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/directorio?p=$page")
 
     override fun popularAnimeFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.url = element.select("article a").attr("href")
-        anime.title = element.select("article a h3").text()
-        anime.thumbnail_url = baseUrl + element.select("article a div figure img").attr("src")
-        return anime
+        return SAnime.create().apply {
+            url = element.select("article a").attr("href")
+            title = element.select("article a h3").text()
+            thumbnail_url = baseUrl + element.select("article a div figure img").attr("src")
+        }
     }
 
-    override fun popularAnimeNextPageSelector(): String = "nav ul.pagination.d-inline-flex li.page-item a.page-link"
+    override fun popularAnimeNextPageSelector(): String = ".pagination .active ~ li:not(.disabled)"
 
     override fun episodeListParse(response: Response): List<SEpisode> {
         val document = response.asJsoup()
         val epInfoScript = document.selectFirst("script:containsData(var episodes = )")!!.data()
 
         if (epInfoScript.substringAfter("episodes = [").substringBefore("];").isEmpty()) {
-            return listOf<SEpisode>()
+            return emptyList()
         }
 
         val epNumList = epInfoScript.substringAfter("episodes = [").substringBefore("];").split(",")
@@ -84,27 +85,36 @@ open class TioanimeH(override val name: String, override val baseUrl: String) :
     }
 
     override fun episodeListSelector() = throw UnsupportedOperationException()
+
     override fun episodeFromElement(element: Element) = throw UnsupportedOperationException()
 
+    /*--------------------------------Video extractors------------------------------------*/
+    private val voeExtractor by lazy { VoeExtractor(client) }
+    private val vidGuardExtractor by lazy { VidGuardExtractor(client) }
+    private val okruExtractor by lazy { OkruExtractor(client) }
+    private val yourUploadExtractor by lazy { YourUploadExtractor(client) }
+    private val mixDropExtractor by lazy { MixDropExtractor(client) }
+
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val videoList = mutableListOf<Video>()
-        val serverList = document.selectFirst("script:containsData(var videos =)")!!.data().substringAfter("var videos = [[").substringBefore("]];")
-            .replace("\"", "").split("],[")
 
-        serverList.forEach {
+        val serverList = document.selectFirst("script:containsData(var videos =)")
+            ?.data()?.substringAfter("var videos = [[")?.substringBefore("]];")
+            ?.replace("\"", "")?.split("],[") ?: return emptyList()
+
+        return serverList.parallelCatchingFlatMapBlocking {
             val servers = it.split(",")
             val serverName = servers[0]
             val serverUrl = servers[1].replace("\\/", "/")
             when (serverName.lowercase()) {
-                "voe" -> VoeExtractor(client).videosFromUrl(serverUrl).let(videoList::addAll)
-                "vidguard" -> VidGuardExtractor(client).videosFromUrl(serverUrl).let(videoList::addAll)
-                "okru" -> OkruExtractor(client).videosFromUrl(serverUrl).let(videoList::addAll)
-                "yourupload" -> YourUploadExtractor(client).videoFromUrl(serverUrl, headers = headers).let(videoList::addAll)
+                "voe" -> voeExtractor.videosFromUrl(serverUrl)
+                "vidguard" -> vidGuardExtractor.videosFromUrl(serverUrl)
+                "okru" -> okruExtractor.videosFromUrl(serverUrl)
+                "yourupload" -> yourUploadExtractor.videoFromUrl(serverUrl, headers = headers)
+                "mixdrop" -> mixDropExtractor.videosFromUrl(serverUrl)
+                else -> emptyList()
             }
         }
-
-        return videoList
     }
 
     override fun videoListSelector() = throw UnsupportedOperationException()
@@ -126,32 +136,29 @@ open class TioanimeH(override val name: String, override val baseUrl: String) :
     }
 
     override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val filterList = if (filters.isEmpty()) getFilterList() else filters
-        val genreFilter = if (filterList.isNotEmpty())filterList.find { it is GenreFilter } as GenreFilter else { GenreFilter().apply { state = 0 } }
+        val params = TioAnimeHFilters.getSearchParameters(filters, TioAnimeHFilters.TioAnimeHFiltersData.ORIGEN.HENTAI)
 
         return when {
             query.isNotBlank() -> GET("$baseUrl/directorio?q=$query&p=$page", headers)
-            genreFilter.state != 0 -> GET("$baseUrl/directorio?genero=${genreFilter.toUriPart()}&p=$page")
-            else -> GET("$baseUrl/directorio?p=$page ")
+            params.filter.isNotBlank() -> GET("$baseUrl/directorio${params.getQuery()}&p=$page")
+            else -> popularAnimeRequest(page)
         }
     }
 
-    override fun searchAnimeFromElement(element: Element): SAnime {
-        return popularAnimeFromElement(element)
-    }
+    override fun searchAnimeFromElement(element: Element): SAnime = popularAnimeFromElement(element)
 
     override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
 
     override fun searchAnimeSelector(): String = popularAnimeSelector()
 
     override fun animeDetailsParse(document: Document): SAnime {
-        val anime = SAnime.create()
-        anime.title = document.select("h1.title").text()
-        anime.description = document.selectFirst("p.sinopsis")!!.ownText()
-        anime.genre = document.select("p.genres span.btn.btn-sm.btn-primary.rounded-pill a").joinToString { it.text() }
-        anime.thumbnail_url = document.select(".thumb img").attr("abs:src")
-        anime.status = parseStatus(document.select("a.btn.btn-success.btn-block.status").text())
-        return anime
+        return SAnime.create().apply {
+            title = document.select("h1.title").text()
+            description = document.selectFirst("p.sinopsis")!!.ownText()
+            genre = document.select("p.genres span.btn.btn-sm.btn-primary.rounded-pill a").joinToString { it.text() }
+            thumbnail_url = document.select(".thumb img").attr("abs:src")
+            status = parseStatus(document.select("a.btn.btn-success.btn-block.status").text())
+        }
     }
 
     private fun parseStatus(statusString: String): Int {
@@ -165,59 +172,21 @@ open class TioanimeH(override val name: String, override val baseUrl: String) :
     override fun latestUpdatesNextPageSelector() = popularAnimeNextPageSelector()
 
     override fun latestUpdatesFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.title = element.select("article a h3").text()
-        anime.thumbnail_url = baseUrl + element.select("article a div figure img").attr("src")
-
+        return SAnime.create().apply {
+            title = element.select("article a h3").text()
+            thumbnail_url = baseUrl + element.select("article a div figure img").attr("src")
             val slug = if (baseUrl.contains("hentai")) "/hentai/" else "/anime/"
             val fixUrl = element.select("article a").attr("href").split("-").toTypedArray()
             val realUrl = fixUrl.copyOf(fixUrl.size - 1).joinToString("-").replace("/ver/", slug)
-        anime.setUrlWithoutDomain(realUrl)
-        return anime
+            setUrlWithoutDomain(realUrl)
+        }
     }
 
     override fun latestUpdatesRequest(page: Int) = GET(baseUrl)
 
     override fun latestUpdatesSelector() = ".episodes li"
 
-    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
-        GenreFilter(),
-    )
-
-    class GenreFilter : UriPartFilter(
-        "Generos",
-        arrayOf(
-            Pair("<selecionar>", ""),
-            Pair("Ahegao", "ahegao"),
-            Pair("Anal", "anal"),
-            Pair("Casadas", "casadas"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Escolares", "escolares"),
-            Pair("Enfermeras", "enfermeras"),
-            Pair("Futanari", "futanari"),
-            Pair("Harem", "Harem"),
-            Pair("Gore", "gore"),
-            Pair("Hardcore", "hardcore"),
-            Pair("Incesto", "incesto"),
-            Pair("Juegos Sexuales", "juegos-sexuales"),
-            Pair("Milfs", "milf"),
-            Pair("Orgia", "orgia"),
-            Pair("Romance", "romance"),
-            Pair("Shota", "shota"),
-            Pair("Succubus", "succubus"),
-            Pair("Tetonas", "tetonas"),
-            Pair("Violacion", "violacion"),
-            Pair("Virgenes(como tu)", "virgenes"),
-            Pair("Yaoi", "Yaoi"),
-            Pair("Yuri", "yuri"),
-        ),
-    )
-
-    open class UriPartFilter(displayName: String, val vals: Array<Pair<String, String>>) :
-        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
-        fun toUriPart() = vals[state].second
-    }
+    override fun getFilterList(): AnimeFilterList = TioAnimeHFilters.getFilterList(TioAnimeHFilters.TioAnimeHFiltersData.ORIGEN.HENTAI)
 
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {

src/es/tioanimeh/src/eu/kanade/tachiyomi/animeextension/es/tioanimeh/TioanimeHFactory.kt

@@ -15,65 +15,16 @@ class TioanimeHFactory : AnimeSourceFactory {
 
 class TioAnime : TioanimeH("TioAnime", "https://tioanime.com") {
     override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val filterList = if (filters.isEmpty()) getFilterList() else filters
-        val genreFilter = if (filterList.isNotEmpty())filterList.find { it is GenreFilter } as GenreFilter else { GenreFilter().apply { state = 0 } }
+        val params = TioAnimeHFilters.getSearchParameters(filters, TioAnimeHFilters.TioAnimeHFiltersData.ORIGEN.ANIME)
+
         return when {
             query.isNotBlank() -> GET("$baseUrl/directorio?q=$query&p=$page", headers)
-            genreFilter.state != 0 -> GET("$baseUrl/directorio?genero=${genreFilter.toUriPart()}&p=$page")
-            else -> GET("$baseUrl/directorio?p=$page ")
+            params.filter.isNotBlank() -> GET("$baseUrl/directorio${params.getQuery()}&p=$page")
+            else -> popularAnimeRequest(page)
         }
     }
 
-    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        GenreFilter(),
-    )
-
-    private class GenreFilter : UriPartFilter(
-        "Géneros",
-        arrayOf(
-            Pair("<Selecionar>", "all"),
-            Pair("Acción", "accion"),
-            Pair("Artes Marciales", "artes_marciales"),
-            Pair("Aventuras", "aventura"),
-            Pair("Carreras", "carreras"),
-            Pair("Ciencia Ficción", "ciencia_ficcion"),
-            Pair("Comedia", "comedia"),
-            Pair("Demencia", "demencia"),
-            Pair("Demonios", "demonios"),
-            Pair("Deportes", "deportes"),
-            Pair("Drama", "drama"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Escolares", "escolares"),
-            Pair("Espacial", "espacial"),
-            Pair("Fantasía", "fantasia"),
-            Pair("Harem", "harem"),
-            Pair("Historico", "historico"),
-            Pair("Infantil", "infantil"),
-            Pair("Josei", "josei"),
-            Pair("Juegos", "juegos"),
-            Pair("Magia", "magia"),
-            Pair("Mecha", "mecha"),
-            Pair("Militar", "militar"),
-            Pair("Misterio", "misterio"),
-            Pair("Música", "musica"),
-            Pair("Parodia", "parodia"),
-            Pair("Policía", "policia"),
-            Pair("Psicológico", "psicologico"),
-            Pair("Recuentos de la vida", "recuentos_de_la_vida"),
-            Pair("Romance", "romance"),
-            Pair("Samurai", "samurai"),
-            Pair("Seinen", "seinen"),
-            Pair("Shoujo", "shoujo"),
-            Pair("Shounen", "shounen"),
-            Pair("Sobrenatural", "sobrenatural"),
-            Pair("Superpoderes", "superpoderes"),
-            Pair("Suspenso", "suspenso"),
-            Pair("Terror", "terror"),
-            Pair("Vampiros", "vampiros"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-        ),
-    )
+    override fun getFilterList(): AnimeFilterList = TioAnimeHFilters.getFilterList(TioAnimeHFilters.TioAnimeHFiltersData.ORIGEN.ANIME)
 }
 
 class TioHentai : TioanimeH("TioHentai", "https://tiohentai.com")

src/es/tioanimeh/src/eu/kanade/tachiyomi/animeextension/es/tioanimeh/extractors/VidGuardExtractor.kt

@@ -1,124 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.es.tioanimeh.extractors
-
-import android.app.Application
-import android.os.Handler
-import android.os.Looper
-import android.util.Base64
-import android.webkit.JavascriptInterface
-import android.webkit.WebSettings
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.OkHttpClient
-import uy.kohesive.injekt.injectLazy
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-
-class VidGuardExtractor(private val client: OkHttpClient) {
-    private val context: Application by injectLazy()
-    private val handler by lazy { Handler(Looper.getMainLooper()) }
-
-    class JsObject(private val latch: CountDownLatch) {
-        var payload: String = ""
-
-        @JavascriptInterface
-        fun passPayload(passedPayload: String) {
-            payload = passedPayload
-            latch.countDown()
-        }
-    }
-
-    fun videosFromUrl(url: String): List<Video> {
-        val doc = client.newCall(GET(url)).execute().asJsoup()
-        val scriptUrl = doc.selectFirst("script[src*=ad/plugin]")
-            ?.absUrl("src")
-            ?: return emptyList()
-
-        val headers = Headers.headersOf("Referer", url)
-        val script = client.newCall(GET(scriptUrl, headers)).execute()
-            .body.string()
-
-        val sources = getSourcesFromScript(script, url)
-            .takeIf { it.isNotBlank() && it != "undefined" }
-            ?: return emptyList()
-
-        return sources.substringAfter("stream:[").substringBefore("}]")
-            .split('{')
-            .drop(1)
-            .mapNotNull { line ->
-                val resolution = line.substringAfter("Label\":\"").substringBefore('"')
-                val videoUrl = line.substringAfter("URL\":\"").substringBefore('"')
-                    .takeIf(String::isNotBlank)
-                    ?.let(::fixUrl)
-                    ?: return@mapNotNull null
-                Video(videoUrl, "VidGuard:$resolution", videoUrl, headers)
-            }
-    }
-
-    private fun getSourcesFromScript(script: String, url: String): String {
-        val latch = CountDownLatch(1)
-
-        var webView: WebView? = null
-
-        val jsinterface = JsObject(latch)
-
-        handler.post {
-            val webview = WebView(context)
-            webView = webview
-            with(webview.settings) {
-                javaScriptEnabled = true
-                domStorageEnabled = true
-                databaseEnabled = true
-                useWideViewPort = false
-                loadWithOverviewMode = false
-                cacheMode = WebSettings.LOAD_NO_CACHE
-            }
-
-            webview.addJavascriptInterface(jsinterface, "android")
-            webview.webViewClient = object : WebViewClient() {
-                override fun onPageFinished(view: WebView?, url: String?) {
-                    view?.clearCache(true)
-                    view?.clearFormData()
-                    view?.evaluateJavascript(script) {}
-                    view?.evaluateJavascript("window.android.passPayload(JSON.stringify(window.svg))") {}
-                }
-            }
-
-            webview.loadDataWithBaseURL(url, "<html></html>", "text/html", "UTF-8", null)
-        }
-
-        latch.await(5, TimeUnit.SECONDS)
-
-        handler.post {
-            webView?.stopLoading()
-            webView?.destroy()
-            webView = null
-        }
-
-        return jsinterface.payload
-    }
-
-    private fun fixUrl(url: String): String {
-        val httpUrl = url.toHttpUrl()
-        val originalSign = httpUrl.queryParameter("sig")!!
-        val newSign = originalSign.chunked(2).joinToString("") {
-            Char(it.toInt(16) xor 2).toString()
-        }
-            .let { String(Base64.decode(it, Base64.DEFAULT)) }
-            .substring(5)
-            .chunked(2)
-            .reversed()
-            .joinToString("")
-            .substring(5)
-
-        return httpUrl.newBuilder()
-            .removeAllQueryParameters("sig")
-            .addQueryParameter("sig", newSign)
-            .build()
-            .toString()
-    }
-}

src/es/veranimes/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'VerAnimes'
     extClass = '.VerAnimes'
-    extVersionCode = 2
+    extVersionCode = 3
 }
 
 apply from: "$rootDir/common.gradle"
@@ -12,4 +12,5 @@ dependencies {
     implementation(project(':lib:streamhidevid-extractor'))
     implementation(project(':lib:voe-extractor'))
     implementation(project(':lib:yourupload-extractor'))
+    implementation(project(':lib:vidguard-extractor'))
 }

src/es/veranimes/src/eu/kanade/tachiyomi/animeextension/es/veranimes/VerAnimes.kt

@@ -4,9 +4,7 @@ import android.app.Application
 import android.content.SharedPreferences
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animeextension.es.veranimes.extractors.VidGuardExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-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
@@ -16,6 +14,7 @@ import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
 import eu.kanade.tachiyomi.lib.streamhidevidextractor.StreamHideVidExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
+import eu.kanade.tachiyomi.lib.vidguardextractor.VidGuardExtractor
 import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
@@ -57,6 +56,7 @@ class VerAnimes : ConfigurableAnimeSource, AnimeHttpSource() {
             "YourUpload",
             "FileLions",
             "StreamHideVid",
+            "VidGuard",
         )
     }
 
@@ -64,10 +64,14 @@ class VerAnimes : ConfigurableAnimeSource, AnimeHttpSource() {
         val document = response.asJsoup()
         val animeDetails = SAnime.create().apply {
             title = document.selectFirst(".ti h1")?.text()?.trim() ?: ""
-            status = SAnime.UNKNOWN
             description = document.selectFirst(".r .tx p")?.text()
             genre = document.select(".gn li a").joinToString { it.text() }
             thumbnail_url = document.selectFirst(".info figure img")?.attr("abs:data-src")
+            status = when {
+                document.select(".em").any() -> SAnime.ONGOING
+                document.select(".fi").any() -> SAnime.COMPLETED
+                else -> SAnime.UNKNOWN
+            }
             document.select(".info .u:not(.sp) > li").map { it.text() }.map { textContent ->
                 when {
                     "Estudio" in textContent -> author = textContent.substringAfter("Estudio(s):").trim()
@@ -99,12 +103,11 @@ class VerAnimes : ConfigurableAnimeSource, AnimeHttpSource() {
     override fun latestUpdatesRequest(page: Int) = GET("$baseUrl/animes?estado=en-emision&orden=desc&pag=$page", headers)
 
     override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val filterList = if (filters.isEmpty()) getFilterList() else filters
-        val genreFilter = filterList.find { it is GenreFilter } as GenreFilter
+        val params = VerAnimesFilters.getSearchParameters(filters)
 
         return when {
             query.isNotBlank() -> GET("$baseUrl/animes?buscar=$query&pag=$page", headers)
-            genreFilter.state != 0 -> GET("$baseUrl/animes?genero=${genreFilter.toUriPart()}&orden=desc&pag=$page", headers)
+            params.filter.isNotBlank() -> GET("$baseUrl/animes${params.getQuery()}&pag=$page", headers)
             else -> popularAnimeRequest(page)
         }
     }
@@ -155,23 +158,23 @@ class VerAnimes : ConfigurableAnimeSource, AnimeHttpSource() {
         }
     }
 
+    /*--------------------------------Video extractors------------------------------------*/
+    private val okruExtractor by lazy { OkruExtractor(client) }
+    private val streamWishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val streamHideVidExtractor by lazy { StreamHideVidExtractor(client) }
+    private val voeExtractor by lazy { VoeExtractor(client) }
+    private val yourUploadExtractor by lazy { YourUploadExtractor(client) }
+    private val vidGuardExtractor by lazy { VidGuardExtractor(client) }
+
     private fun serverVideoResolver(url: String): List<Video> {
-        val embedUrl = url.lowercase()
         return when {
-            embedUrl.contains("ok.ru") || embedUrl.contains("okru") -> OkruExtractor(client).videosFromUrl(url)
-            embedUrl.contains("filelions") || embedUrl.contains("lion") -> StreamWishExtractor(client, headers).videosFromUrl(url, videoNameGen = { "FileLions:$it" })
-            embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish") -> {
-                val docHeaders = headers.newBuilder()
-                    .add("Origin", "https://streamwish.to")
-                    .add("Referer", "https://streamwish.to/")
-                    .build()
-                StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "StreamWish:$it" })
-            }
-            embedUrl.contains("vidhide") || embedUrl.contains("streamhide") ||
-                embedUrl.contains("guccihide") || embedUrl.contains("streamvid") -> StreamHideVidExtractor(client).videosFromUrl(url)
-            embedUrl.contains("voe") -> VoeExtractor(client).videosFromUrl(url)
-            embedUrl.contains("yourupload") || embedUrl.contains("upload") -> YourUploadExtractor(client).videoFromUrl(url, headers = headers)
-            embedUrl.contains("vidguard") || embedUrl.contains("vgfplay") || embedUrl.contains("listeamed") -> VidGuardExtractor(client).videosFromUrl(url)
+            arrayOf("ok.ru", "okru").any(url) -> okruExtractor.videosFromUrl(url)
+            arrayOf("filelions", "lion", "fviplions").any(url) -> streamWishExtractor.videosFromUrl(url, videoNameGen = { "FileLions:$it" })
+            arrayOf("wishembed", "streamwish", "strwish", "wish").any(url) -> streamWishExtractor.videosFromUrl(url, videoNameGen = { "StreamWish:$it" })
+            arrayOf("vidhide", "streamhide", "guccihide", "streamvid").any(url) -> streamHideVidExtractor.videosFromUrl(url)
+            arrayOf("voe").any(url) -> voeExtractor.videosFromUrl(url)
+            arrayOf("yourupload", "upload").any(url) -> yourUploadExtractor.videoFromUrl(url, headers = headers)
+            arrayOf("vembed", "guard", "listeamed", "bembed", "vgfplay").any(url) -> vidGuardExtractor.videosFromUrl(url)
             else -> emptyList()
         }
     }
@@ -188,62 +191,9 @@ class VerAnimes : ConfigurableAnimeSource, AnimeHttpSource() {
         ).reversed()
     }
 
-    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
-        GenreFilter(),
-    )
+    override fun getFilterList(): AnimeFilterList = VerAnimesFilters.FILTER_LIST
 
-    private class GenreFilter : UriPartFilter(
-        "Género",
-        arrayOf(
-            Pair("<Seleccionar>", ""),
-            Pair("Acción", "accion"),
-            Pair("Artes Marciales", "artes-marciales"),
-            Pair("Aventuras", "aventuras"),
-            Pair("Carreras", "carreras"),
-            Pair("Ciencia Ficción", "ciencia-ficcion"),
-            Pair("Comedia", "comedia"),
-            Pair("Demencia", "demencia"),
-            Pair("Demonios", "demonios"),
-            Pair("Deportes", "deportes"),
-            Pair("Drama", "drama"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Escolares", "escolares"),
-            Pair("Espacial", "espacial"),
-            Pair("Fantasía", "fantasia"),
-            Pair("Harem", "harem"),
-            Pair("Historico", "historico"),
-            Pair("Infantil", "infantil"),
-            Pair("Josei", "josei"),
-            Pair("Juegos", "juegos"),
-            Pair("Magia", "magia"),
-            Pair("Mecha", "mecha"),
-            Pair("Militar", "militar"),
-            Pair("Misterio", "misterio"),
-            Pair("Música", "musica"),
-            Pair("Parodia", "parodia"),
-            Pair("Policía", "policia"),
-            Pair("Psicológico", "psicologico"),
-            Pair("Recuentos de la vida", "recuentos-de-la-vida"),
-            Pair("Romance", "romance"),
-            Pair("Samurai", "samurai"),
-            Pair("Seinen", "seinen"),
-            Pair("Shoujo", "shoujo"),
-            Pair("Shounen", "shounen"),
-            Pair("Sobrenatural", "sobrenatural"),
-            Pair("Superpoderes", "superpoderes"),
-            Pair("Suspenso", "suspenso"),
-            Pair("Terror", "terror"),
-            Pair("Vampiros", "vampiros"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-        ),
-    )
-
-    private open class UriPartFilter(displayName: String, val vals: Array<Pair<String, String>>) :
-        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
-        fun toUriPart() = vals[state].second
-    }
+    private fun Array<String>.any(url: String): Boolean = this.any { url.contains(it, ignoreCase = true) }
 
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {

src/es/veranimes/src/eu/kanade/tachiyomi/animeextension/es/veranimes/VerAnimesFilters.kt

@@ -0,0 +1,146 @@
+package eu.kanade.tachiyomi.animeextension.es.veranimes
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+
+object VerAnimesFilters {
+    open class QueryPartFilter(displayName: String, val vals: Array<Pair<String, String>>) : AnimeFilter.Select<String>(
+        displayName,
+        vals.map { it.first }.toTypedArray(),
+    ) {
+        fun toQueryPart(name: String) = vals[state].second.takeIf { it.isNotEmpty() }?.let { "&$name=${vals[state].second}" } ?: run { "" }
+    }
+
+    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
+
+    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
+
+    private inline fun <reified R> AnimeFilterList.parseCheckbox(
+        options: Array<Pair<String, String>>,
+        name: String,
+    ): String {
+        return (this.getFirst<R>() as CheckBoxFilterList).state
+            .mapNotNull { checkbox ->
+                if (checkbox.state) {
+                    options.find { it.first == checkbox.name }!!.second
+                } else {
+                    null
+                }
+            }.joinToString(",").let {
+                if (it.isBlank()) {
+                    ""
+                } else {
+                    "&$name=$it"
+                }
+            }
+    }
+
+    private inline fun <reified R> AnimeFilterList.asQueryPart(name: String): String {
+        return (this.getFirst<R>() as QueryPartFilter).toQueryPart(name)
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return this.filterIsInstance<R>().first()
+    }
+
+    private fun String.changePrefix() = this.takeIf { it.startsWith("&") }?.let { this.replaceFirst("&", "?") } ?: run { this }
+
+    data class FilterSearchParams(val filter: String = "") { fun getQuery() = filter.changePrefix() }
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+        return FilterSearchParams(
+            filters.parseCheckbox<GenresFilter>(VerAnimesFiltersData.GENRES, "genero") +
+                filters.parseCheckbox<YearsFilter>(VerAnimesFiltersData.YEARS, "anio") +
+                filters.parseCheckbox<TypesFilter>(VerAnimesFiltersData.TYPES, "tipo") +
+                filters.asQueryPart<StateFilter>("estado") +
+                filters.asQueryPart<SortFilter>("orden"),
+        )
+    }
+
+    val FILTER_LIST get() = AnimeFilterList(
+        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
+        GenresFilter(),
+        YearsFilter(),
+        TypesFilter(),
+        StateFilter(),
+        SortFilter(),
+    )
+
+    class GenresFilter : CheckBoxFilterList("Género", VerAnimesFiltersData.GENRES.map { CheckBoxVal(it.first, false) })
+
+    class YearsFilter : CheckBoxFilterList("Año", VerAnimesFiltersData.YEARS.map { CheckBoxVal(it.first, false) })
+
+    class TypesFilter : CheckBoxFilterList("Tipo", VerAnimesFiltersData.TYPES.map { CheckBoxVal(it.first, false) })
+
+    class StateFilter : QueryPartFilter("Estado", VerAnimesFiltersData.STATE)
+
+    class SortFilter : QueryPartFilter("Orden", VerAnimesFiltersData.SORT)
+
+    private object VerAnimesFiltersData {
+
+        val YEARS = (1967..2024).map { Pair("$it", "$it") }.reversed().toTypedArray()
+
+        val TYPES = arrayOf(
+            Pair("Tv", "tv"),
+            Pair("Película", "pelicula"),
+            Pair("Especial", "especial"),
+            Pair("Ova", "ova"),
+        )
+
+        val STATE = arrayOf(
+            Pair("Todos", ""),
+            Pair("En Emisión", "en-emision"),
+            Pair("Finalizado", "finalizado"),
+            Pair("Próximamente", "proximamente"),
+        )
+
+        val SORT = arrayOf(
+            Pair("Descendente", "desc"),
+            Pair("Ascendente", "asc"),
+        )
+
+        val GENRES = arrayOf(
+            Pair("Acción", "accion"),
+            Pair("Artes Marciales", "artes-marciales"),
+            Pair("Aventuras", "aventuras"),
+            Pair("Carreras", "carreras"),
+            Pair("Ciencia Ficción", "ciencia-ficcion"),
+            Pair("Comedia", "comedia"),
+            Pair("Demencia", "demencia"),
+            Pair("Demonios", "demonios"),
+            Pair("Deportes", "deportes"),
+            Pair("Drama", "drama"),
+            Pair("Ecchi", "ecchi"),
+            Pair("Escolares", "escolares"),
+            Pair("Espacial", "espacial"),
+            Pair("Fantasía", "fantasia"),
+            Pair("Harem", "harem"),
+            Pair("Historico", "historico"),
+            Pair("Infantil", "infantil"),
+            Pair("Josei", "josei"),
+            Pair("Juegos", "juegos"),
+            Pair("Magia", "magia"),
+            Pair("Mecha", "mecha"),
+            Pair("Militar", "militar"),
+            Pair("Misterio", "misterio"),
+            Pair("Música", "musica"),
+            Pair("Parodia", "parodia"),
+            Pair("Policía", "policia"),
+            Pair("Psicológico", "psicologico"),
+            Pair("Recuentos de la vida", "recuentos-de-la-vida"),
+            Pair("Romance", "romance"),
+            Pair("Samurai", "samurai"),
+            Pair("Seinen", "seinen"),
+            Pair("Shoujo", "shoujo"),
+            Pair("Shounen", "shounen"),
+            Pair("Sobrenatural", "sobrenatural"),
+            Pair("Superpoderes", "superpoderes"),
+            Pair("Suspenso", "suspenso"),
+            Pair("Terror", "terror"),
+            Pair("Vampiros", "vampiros"),
+            Pair("Yaoi", "yaoi"),
+            Pair("Yuri", "yuri"),
+        )
+    }
+}

src/es/veranimes/src/eu/kanade/tachiyomi/animeextension/es/veranimes/extractors/VidGuardExtractor.kt

@@ -1,124 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.es.veranimes.extractors
-
-import android.app.Application
-import android.os.Handler
-import android.os.Looper
-import android.util.Base64
-import android.webkit.JavascriptInterface
-import android.webkit.WebSettings
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.OkHttpClient
-import uy.kohesive.injekt.injectLazy
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-
-class VidGuardExtractor(private val client: OkHttpClient) {
-    private val context: Application by injectLazy()
-    private val handler by lazy { Handler(Looper.getMainLooper()) }
-
-    class JsObject(private val latch: CountDownLatch) {
-        var payload: String = ""
-
-        @JavascriptInterface
-        fun passPayload(passedPayload: String) {
-            payload = passedPayload
-            latch.countDown()
-        }
-    }
-
-    fun videosFromUrl(url: String): List<Video> {
-        val doc = client.newCall(GET(url)).execute().asJsoup()
-        val scriptUrl = doc.selectFirst("script[src*=ad/plugin]")
-            ?.absUrl("src")
-            ?: return emptyList()
-
-        val headers = Headers.headersOf("Referer", url)
-        val script = client.newCall(GET(scriptUrl, headers)).execute()
-            .body.string()
-
-        val sources = getSourcesFromScript(script, url)
-            .takeIf { it.isNotBlank() && it != "undefined" }
-            ?: return emptyList()
-
-        return sources.substringAfter("stream:[").substringBefore("}]")
-            .split('{')
-            .drop(1)
-            .mapNotNull { line ->
-                val resolution = line.substringAfter("Label\":\"").substringBefore('"')
-                val videoUrl = line.substringAfter("URL\":\"").substringBefore('"')
-                    .takeIf(String::isNotBlank)
-                    ?.let(::fixUrl)
-                    ?: return@mapNotNull null
-                Video(videoUrl, "VidGuard:$resolution", videoUrl, headers)
-            }
-    }
-
-    private fun getSourcesFromScript(script: String, url: String): String {
-        val latch = CountDownLatch(1)
-
-        var webView: WebView? = null
-
-        val jsinterface = JsObject(latch)
-
-        handler.post {
-            val webview = WebView(context)
-            webView = webview
-            with(webview.settings) {
-                javaScriptEnabled = true
-                domStorageEnabled = true
-                databaseEnabled = true
-                useWideViewPort = false
-                loadWithOverviewMode = false
-                cacheMode = WebSettings.LOAD_NO_CACHE
-            }
-
-            webview.addJavascriptInterface(jsinterface, "android")
-            webview.webViewClient = object : WebViewClient() {
-                override fun onPageFinished(view: WebView?, url: String?) {
-                    view?.clearCache(true)
-                    view?.clearFormData()
-                    view?.evaluateJavascript(script) {}
-                    view?.evaluateJavascript("window.android.passPayload(JSON.stringify(window.svg))") {}
-                }
-            }
-
-            webview.loadDataWithBaseURL(url, "<html></html>", "text/html", "UTF-8", null)
-        }
-
-        latch.await(5, TimeUnit.SECONDS)
-
-        handler.post {
-            webView?.stopLoading()
-            webView?.destroy()
-            webView = null
-        }
-
-        return jsinterface.payload
-    }
-
-    private fun fixUrl(url: String): String {
-        val httpUrl = url.toHttpUrl()
-        val originalSign = httpUrl.queryParameter("sig")!!
-        val newSign = originalSign.chunked(2).joinToString("") {
-            Char(it.toInt(16) xor 2).toString()
-        }
-            .let { String(Base64.decode(it, Base64.DEFAULT)) }
-            .substring(5)
-            .chunked(2)
-            .reversed()
-            .joinToString("")
-            .substring(5)
-
-        return httpUrl.newBuilder()
-            .removeAllQueryParameters("sig")
-            .addQueryParameter("sig", newSign)
-            .build()
-            .toString()
-    }
-}