Add docchi, fix lib lycoris/vk/lulustream (#674)

* feat(pl/OgladajAnime): Update OgladajANime and Add new Lib

* feat(lib/Lycoris): little fix key

* Add docchi, fix lycoris/vk, add lib lulustream(luluvdo)

* fix(lulustream), undo the changes OgladajAnime

* undo change OgladajAnime

* feat(pl/docchi): add lib googledrive

lib/lulu-extractor/build.gradle.kts

@@ -0,0 +1,3 @@
+plugins {
+    id("lib-android")
+}

lib/lulu-extractor/src/main/java/eu/kanade/tachiyomi/lib/luluextractor/LuluExtractor.kt

@@ -0,0 +1,136 @@
+package eu.kanade.tachiyomi.lib.luluextractor
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+import java.util.regex.Pattern
+
+class LuluExtractor(private val client: OkHttpClient) {
+
+    private val headers = Headers.Builder()
+        .add("Referer", "https://luluvdo.com")
+        .add("Origin", "https://luluvdo.com")
+        .build()
+
+    fun videosFromUrl(url: String, prefix: String): List<Video> {
+        val videos = mutableListOf<Video>()
+
+        try {
+            val html = client.newCall(GET(url, headers)).execute().use { it.body.string() }
+            val m3u8Url = extractM3u8Url(html) ?: return emptyList()
+            val fixedUrl = fixM3u8Link(m3u8Url)
+            val quality = getResolution(fixedUrl)
+
+            videos.add(Video(fixedUrl, "${prefix}Lulu - $quality", fixedUrl))
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+        return videos
+    }
+
+    private fun extractM3u8Url(html: String): String? {
+        return when {
+            html.contains("eval(function(p,a,c,k,e") -> {
+                val unpacked = JavaScriptUnpacker.unpack(html) ?: return null
+                Pattern.compile("sources:\\[\\{file:\"([^\"]+)\"")
+                    .matcher(unpacked)
+                    .takeIf { it.find() }
+                    ?.group(1)
+            }
+            else -> {
+                Pattern.compile("sources: \\[\\{file:\"(https?://[^\"]+)\"")
+                    .matcher(html)
+                    .takeIf { it.find() }
+                    ?.group(1)
+            }
+        }
+    }
+
+    private fun fixM3u8Link(link: String): String {
+        val paramOrder = listOf("t", "s", "e", "f")
+        val baseUrl = link.split("?").first()
+        val params = link.split("?").getOrNull(1)?.split("&") ?: emptyList()
+
+        val paramMap = mutableMapOf<String, String>()
+        val extraParams = mutableMapOf(
+            "i" to "0.3",
+            "sp" to "0"
+        )
+
+        params.forEachIndexed { index, param ->
+            val parts = param.split("=")
+            when {
+                parts.size == 2 -> {
+                    val (key, value) = parts
+                    if (key in paramOrder) paramMap[key] = value
+                    else extraParams[key] = value
+                }
+                index < paramOrder.size -> paramMap[paramOrder[index]] = parts.firstOrNull() ?: ""
+            }
+        }
+
+        return buildString {
+            append(baseUrl)
+            append("?")
+            append(paramOrder.joinToString("&") { "$it=${paramMap[it]}" })
+            append("&")
+            append(extraParams.map { "${it.key}=${it.value}" }.joinToString("&"))
+        }
+    }
+
+    private fun getResolution(m3u8Url: String): String {
+        return try {
+            val content = client.newCall(GET(m3u8Url, headers)).execute()
+                .use { it.body.string() }
+
+            Pattern.compile("RESOLUTION=\\d+x(\\d+)")
+                .matcher(content)
+                .takeIf { it.find() }
+                ?.group(1)
+                ?.let { "${it}p" }
+                ?: "Unknown"
+        } catch (e: Exception) {
+            "Unknown"
+        }
+    }
+}
+
+object JavaScriptUnpacker {
+    private val UNPACK_REGEX = Regex(
+        """}\('(.*)', *(\d+), *(\d+), *'(.*?)'\.split\('\|'\)""",
+        RegexOption.DOT_MATCHES_ALL
+    )
+
+    fun unpack(encodedJs: String): String? {
+        val match = UNPACK_REGEX.find(encodedJs) ?: return null
+        val (payload, radixStr, countStr, symtabStr) = match.destructured
+
+        val radix = radixStr.toIntOrNull() ?: return null
+        val count = countStr.toIntOrNull() ?: return null
+        val symtab = symtabStr.split('|')
+
+        if (symtab.size != count) throw IllegalArgumentException("Invalid symtab size")
+
+        val baseDict = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            .take(radix)
+            .withIndex()
+            .associate { it.value to it.index }
+
+        return Regex("""\b\w+\b""").replace(payload) { mr ->
+            symtab.getOrNull(unbase(mr.value, radix, baseDict)) ?: mr.value
+        }.replace("\\", "")
+    }
+
+    private fun unbase(value: String, radix: Int, dict: Map<Char, Int>): Int {
+        var result = 0
+        var multiplier = 1
+
+        for (char in value.reversed()) {
+            result += dict[char]?.times(multiplier) ?: 0
+            multiplier *= radix
+        }
+        return result
+    }
+}

lib/lycoris-extractor/build.gradle.kts

@@ -0,0 +1,3 @@
+plugins {
+    id("lib-android")
+}

lib/lycoris-extractor/src/main/java/eu/kanade/tachiyomi/lib/lycorisextractor/LycorisExtractor.kt

@@ -0,0 +1,226 @@
+package eu.kanade.tachiyomi.lib.lycorisextractor
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import android.util.Base64
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.Serializable
+import okhttp3.Headers
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+import uy.kohesive.injekt.injectLazy
+import java.nio.charset.Charset
+
+class LycorisCafeExtractor(private val client: OkHttpClient) {
+
+    private val GETSECONDARYURL = "https://www.lycoris.cafe/api/watch/getSecondaryLink"
+
+    private val GETLNKURL = "https://www.lycoris.cafe/api/watch/getLink"
+
+    private val json: Json by injectLazy()
+
+    // Credit: https://github.com/skoruppa/docchi-stremio-addon/blob/main/app/players/lycoris.py
+    fun getVideosFromUrl(url: String, headers: Headers, prefix: String): List<Video> {
+
+        val videos = mutableListOf<Video>()
+        val embedHeaders = headers.newBuilder()
+            .add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36")
+            .build()
+
+        val document = client.newCall(
+            GET(url, headers = embedHeaders),
+        ).execute().asJsoup()
+
+        val scripts = document.select("script")
+
+        val episodeDataPattern = Regex("episodeInfo\\s*:\\s*(\\{.*?\\}),", RegexOption.DOT_MATCHES_ALL)
+        var episodeData: String? = null
+
+        for (script in scripts) {
+            val content = script.data()
+            val match = episodeDataPattern.find(content)
+
+            if (match != null) {
+                episodeData = match.groupValues[1]
+                break
+            }
+        }
+
+        val result = mutableMapOf<String, String?>()
+
+        val patterns = listOf(
+            "id" to Regex("id\\s*:\\s*(\\d+)"),
+            "FHD" to Regex("FHD\\s*:\\s*\"([^\"]+)\""),
+            "HD" to Regex("HD\\s*:\\s*\"([^\"]+)\""),
+            "SD" to Regex("SD\\s*:\\s*\"([^\"]+)\"")
+        )
+
+        patterns.forEach { (key, pattern) ->
+            result[key] = episodeData?.let { pattern.find(it)?.groups?.get(1)?.value }
+        }
+
+        var linkList: String? = fetchAndDecodeVideo(client, result["id"].toString(), isSecondary = false).toString()
+
+        val fhdLink = fetchAndDecodeVideo(client, result["FHD"].toString(), isSecondary = true).toString()
+        val sdLink = fetchAndDecodeVideo(client, result["SD"].toString(), isSecondary = true).toString()
+        val hdLink = fetchAndDecodeVideo(client, result["HD"].toString(), isSecondary = true).toString()
+
+
+        if (linkList.isNullOrBlank() || linkList == "{}") {
+            if (fhdLink.isNotEmpty()) {
+                videos.add(Video(fhdLink, "${prefix}lycoris.cafe - 1080p", fhdLink))
+            }
+            if (hdLink.isNotEmpty()) {
+                videos.add(Video(hdLink, "${prefix}lycoris.cafe - 720p", hdLink))
+            }
+            if (sdLink.isNotEmpty()) {
+                videos.add(Video(sdLink, "${prefix}lycoris.cafe - 480p", sdLink))
+            }
+        }else {
+            val videoLinks = Json.decodeFromString<VideoLinks>(linkList)
+
+            videoLinks.FHD?.takeIf { checkLinks(client, it) }?.let {
+                videos.add(Video(it, "${prefix}lycoris.cafe - 1080p", it))
+            }?: videos.add(Video(fhdLink, "${prefix}lycoris.cafe - 1080p", fhdLink))
+
+            videoLinks.HD?.takeIf { checkLinks(client, it) }?.let {
+                videos.add(Video(it, "${prefix}lycoris.cafe - 720p", it))
+            }?: videos.add(Video(hdLink, "${prefix}lycoris.cafe - 720p", hdLink))
+
+            videoLinks.SD?.takeIf { checkLinks(client, it) }?.let {
+                videos.add(Video(it, "${prefix}lycoris.cafe - 480p", it))
+            }?: videos.add(Video(sdLink, "${prefix}lycoris.cafe - 480p", sdLink))
+        }
+        return videos
+
+    }
+
+    private fun decodeVideoLinks(encodedUrl: String?): Any? {
+        if (encodedUrl.isNullOrEmpty()) {
+            return null
+        }
+
+        if (!encodedUrl.endsWith("LC")) {
+            return encodedUrl
+        }
+
+        val encodedUrlWithoutSignature = encodedUrl.dropLast(2)
+
+        val decoded = encodedUrlWithoutSignature
+            .reversed()
+            .map { (it.code - 7).toChar() }
+            .joinToString("")
+
+        return try {
+            val base64Decoded = Base64.decode(decoded, Base64.DEFAULT)
+            base64Decoded.toString(Charsets.UTF_8)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun fetchAndDecodeVideo(client: OkHttpClient, episodeId: String, isSecondary: Boolean = false): Any? {
+            val url: HttpUrl
+
+            if (isSecondary) {
+                val convertedText = episodeId.toByteArray(Charset.forName("UTF-8")).toString(Charset.forName("ISO-8859-1"))
+                val unicodeEscape = decodePythonEscape(convertedText)
+                val finalText = unicodeEscape.toByteArray(Charsets.ISO_8859_1).toString(Charsets.UTF_8)
+
+                url = GETLNKURL.toHttpUrl().newBuilder()
+                    ?.addQueryParameter("link", finalText)
+                    ?.build() ?: throw IllegalStateException("Invalid URL")
+            } else {
+                url = GETSECONDARYURL.toHttpUrl().newBuilder()
+                    ?.addQueryParameter("id", episodeId)
+                    ?.build() ?: throw IllegalStateException("Invalid URL")
+            }
+            client.newCall(GET(url))
+                .execute()
+                .use { response ->
+                    val data = response.body.string() ?: ""
+                    return decodeVideoLinks(data)
+                }
+    }
+
+    private fun checkLinks(client: OkHttpClient, link: String): Boolean {
+        client.newCall(GET(link)).execute().use { response ->
+            return response.code.toString() == "200"
+        }
+    }
+    //thx deepseek
+    private fun decodePythonEscape(text: String): String {
+        // 1. Obsługa kontynuacji linii (backslash + newline)
+        val withoutLineContinuation = text.replace("\\\n", "")
+
+        // 2. Regex do wykrywania wszystkich sekwencji escape
+        val regex = Regex(
+            """\\U([0-9a-fA-F]{8})|""" +     // \UXXXXXXXX
+                """\\u([0-9a-fA-F]{4})|""" +     // \uXXXX
+                """\\x([0-9a-fA-F]{2})|""" +     // \xHH
+                """\\([0-7]{1,3})|""" +          // \OOO (octal)
+                """\\([btnfr"'$\\\\])"""         // \n, \t, itd.
+        )
+
+        return regex.replace(withoutLineContinuation) { match ->
+            val (u8, u4, x2, octal, simple) = match.destructured
+            when {
+                u8.isNotEmpty() -> handleUnicode8(u8)
+                u4.isNotEmpty() -> handleUnicode4(u4)
+                x2.isNotEmpty() -> handleHex(x2)
+                octal.isNotEmpty() -> handleOctal(octal)
+                simple.isNotEmpty() -> handleSimple(simple)
+                else -> match.value
+            }
+        }
+    }
+
+    private fun handleUnicode8(hex: String): String {
+        val codePoint = hex.toInt(16)
+        return if (codePoint in 0..0x10FFFF) {
+            String(intArrayOf(codePoint), 0, 1)
+        } else {
+            "\\U$hex"
+        }
+    }
+
+    private fun handleUnicode4(hex: String) = hex.toInt(16).toChar().toString()
+    private fun handleHex(hex: String) = hex.toInt(16).toChar().toString()
+
+    private fun handleOctal(octal: String): String {
+        val value = octal.toInt(8)
+        return (value and 0xFF).toChar().toString()
+    }
+
+    private fun handleSimple(c: String): String = when (c) {
+        "b" -> "\u0008"
+        "t" -> "\t"
+        "n" -> "\n"
+        "f" -> "\u000C"
+        "r" -> "\r"
+        "\"" -> "\""
+        "'" -> "'"
+        "$" -> "$"
+        "\\" -> "\\"
+        else -> "\\$c"
+    }
+
+    @Serializable
+    data class VideoLinks(
+        val HD: String? = null,
+        val SD: String? = null,
+        val FHD: String? = null,
+        val Source: String? = null,
+        val preview: String? = null,
+        val SourceMKV: String? = null
+    )
+
+
+}
+
+
+
+
+

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

@@ -20,9 +20,9 @@ class VkExtractor(private val client: OkHttpClient, private val headers: Headers
             .build()
     }
 
-    fun videosFromUrl(url: String, prefix: String) = videosFromUrl(url) { "${prefix}Vk:$it" }
+    fun videosFromUrl(url: String, prefix: String) = videosFromUrl(url) { "${prefix}Vk - $it" }
 
-    fun videosFromUrl(url: String, videoNameGen: (String) -> String = { quality -> "Vk:$quality" }): List<Video> {
+    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 {

src/pl/docchi/build.gradle

@@ -0,0 +1,20 @@
+ext {
+    extName = 'Docchi'
+    extClass = '.Docchi'
+    extVersionCode = 1
+    isNsfw = true
+}
+
+apply from: "$rootDir/common.gradle"
+
+dependencies {
+    implementation(project(':lib:dailymotion-extractor'))
+    implementation(project(':lib:mp4upload-extractor'))
+    implementation(project(':lib:sibnet-extractor'))
+    implementation(project(':lib:vk-extractor'))
+    implementation(project(':lib:googledrive-extractor'))
+    implementation(project(':lib:cda-extractor'))
+    implementation(project(':lib:dood-extractor'))
+    implementation(project(':lib:lycoris-extractor'))
+    implementation(project(':lib:lulu-extractor'))
+}

src/pl/docchi/src/eu/kanade/tachiyomi/animeextension/pl/docchi/Docchi.kt

@@ -0,0 +1,349 @@
+package eu.kanade.tachiyomi.animeextension.pl.docchi
+
+import android.app.Application
+import android.content.SharedPreferences
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.lib.cdaextractor.CdaPlExtractor
+import eu.kanade.tachiyomi.lib.dailymotionextractor.DailymotionExtractor
+import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
+import eu.kanade.tachiyomi.lib.googledriveextractor.GoogleDriveExtractor
+import eu.kanade.tachiyomi.lib.luluextractor.LuluExtractor
+import eu.kanade.tachiyomi.lib.lycorisextractor.LycorisCafeExtractor
+import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
+import eu.kanade.tachiyomi.lib.sibnetextractor.SibnetExtractor
+import eu.kanade.tachiyomi.lib.vkextractor.VkExtractor
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import okhttp3.Request
+import okhttp3.Response
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import uy.kohesive.injekt.injectLazy
+
+class Docchi : ConfigurableAnimeSource, AnimeHttpSource() {
+
+    override val name = "Docchi"
+
+    override val baseUrl = "https://docchi.pl"
+
+    private val baseApiUrl = "https://api.docchi.pl"
+
+    override val lang = "pl"
+
+    override val supportsLatest = true
+
+    private val json: Json by injectLazy()
+
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    // ============================== Popular ===============================
+
+    override fun popularAnimeRequest(page: Int) =
+        GET("$baseApiUrl/v1/series/list?limit=20&before=${(page - 1) * 20}")
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        val animeArray: List<ApiList> = json.decodeFromString(response.body.string())
+        val entries = animeArray.map { animeDetail ->
+            SAnime.create().apply {
+                title = animeDetail.title
+                url = "$baseUrl/production/as/${animeDetail.slug}"
+                thumbnail_url = animeDetail.cover
+            }
+        }
+        val hasNextPage = animeArray.isNotEmpty()
+
+        return AnimesPage(entries, hasNextPage)
+    }
+
+    // =============================== Latest ===============================
+
+    override fun latestUpdatesRequest(page: Int): Request =
+        GET("$baseApiUrl/v1/series/list?limit=20&before=${(page - 1) * 20}&sort=DESC")
+
+    override fun latestUpdatesParse(response: Response): AnimesPage = popularAnimeParse(response)
+
+    // =============================== Search ===============================
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request =
+        GET("$baseApiUrl/v1/series/related/$query")
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        val animeArray: List<ApiSearch> = json.decodeFromString(response.body.string())
+        val entries = animeArray.map { animeDetail ->
+            SAnime.create().apply {
+                title = animeDetail.title
+                url = "$baseUrl/production/as/${animeDetail.slug}"
+                thumbnail_url = animeDetail.cover
+            }
+        }
+        return AnimesPage(entries, false)
+    }
+    // ============================== Episodes ==============================
+
+    override fun episodeListRequest(anime: SAnime): Request =
+        GET("$baseApiUrl/v1/episodes/count/${anime.url.substringAfterLast("/")}")
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val episodeList: List<EpisodeList> = json.decodeFromString(response.body.string())
+        return episodeList.map { episode ->
+            SEpisode.create().apply {
+                name = "${episode.anime_episode_number.toInt()} Odcinek"
+                url = "$baseUrl/production/as/${episode.anime_id}/${episode.anime_episode_number}"
+                episode_number = episode.anime_episode_number
+                // date_upload = episode.created_at.toLong()
+            }
+        }.reversed()
+    }
+
+    // =========================== Anime Details ============================
+
+    override fun animeDetailsRequest(anime: SAnime): Request =
+        GET("$baseApiUrl/v1/series/find/${anime.url.substringAfterLast("/")}")
+
+    override fun animeDetailsParse(response: Response): SAnime {
+        val animeDetail: ApiDetail = json.decodeFromString(response.body.string())
+
+        return SAnime.create().apply {
+            title = animeDetail.title
+            description = animeDetail.description
+            genre = animeDetail.genres.joinToString(", ")
+        }
+    }
+
+    // ============================ Video Links =============================
+
+    override fun videoListRequest(episode: SEpisode): Request = GET(
+        "$baseApiUrl/v1/episodes/find/${
+            episode.url.substringBeforeLast("/").substringAfterLast("/")
+        }/${episode.episode_number}",
+    )
+
+    private val vkExtractor by lazy { VkExtractor(client, headers) }
+    private val cdaExtractor by lazy { CdaPlExtractor(client) }
+    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
+    private val dailymotionExtractor by lazy { DailymotionExtractor(client, headers) }
+    private val sibnetExtractor by lazy { SibnetExtractor(client) }
+    private val doodExtractor by lazy { DoodExtractor(client) }
+    private val lycorisExtractor by lazy { LycorisCafeExtractor(client) }
+    private val luluExtractor by lazy { LuluExtractor(client) }
+    private val googledriveExtractor by lazy { GoogleDriveExtractor(client, headers) }
+
+    override fun videoListParse(response: Response): List<Video> {
+        val videolist: List<VideoList> = json.decodeFromString(response.body.string())
+        val serverList = videolist.mapNotNull { player ->
+            var sub = player.translator_title.uppercase()
+
+            val prefix = if (player.isInverted) {
+                "[Odwrócone Kolory] $sub - "
+            } else {
+                "$sub - "
+            }
+
+            val playerName = player.player_hosting.lowercase()
+
+            if (playerName !in listOf(
+                    "vk",
+                    "cda",
+                    "mp4upload",
+                    "sibnet",
+                    "dailymotion",
+                    "dood",
+                    "lycoris.cafe",
+                    "lulustream",
+                    "gdrive",
+                    "google drive",
+                )
+            ) {
+                return@mapNotNull null
+            }
+
+            Pair(player.player, prefix)
+        }
+        // Jeśli dodadzą opcje z mozliwością edytowania mpv to zrobić tak ze jak bedą odwrócone kolory to ustawia dane do mkv <3
+        return serverList.parallelCatchingFlatMapBlocking { (serverUrl, prefix) ->
+            when {
+                serverUrl.contains("vk.com") -> {
+                    vkExtractor.videosFromUrl(serverUrl, prefix)
+                }
+
+                serverUrl.contains("mp4upload") -> {
+                    mp4uploadExtractor.videosFromUrl(serverUrl, headers, prefix)
+                }
+
+                serverUrl.contains("cda.pl") -> {
+                    cdaExtractor.getVideosFromUrl(serverUrl, headers, prefix)
+                }
+
+                serverUrl.contains("dailymotion") -> {
+                    dailymotionExtractor.videosFromUrl(serverUrl, "$prefix Dailymotion -")
+                }
+
+                serverUrl.contains("sibnet.ru") -> {
+                    sibnetExtractor.videosFromUrl(serverUrl, prefix)
+                }
+
+                serverUrl.contains("dood") -> {
+                    doodExtractor.videosFromUrl(serverUrl, "$prefix Dood")
+                }
+
+                serverUrl.contains("lycoris.cafe") -> {
+                    lycorisExtractor.getVideosFromUrl(serverUrl, headers, prefix)
+                }
+
+                serverUrl.contains("luluvdo.com") -> {
+                    luluExtractor.videosFromUrl(serverUrl, prefix)
+                }
+
+                serverUrl.contains("drive.google.com") -> {
+                    val regex = Regex("/d/([a-zA-Z0-9_-]+)")
+                    val id = regex.find(serverUrl)?.groupValues?.get(1).toString()
+                    googledriveExtractor.videosFromUrl(id, "${prefix}Gdrive -")
+                }
+
+                else -> emptyList()
+            }
+        }
+    }
+
+    // ============================= Utilities ==============================
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString("preferred_quality", "1080")!!
+        val server = preferences.getString("preferred_server", "cda.pl")!!
+
+        return this.sortedWith(
+            compareBy(
+                { it.quality.contains(quality) },
+                { it.quality.contains(server, true) },
+            ),
+        ).reversed()
+    }
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        val videoQualityPref = ListPreference(screen.context).apply {
+            key = "preferred_quality"
+            title = "Preferowana jakość"
+            entries = arrayOf("1080p", "720p", "480p", "360p")
+            entryValues = arrayOf("1080", "720", "480", "360")
+            setDefaultValue("1080")
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }
+        val videoServerPref = ListPreference(screen.context).apply {
+            key = "preferred_server"
+            title = "Preferowany serwer"
+            entries = arrayOf("cda.pl", "Dailymotion", "Mp4upload", "Sibnet", "vk.com")
+            entryValues = arrayOf("cda.pl", "Dailymotion", "Mp4upload", "Sibnet", "vk.com")
+            setDefaultValue("cda.pl")
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }
+
+        screen.addPreference(videoQualityPref)
+        screen.addPreference(videoServerPref)
+    }
+
+    @Serializable
+    data class ApiList(
+        val mal_id: Int,
+        val adult_content: String,
+        val title: String,
+        val title_en: String,
+        val slug: String,
+        val cover: String,
+        val genres: List<String>,
+        val broadcast_day: String?,
+        val aired_from: String?,
+        val episodes: Int,
+        val season: String,
+        val season_year: Int,
+        val series_type: String,
+    )
+
+    @Serializable
+    data class ApiSearch(
+        val mal_id: Int,
+        val ani_id: Int?,
+        val title: String,
+        val title_en: String,
+        val slug: String,
+        val cover: String,
+        val adult_content: String,
+        val series_type: String,
+        val episodes: Int,
+        val season: String,
+        val season_year: Int,
+    )
+
+    @Serializable
+    data class ApiDetail(
+        val id: Int,
+        val mal_id: Int,
+        val ani_id: Int?,
+        val adult_content: String,
+        val title: String,
+        val title_en: String,
+        val slug: String,
+        val slug_oa: String?,
+        val description: String,
+        val cover: String,
+        val bg: String?,
+        val genres: List<String>,
+        val broadcast_day: String?,
+        val aired_from: String?,
+        val episodes: Int,
+        val season: String,
+        val season_year: Int,
+        val series_type: String,
+        val ads: String?,
+        val modified: String?,
+    )
+
+    @Serializable
+    data class EpisodeList(
+        val anime_id: String,
+        val anime_episode_number: Float,
+        val isInverted: String,
+        val created_at: String,
+        val bg: String?,
+    )
+
+    @Serializable
+    data class VideoList(
+        val id: Int,
+        val anime_id: String,
+        val anime_episode_number: Float,
+        val player: String,
+        val player_hosting: String,
+        val created_at: String,
+        val translator: Boolean,
+        val translator_title: String,
+        val translator_url: String?,
+        val isInverted: Boolean,
+        val bg: String?,
+    )
+}

src/pl/ogladajanime/build.gradle

@@ -7,11 +7,3 @@ ext {
 
 apply from: "$rootDir/common.gradle"
 
-dependencies {
-    implementation(project(':lib:dailymotion-extractor'))
-    implementation(project(':lib:mp4upload-extractor'))
-    implementation(project(':lib:sibnet-extractor'))
-    implementation(project(':lib:vk-extractor'))
-    implementation(project(':lib:googledrive-extractor'))
-    implementation(project(':lib:cda-extractor'))
-}

src/pl/ogladajanime/src/eu/kanade/tachiyomi/animeextension/pl/ogladajanime/OgladajAnime.kt

@@ -10,17 +10,9 @@ 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.cdaextractor.CdaPlExtractor
-import eu.kanade.tachiyomi.lib.dailymotionextractor.DailymotionExtractor
-import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
-import eu.kanade.tachiyomi.lib.sibnetextractor.SibnetExtractor
-import eu.kanade.tachiyomi.lib.vkextractor.VkExtractor
 import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.network.POST
-import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
-import okhttp3.FormBody
 import okhttp3.Headers
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
@@ -57,7 +49,7 @@ class OgladajAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     // ============================== Popular ===============================
     override fun popularAnimeRequest(page: Int): Request {
-        return GET("$baseUrl/search/page/$page", headers)
+        return GET("$baseUrl/search/page/$page", apiHeaders)
     }
     override fun popularAnimeSelector(): String = "div#anime_main div.card.bg-white"
 
@@ -72,7 +64,7 @@ class OgladajAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     // =============================== Latest ===============================
 
-    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/search/new/$page", headers)
+    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/search/new/$page", apiHeaders)
 
     override fun latestUpdatesSelector(): String = popularAnimeSelector()
 
@@ -82,7 +74,7 @@ class OgladajAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     // =============================== Search ===============================
 
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request = GET("$baseUrl/search/name/$query", headers)
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request = GET("$baseUrl/search/name/$query", apiHeaders)
 
     override fun searchAnimeFromElement(element: Element): SAnime = popularAnimeFromElement(element)
 
@@ -90,8 +82,6 @@ class OgladajAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override fun searchAnimeNextPageSelector(): String? = null
 
-    // prosta bez filtrów jak na razie :) są dziury ale to kiedyś sie naprawi hihi. Wystarczy dobrze wyszukać animca i powinno wyszukać.
-
     // =========================== Anime Details ============================
     override fun animeDetailsParse(document: Document): SAnime {
         return SAnime.create().apply {
@@ -148,89 +138,25 @@ class OgladajAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     // ============================ Video Links =============================
 
-    private fun getPlayerUrl(id: String): String {
-        val body = FormBody.Builder()
-            .add("action", "change_player_url")
-            .add("id", id)
-            .build()
-        return client.newCall(POST("$baseUrl/manager.php", apiHeaders, body))
-            .execute()
-            .use { response ->
-                response.body.string()
-                    .substringAfter("\"data\":\"")
-                    .substringBefore("\",")
-                    .replace("\\", "")
-            }
-    }
-
     override fun videoListRequest(episode: SEpisode): Request {
-        val body = FormBody.Builder()
+        return GET("$baseUrl:8443/Player/${episode.url}", apiHeaders)
-            .add("action", "get_player_list")
-            .add("id", episode.url)
-            .build()
-        return POST("$baseUrl/manager.php", apiHeaders, body)
     }
 
-    private val vkExtractor by lazy { VkExtractor(client, headers) }
-    private val cdaExtractor by lazy { CdaPlExtractor(client) }
-    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
-    private val dailymotionExtractor by lazy { DailymotionExtractor(client, headers) }
-    private val sibnetExtractor by lazy { SibnetExtractor(client) }
-
     override fun videoListParse(response: Response): List<Video> {
-        val jsonResponse = json.decodeFromString<ApiResponse>(response.body.string())
+        val players = json.decodeFromString<List<ApiPlayer>>(response.body.string())
-        val dataObject = json.decodeFromString<ApiData>(jsonResponse.data)
-        val serverList = dataObject.players.mapNotNull { player ->
-            var sub = player.sub.uppercase()
-            if (player.audio == "pl") {
-                sub = "Lektor"
-            } else if (player.sub.isEmpty() && sub != "Lektor") {
-                sub = "Dub " + player.sub.uppercase()
-            }
 
-            val subGroup = if (sub == player.sub_group?.uppercase()) "" else player.sub_group
+        return players.map { player ->
-            val subGroupPart = if (subGroup?.isNotEmpty() == true) " $subGroup - " else " "
+            val host = Regex("""https?://(?:www\.)?([^/]+)""")
-
+                .find(player.mainUrl)
-            val prefix = if (player.ismy > 0) {
+                ?.groupValues
-                if (player.sub == "pl" && player.sub_group?.isNotEmpty() == true) {
+                ?.get(1)
-                    "[Odwrócone Kolory] $subGroup - "
+                ?: "unknown-host"
-                } else {
+            Video(
-                    "[$sub/Odwrócone Kolory]$subGroupPart"
+                url = player.mainUrl,
-                }
+                quality = if (player.extra == "inv") "[Odwrócone Kolory] $host - ${player.res}p" else "$host - ${player.res}p",
-            } else {
+                videoUrl = player.src,
-                if (player.sub == "pl" && player.sub_group?.isNotEmpty() == true) {
+                headers = null,
-                    "$subGroup - "
+            )
-                } else {
-                    "[$sub]$subGroupPart"
-                }
-            }
-
-            if (player.url !in listOf("vk", "cda", "mp4upload", "sibnet", "dailymotion")) {
-                return@mapNotNull null
-            }
-            val url = getPlayerUrl(player.id)
-            Pair(url, prefix)
-        }
-        // Jeśli dodadzą opcje z mozliwością edytowania mpv to zrobić tak ze jak bedą odwrócone kolory to ustawia dane do mkv <3
-        return serverList.parallelCatchingFlatMapBlocking { (serverUrl, prefix) ->
-            when {
-                serverUrl.contains("vk.com") -> {
-                    vkExtractor.videosFromUrl(serverUrl, prefix)
-                }
-                serverUrl.contains("mp4upload") -> {
-                    mp4uploadExtractor.videosFromUrl(serverUrl, headers, prefix)
-                }
-                serverUrl.contains("cda.pl") -> {
-                    cdaExtractor.getVideosFromUrl(serverUrl, headers, prefix)
-                }
-                serverUrl.contains("dailymotion") -> {
-                    dailymotionExtractor.videosFromUrl(serverUrl, "$prefix Dailymotion -")
-                }
-                serverUrl.contains("sibnet.ru") -> {
-                    sibnetExtractor.videosFromUrl(serverUrl, prefix)
-                }
-                else -> emptyList()
-            }
         }
     }
 
@@ -244,32 +170,23 @@ class OgladajAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     @Serializable
     data class ApiPlayer(
-        val id: String,
+        val mainUrl: String,
-        val audio: String? = null,
+        val label: String,
-        val sub: String,
+        val res: Int,
-        val url: String,
+        val src: String,
-        val sub_group: String? = null,
+        val type: String,
-        val ismy: Int,
+        val extra: String,
-    )
+        val startTime: Int,
-
+        val endTime: Int,
-    @Serializable
+        val ageValidation: Boolean,
-    data class ApiData(
+        val youtube: String? = null,
-        val players: List<ApiPlayer>,
-    )
-
-    @Serializable
-    data class ApiResponse(
-        val data: String,
     )
 
     override fun List<Video>.sort(): List<Video> {
         val quality = preferences.getString("preferred_quality", "1080")!!
-        val server = preferences.getString("preferred_server", "cda.pl")!!
-
         return this.sortedWith(
             compareBy(
                 { it.quality.contains(quality) },
-                { it.quality.contains(server, true) },
             ),
         ).reversed()
     }
@@ -290,23 +207,7 @@ class OgladajAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
                 preferences.edit().putString(key, entry).commit()
             }
         }
-        val videoServerPref = ListPreference(screen.context).apply {
-            key = "preferred_server"
-            title = "Preferowany serwer"
-            entries = arrayOf("cda.pl", "Dailymotion", "Mp4upload", "Sibnet", "vk.com")
-            entryValues = arrayOf("cda.pl", "Dailymotion", "Mp4upload", "Sibnet", "vk.com")
-            setDefaultValue("cda.pl")
-            summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
-        }
 
         screen.addPreference(videoQualityPref)
-        screen.addPreference(videoServerPref)
     }
 }