Add files via upload

Crunchyroll/build.gradle.kts

@@ -0,0 +1,22 @@
+// use an integer for version numbers
+version = 5
+
+
+cloudstream {
+    language = "en"
+    // All of these properties are optional, you can safely remove them
+
+    description = "The Crunchyroll provider allows you to watch all the shows that are on Crunchyroll."
+    authors = listOf("Sir Aguacata (KillerDogeEmpire)")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 0 // will be 3 if unspecified
+    tvTypes = listOf("AnimeMovie", "Anime", "OVA")
+    iconUrl = "https://www.google.com/s2/favicons?domain=crunchyroll.com&sz=%size%"
+}

Crunchyroll/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.lagradost"/>

Crunchyroll/src/main/kotlin/com/lagradost/CookieInterceptor.kt

@@ -0,0 +1,46 @@
+package com.lagradost
+
+import com.lagradost.nicehttp.Requests
+import okhttp3.*
+import okhttp3.internal.parseCookie
+
+/**
+ * An HTTP session manager.
+ *
+ * This class simply keeps cookies across requests. No security about which site should use which cookies.
+ *
+ */
+
+class CustomSession(
+    client: OkHttpClient
+) : Requests() {
+    var cookies = mutableMapOf<String, Cookie>()
+
+    init {
+        this.baseClient = client
+            .newBuilder()
+            .addInterceptor {
+                val time = System.currentTimeMillis()
+                val request = it.request()
+                request.headers.forEach { header ->
+                    if (header.first.equals("cookie", ignoreCase = true)) {
+                        val cookie = parseCookie(time, request.url, header.second) ?: return@forEach
+                        cookies += cookie.name to cookie
+                    }
+                }
+                it.proceed(request)
+            }
+            .cookieJar(CustomCookieJar())
+            .build()
+    }
+
+    inner class CustomCookieJar : CookieJar {
+        override fun loadForRequest(url: HttpUrl): List<Cookie> {
+            return this@CustomSession.cookies.values.toList()
+        }
+
+        override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
+            this@CustomSession.cookies += cookies.map { it.name to it }
+        }
+    }
+}

Crunchyroll/src/main/kotlin/com/lagradost/CrunchyrollProvider.kt

@@ -0,0 +1,513 @@
+package com.lagradost
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.APIHolder.capitalize
+import com.lagradost.cloudstream3.utils.AppUtils.parseJson
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.M3u8Helper
+import com.lagradost.cloudstream3.utils.Qualities
+import com.lagradost.cloudstream3.utils.getQualityFromName
+import com.lagradost.nicehttp.NiceResponse
+import kotlinx.coroutines.delay
+import org.jsoup.Jsoup
+import java.util.*
+
+private fun String.toAscii() = this.map { it.code }.joinToString()
+
+class KrunchyGeoBypasser {
+    companion object {
+        const val BYPASS_SERVER = "https://cr-unblocker.us.to/start_session"
+        val headers = mapOf(
+            "accept" to "*/*",
+//            "Accept-Encoding" to "gzip, deflate",
+            "connection" to "keep-alive",
+//            "Referer" to "https://google.com/",
+            "user-agent" to "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36".toAscii()
+        )
+        var sessionId: String? = null
+
+        //        val interceptor = CookieInterceptor()
+        val session = CustomSession(app.baseClient)
+    }
+
+    data class KrunchySession(
+        @JsonProperty("data") var data: DataInfo? = DataInfo(),
+        @JsonProperty("error") var error: Boolean? = null,
+        @JsonProperty("code") var code: String? = null
+    )
+
+    data class DataInfo(
+        @JsonProperty("session_id") var sessionId: String? = null,
+        @JsonProperty("country_code") var countryCode: String? = null,
+    )
+
+    private suspend fun getSessionId(): Boolean {
+        return try {
+            val response = app.get(BYPASS_SERVER, params = mapOf("version" to "1.1")).text
+            val json = parseJson<KrunchySession>(response)
+            sessionId = json.data?.sessionId
+            true
+        } catch (e: Exception) {
+            sessionId = null
+            false
+        }
+    }
+
+    private suspend fun autoLoadSession(): Boolean {
+        if (sessionId != null) return true
+        getSessionId()
+        // Do not spam the api!
+        delay(3000)
+        return autoLoadSession()
+    }
+
+    suspend fun geoBypassRequest(url: String): NiceResponse {
+        autoLoadSession()
+        return session.get(url, headers = headers, cookies = mapOf("session_id" to sessionId!!))
+    }
+}
+
+class KrunchyProvider : MainAPI() {
+    companion object {
+        val crUnblock = KrunchyGeoBypasser()
+        val episodeNumRegex = Regex("""Episode (\d+)""")
+    }
+
+    // Do not make https! It will fail!
+    override var mainUrl = "http://www.crunchyroll.com"
+    override var name: String = "Crunchyroll"
+    override var lang = "en"
+    override val hasQuickSearch = false
+    override val hasMainPage = true
+
+    override val supportedTypes = setOf(
+        TvType.AnimeMovie,
+        TvType.Anime,
+        TvType.OVA
+    )
+
+    override val mainPage = mainPageOf(
+        "$mainUrl/videos/anime/popular/ajax_page?pg=" to "Popular",
+        "$mainUrl/videos/anime/simulcasts/ajax_page" to "Simulcasts"
+    )
+
+    override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
+        println("GETMAINPAGE ")
+        val categoryData = request.data
+
+        val paginated = categoryData.endsWith("=")
+        val pagedLink = if (paginated) categoryData + page else categoryData
+        val items = mutableListOf<HomePageList>()
+
+        // Only fetch page at first-time load of homepage
+        if (page <= 1 && request.name == "Popular") {
+            val doc = Jsoup.parse(crUnblock.geoBypassRequest(mainUrl).text)
+            val featured = doc.select(".js-featured-show-list > li").mapNotNull { anime ->
+                val url =
+                    fixUrlNull(anime?.selectFirst("a")?.attr("href")) ?: return@mapNotNull null
+                val imgEl = anime.selectFirst("img")
+                val name = imgEl?.attr("alt") ?: ""
+                val posterUrl = imgEl?.attr("src")?.replace("small", "full")
+                AnimeSearchResponse(
+                    name = name,
+                    url = url,
+                    apiName = this.name,
+                    type = TvType.Anime,
+                    posterUrl = posterUrl,
+                    dubStatus = EnumSet.of(DubStatus.Subbed)
+                )
+            }
+            val recent =
+                doc.select("div.welcome-countdown-day:contains(Now Showing) li").mapNotNull {
+                    val link =
+                        fixUrlNull(it.selectFirst("a")?.attr("href")) ?: return@mapNotNull null
+                    val name = it.selectFirst("span.welcome-countdown-name")?.text() ?: ""
+                    val img = it.selectFirst("img")?.attr("src")?.replace("medium", "full")
+                    val dubstat = if (name.contains("Dub)", true)) EnumSet.of(DubStatus.Dubbed) else
+                        EnumSet.of(DubStatus.Subbed)
+                    val details = it.selectFirst("span.welcome-countdown-details")?.text()
+                    val epnum =
+                        if (details.isNullOrBlank()) null else episodeNumRegex.find(details)?.value?.replace(
+                            "Episode ",
+                            ""
+                        ) ?: "0"
+                    val episodesMap = mutableMapOf<DubStatus, Int>()
+                    episodesMap[DubStatus.Subbed] = epnum?.toIntOrNull() ?: 0
+                    episodesMap[DubStatus.Dubbed] = epnum?.toIntOrNull() ?: 0
+                    AnimeSearchResponse(
+                        name = "★ $name ★",
+                        url = link.replace(Regex("(\\/episode.*)"), ""),
+                        apiName = this.name,
+                        type = TvType.Anime,
+                        posterUrl = fixUrlNull(img),
+                        dubStatus = dubstat,
+                        episodes = episodesMap
+                    )
+                }
+            if (recent.isNotEmpty()) {
+                items.add(
+                    HomePageList(
+                        name = "Now Showing",
+                        list = recent,
+                    )
+                )
+            }
+            if (featured.isNotEmpty()) {
+                items.add(HomePageList("Featured", featured))
+            }
+        }
+
+        if (paginated || !paginated && page <= 1) {
+            crUnblock.geoBypassRequest(pagedLink).let { respText ->
+                val soup = Jsoup.parse(respText.text)
+
+                val episodes = soup.select("li").mapNotNull {
+                    val innerA = it.selectFirst("a") ?: return@mapNotNull null
+                    val urlEps = fixUrlNull(innerA.attr("href")) ?: return@mapNotNull null
+                    AnimeSearchResponse(
+                        name = innerA.attr("title"),
+                        url = urlEps,
+                        apiName = this.name,
+                        type = TvType.Anime,
+                        posterUrl = it.selectFirst("img")?.attr("src"),
+                        dubStatus = EnumSet.of(DubStatus.Subbed)
+                    )
+                }
+                if (episodes.isNotEmpty()) {
+                    items.add(
+                        HomePageList(
+                            name = request.name,
+                            list = episodes,
+                        )
+                    )
+                }
+            }
+        }
+
+        if (items.isNotEmpty()) {
+            return newHomePageResponse(items)
+        }
+        throw ErrorLoadingException()
+    }
+
+    // Maybe fuzzy match in the future
+    private fun getCloseMatches(sequence: String, items: Collection<String>): List<String> {
+        val a = sequence.trim().lowercase()
+
+        return items.mapNotNull { item ->
+            val b = item.trim().lowercase()
+            if (b.contains(a))
+                item
+            else if (a.contains(b))
+                item
+            else null
+        }
+    }
+
+    private data class CrunchyAnimeData(
+        @JsonProperty("name") val name: String,
+        @JsonProperty("img") var img: String,
+        @JsonProperty("link") var link: String
+    )
+
+    private data class CrunchyJson(
+        @JsonProperty("data") val data: List<CrunchyAnimeData>,
+    )
+
+
+    override suspend fun search(query: String): ArrayList<SearchResponse> {
+        val json =
+            crUnblock.geoBypassRequest("http://www.crunchyroll.com/ajax/?req=RpcApiSearch_GetSearchCandidates").text.split(
+                "*/"
+            )[0].replace("\\/", "/")
+        val data = parseJson<CrunchyJson>(
+            json.split("\n").mapNotNull { if (!it.startsWith("/")) it else null }.joinToString("\n")
+        ).data
+
+        val results = getCloseMatches(query, data.map { it.name })
+        if (results.isEmpty()) return ArrayList()
+        val searchResutls = ArrayList<SearchResponse>()
+
+        var count = 0
+        for (anime in data) {
+            if (count == results.size) {
+                break
+            }
+            if (anime.name == results[count]) {
+                val dubstat =
+                    if (anime.name.contains("Dub)", true)) EnumSet.of(DubStatus.Dubbed) else
+                        EnumSet.of(DubStatus.Subbed)
+                anime.link = fixUrl(anime.link)
+                anime.img = anime.img.replace("small", "full")
+                searchResutls.add(
+                    AnimeSearchResponse(
+                        name = anime.name,
+                        url = anime.link,
+                        apiName = this.name,
+                        type = TvType.Anime,
+                        posterUrl = anime.img,
+                        dubStatus = dubstat,
+                    )
+                )
+                ++count
+            }
+        }
+
+        return searchResutls
+    }
+
+    override suspend fun load(url: String): LoadResponse {
+        val soup = Jsoup.parse(crUnblock.geoBypassRequest(url).text)
+        val title = soup.selectFirst("#showview-content-header .ellipsis")?.text()?.trim()
+        val posterU = soup.selectFirst(".poster")?.attr("src")
+
+        val p = soup.selectFirst(".description")
+        var description = p?.selectFirst(".more")?.text()?.trim()
+        if (description.isNullOrBlank()) {
+            description = p?.selectFirst("span")?.text()?.trim()
+        }
+
+        val genres = soup.select(".large-margin-bottom > ul:nth-child(2) li:nth-child(2) a")
+            .map { it.text().capitalize() }
+        val year = genres.filter { it.toIntOrNull() != null }.map { it.toInt() }.sortedBy { it }
+            .getOrNull(0)
+
+        val subEpisodes = mutableListOf<Episode>()
+        val dubEpisodes = mutableListOf<Episode>()
+        val premiumSubEpisodes = mutableListOf<Episode>()
+        val premiumDubEpisodes = mutableListOf<Episode>()
+        soup.select(".season").forEach {
+            val seasonName = it.selectFirst("a.season-dropdown")?.text()?.trim()
+            it.select(".episode").forEach { ep ->
+                val epTitle = ep.selectFirst(".short-desc")?.text()
+
+                val epNum = episodeNumRegex.find(
+                    ep.selectFirst("span.ellipsis")?.text().toString()
+                )?.destructured?.component1()
+                var poster = ep.selectFirst("img.landscape")?.attr("data-thumbnailurl")
+                val poster2 = ep.selectFirst("img")?.attr("src")
+                if (poster.isNullOrBlank()) {
+                    poster = poster2
+                }
+
+                var epDesc =
+                    (if (epNum == null) "" else "Episode $epNum") + (if (!seasonName.isNullOrEmpty()) " - $seasonName" else "")
+                val isPremium = poster?.contains("widestar", ignoreCase = true) ?: false
+                if (isPremium) {
+                    epDesc = "★ $epDesc ★"
+                }
+
+                val isPremiumDubbed =
+                    isPremium && seasonName != null && (seasonName.contains("Dub") || seasonName.contains(
+                        "Russian"
+                    ) || seasonName.contains("Spanish"))
+
+                val epi = Episode(
+                    fixUrl(ep.attr("href")),
+                    "$epTitle",
+                    posterUrl = poster?.replace("widestar", "full")?.replace("wide", "full"),
+                    description = epDesc,
+                    season = if (isPremium) -1 else 1
+                )
+                if (isPremiumDubbed) {
+                    premiumDubEpisodes.add(epi)
+                } else if (isPremium) {
+                    premiumSubEpisodes.add(epi)
+                } else if (seasonName != null && (seasonName.contains("Dub"))) {
+                    dubEpisodes.add(epi)
+                } else {
+                    subEpisodes.add(epi)
+                }
+            }
+        }
+        val recommendations =
+            soup.select(".other-series > ul li")?.mapNotNull { element ->
+                val recTitle =
+                    element.select("span.ellipsis[dir=auto]").text() ?: return@mapNotNull null
+                val image = element.select("img")?.attr("src")
+                val recUrl = fixUrl(element.select("a").attr("href"))
+                AnimeSearchResponse(
+                    recTitle,
+                    fixUrl(recUrl),
+                    this.name,
+                    TvType.Anime,
+                    fixUrl(image!!),
+                    dubStatus =
+                    if (recTitle.contains("(DUB)") || recTitle.contains("Dub")) EnumSet.of(
+                        DubStatus.Dubbed
+                    ) else EnumSet.of(DubStatus.Subbed),
+                )
+            }
+        return newAnimeLoadResponse(title.toString(), url, TvType.Anime) {
+            this.posterUrl = posterU
+            this.engName = title
+            if (subEpisodes.isNotEmpty()) addEpisodes(DubStatus.Subbed, subEpisodes.reversed())
+            if (dubEpisodes.isNotEmpty()) addEpisodes(DubStatus.Dubbed, dubEpisodes.reversed())
+
+            if (premiumDubEpisodes.isNotEmpty()) addEpisodes(
+                DubStatus.Dubbed,
+                premiumDubEpisodes.reversed()
+            )
+            if (premiumSubEpisodes.isNotEmpty()) addEpisodes(
+                DubStatus.Subbed,
+                premiumSubEpisodes.reversed()
+            )
+
+            this.plot = description
+            this.tags = genres
+            this.year = year
+
+            this.recommendations = recommendations
+            this.seasonNames = listOf(
+                SeasonData(
+                    1,
+                    "Free",
+                    null
+                ),
+                SeasonData(
+                    -1,
+                    "Premium",
+                    null
+                ),
+            )
+        }
+    }
+
+    data class Subtitles(
+        @JsonProperty("language") val language: String,
+        @JsonProperty("url") val url: String,
+        @JsonProperty("title") val title: String?,
+        @JsonProperty("format") val format: String?
+    )
+
+    data class Streams(
+        @JsonProperty("format") val format: String?,
+        @JsonProperty("audio_lang") val audioLang: String?,
+        @JsonProperty("hardsub_lang") val hardsubLang: String?,
+        @JsonProperty("url") val url: String,
+        @JsonProperty("resolution") val resolution: String?,
+        @JsonProperty("title") var title: String?
+    ) {
+        fun title(): String {
+            return when {
+                this.hardsubLang == "enUS" && this.audioLang == "jaJP" -> "Hardsub (English)"
+                this.hardsubLang == "esLA" && this.audioLang == "jaJP" -> "Hardsub (Latino)"
+                this.hardsubLang == "esES" && this.audioLang == "jaJP" -> "Hardsub (Español España)"
+                this.audioLang == "esLA" -> "Latino"
+                this.audioLang == "esES" -> "Español España"
+                this.audioLang == "enUS" -> "English (US)"
+                else -> "RAW"
+            }
+        }
+    }
+
+    data class KrunchyVideo(
+        @JsonProperty("streams") val streams: List<Streams>,
+        @JsonProperty("subtitles") val subtitles: List<Subtitles>,
+    )
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+        val contentRegex = Regex("""vilos\.config\.media = (\{.+\})""")
+        val response = crUnblock.geoBypassRequest(data)
+
+        val hlsHelper = M3u8Helper()
+
+        val dat = contentRegex.find(response.text)?.destructured?.component1()
+
+        if (!dat.isNullOrEmpty()) {
+            val json = parseJson<KrunchyVideo>(dat)
+            val streams = ArrayList<Streams>()
+
+            for (stream in json.streams) {
+                if (
+                    listOf(
+                        "adaptive_hls", "adaptive_dash",
+                        "multitrack_adaptive_hls_v2",
+                        "vo_adaptive_dash", "vo_adaptive_hls",
+                        "trailer_hls",
+                    ).contains(stream.format)
+                ) {
+                    if (stream.format!!.contains("adaptive") && listOf(
+                            "jaJP",
+                            "esLA",
+                            "esES",
+                            "enUS"
+                        )
+                            .contains(stream.audioLang) && (listOf(
+                            "esLA",
+                            "esES",
+                            "enUS",
+                            null
+                        ).contains(stream.hardsubLang))
+//                        && URI(stream.url).path.endsWith(".m3u")
+                    ) {
+                        stream.title = stream.title()
+                        streams.add(stream)
+                    }
+                    // Premium eps
+                    else if (stream.format == "trailer_hls" && listOf(
+                            "jaJP",
+                            "esLA",
+                            "esES",
+                            "enUS"
+                        ).contains(stream.audioLang) &&
+                        (listOf("esLA", "esES", "enUS", null).contains(stream.hardsubLang))
+                    ) {
+                        stream.title = stream.title()
+                        streams.add(stream)
+                    }
+                }
+            }
+
+            streams.apmap { stream ->
+                if (stream.url.contains("m3u8") && stream.format!!.contains("adaptive")) {
+//                    hlsHelper.m3u8Generation(M3u8Helper.M3u8Stream(stream.url, null), false)
+//                        .forEach {
+                    callback(
+                        ExtractorLink(
+                            "Crunchyroll",
+                            "Crunchy - ${stream.title}",
+                            stream.url,
+                            "",
+                            getQualityFromName(stream.resolution),
+                            true
+                        )
+                    )
+//                        }
+                } else if (stream.format == "trailer_hls") {
+                    val premiumStream = stream.url
+                        .replace("\\/", "/")
+                        .replace(Regex("\\/clipFrom.*?index.m3u8"), "").replace("'_,'", "'_'")
+                        .replace(stream.url.split("/")[2], "fy.v.vrv.co")
+                    callback(
+                        ExtractorLink(
+                            this.name,
+                            "Crunchy - ${stream.title} ★",
+                            premiumStream,
+                            "",
+                            Qualities.Unknown.value,
+                            false
+                        )
+                    )
+                } else null
+            }
+            json.subtitles.forEach {
+                val langclean = it.language.replace("esLA", "Spanish")
+                    .replace("enUS", "English")
+                    .replace("esES", "Spanish (Spain)")
+                subtitleCallback(
+                    SubtitleFile(langclean, it.url)
+                )
+            }
+
+            return true
+        }
+        return false
+    }
+}

Crunchyroll/src/main/kotlin/com/lagradost/CrunchyrollProviderPlugin.kt

@@ -0,0 +1,14 @@
+
+package com.lagradost
+
+import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
+import com.lagradost.cloudstream3.plugins.Plugin
+import android.content.Context
+
+@CloudstreamPlugin
+class CrunchyrollProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(KrunchyProvider())
+    }
+}

GogoanimeProvider/build.gradle.kts

@@ -0,0 +1,27 @@
+// use an integer for version numbers
+version = 1
+
+
+cloudstream {
+    language = "en"
+    // All of these properties are optional, you can safely remove them
+
+    // description = "Lorem Ipsum"
+    // authors = listOf("Cloudburst")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 1 // will be 3 if unspecified
+    tvTypes = listOf(
+        "AnimeMovie",
+        "Anime",
+        "OVA",
+    )
+
+    iconUrl = "https://www.google.com/s2/favicons?domain=gogoanime.lu&sz=%size%"
+}

GogoanimeProvider/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.lagradost"/>

GogoanimeProvider/src/main/kotlin/com/lagradost/GogoanimeProvider.kt

@@ -0,0 +1,412 @@
+package com.lagradost
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.mvvm.normalSafeApiCall
+import com.lagradost.cloudstream3.mvvm.safeApiCall
+import com.lagradost.cloudstream3.utils.AppUtils
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.getQualityFromName
+import com.lagradost.cloudstream3.utils.loadExtractor
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+import java.net.URI
+import java.util.*
+import javax.crypto.Cipher
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.SecretKeySpec
+
+class GogoanimeProvider : MainAPI() {
+    companion object {
+        fun getType(t: String): TvType {
+            return if (t.contains("OVA") || t.contains("Special")) TvType.OVA
+            else if (t.contains("Movie")) TvType.AnimeMovie
+            else TvType.Anime
+        }
+
+        fun getStatus(t: String): ShowStatus {
+            return when (t) {
+                "Completed" -> ShowStatus.Completed
+                "Ongoing" -> ShowStatus.Ongoing
+                else -> ShowStatus.Completed
+            }
+        }
+
+        /**
+         * @param id base64Decode(show_id) + IV
+         * @return the encryption key
+         * */
+        private fun getKey(id: String): String? {
+            return normalSafeApiCall {
+                id.map {
+                    it.code.toString(16)
+                }.joinToString("").substring(0, 32)
+            }
+        }
+
+        val qualityRegex = Regex("(\\d+)P")
+
+        // https://github.com/saikou-app/saikou/blob/3e756bd8e876ad7a9318b17110526880525a5cd3/app/src/main/java/ani/saikou/anime/source/extractors/GogoCDN.kt#L60
+        // No Licence on the function
+        private fun cryptoHandler(
+            string: String,
+            iv: String,
+            secretKeyString: String,
+            encrypt: Boolean = true
+        ): String {
+            //println("IV: $iv, Key: $secretKeyString, encrypt: $encrypt, Message: $string")
+            val ivParameterSpec = IvParameterSpec(iv.toByteArray())
+            val secretKey = SecretKeySpec(secretKeyString.toByteArray(), "AES")
+            val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+            return if (!encrypt) {
+                cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec)
+                String(cipher.doFinal(base64DecodeArray(string)))
+            } else {
+                cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec)
+                base64Encode(cipher.doFinal(string.toByteArray()))
+            }
+        }
+
+        private fun String.decodeHex(): ByteArray {
+            check(length % 2 == 0) { "Must have an even length" }
+            return chunked(2)
+                .map { it.toInt(16).toByte() }
+                .toByteArray()
+        }
+
+        /**
+         * @param iframeUrl something like https://gogoplay4.com/streaming.php?id=XXXXXX
+         * @param mainApiName used for ExtractorLink names and source
+         * @param iv secret iv from site, required non-null if isUsingAdaptiveKeys is off
+         * @param secretKey secret key for decryption from site, required non-null if isUsingAdaptiveKeys is off
+         * @param secretDecryptKey secret key to decrypt the response json, required non-null if isUsingAdaptiveKeys is off
+         * @param isUsingAdaptiveKeys generates keys from IV and ID, see getKey()
+         * @param isUsingAdaptiveData generate encrypt-ajax data based on $("script[data-name='episode']")[0].dataset.value
+         * */
+        suspend fun extractVidstream(
+            iframeUrl: String,
+            mainApiName: String,
+            callback: (ExtractorLink) -> Unit,
+            iv: String?,
+            secretKey: String?,
+            secretDecryptKey: String?,
+            // This could be removed, but i prefer it verbose
+            isUsingAdaptiveKeys: Boolean,
+            isUsingAdaptiveData: Boolean,
+            // If you don't want to re-fetch the document
+            iframeDocument: Document? = null
+        ) = safeApiCall {
+            // https://github.com/saikou-app/saikou/blob/3e756bd8e876ad7a9318b17110526880525a5cd3/app/src/main/java/ani/saikou/anime/source/extractors/GogoCDN.kt
+            // No Licence on the following code
+            // Also modified of https://github.com/jmir1/aniyomi-extensions/blob/master/src/en/gogoanime/src/eu/kanade/tachiyomi/animeextension/en/gogoanime/extractors/GogoCdnExtractor.kt
+            // License on the code above  https://github.com/jmir1/aniyomi-extensions/blob/master/LICENSE
+
+            if ((iv == null || secretKey == null || secretDecryptKey == null) && !isUsingAdaptiveKeys)
+                return@safeApiCall
+
+            val id = Regex("id=([^&]+)").find(iframeUrl)!!.value.removePrefix("id=")
+
+            var document: Document? = iframeDocument
+            val foundIv =
+                iv ?: (document ?: app.get(iframeUrl).document.also { document = it })
+                    .select("""div.wrapper[class*=container]""")
+                    .attr("class").split("-").lastOrNull() ?: return@safeApiCall
+            val foundKey = secretKey ?: getKey(base64Decode(id) + foundIv) ?: return@safeApiCall
+            val foundDecryptKey = secretDecryptKey ?: foundKey
+
+            val uri = URI(iframeUrl)
+            val mainUrl = "https://" + uri.host
+
+            val encryptedId = cryptoHandler(id, foundIv, foundKey)
+            val encryptRequestData = if (isUsingAdaptiveData) {
+                // Only fetch the document if necessary
+                val realDocument = document ?: app.get(iframeUrl).document
+                val dataEncrypted =
+                    realDocument.select("script[data-name='episode']").attr("data-value")
+                val headers = cryptoHandler(dataEncrypted, foundIv, foundKey, false)
+                "id=$encryptedId&alias=$id&" + headers.substringAfter("&")
+            } else {
+                "id=$encryptedId&alias=$id"
+            }
+
+            val jsonResponse =
+                app.get(
+                    "$mainUrl/encrypt-ajax.php?$encryptRequestData",
+                    headers = mapOf("X-Requested-With" to "XMLHttpRequest")
+                )
+            val dataencrypted =
+                jsonResponse.text.substringAfter("{\"data\":\"").substringBefore("\"}")
+            val datadecrypted = cryptoHandler(dataencrypted, foundIv, foundDecryptKey, false)
+            val sources = AppUtils.parseJson<GogoSources>(datadecrypted)
+
+            fun invokeGogoSource(
+                source: GogoSource,
+                sourceCallback: (ExtractorLink) -> Unit
+            ) {
+                sourceCallback.invoke(
+                    ExtractorLink(
+                        mainApiName,
+                        mainApiName,
+                        source.file,
+                        mainUrl,
+                        getQualityFromName(source.label),
+                        isM3u8 = source.type == "hls" || source.label?.contains(
+                            "auto",
+                            ignoreCase = true
+                        ) == true
+                    )
+                )
+            }
+
+            sources.source?.forEach {
+                invokeGogoSource(it, callback)
+            }
+            sources.sourceBk?.forEach {
+                invokeGogoSource(it, callback)
+            }
+        }
+    }
+
+    override var mainUrl = "https://gogoanime.lu"
+    override var name = "GogoAnime"
+    override val hasQuickSearch = false
+    override val hasMainPage = true
+
+    override val supportedTypes = setOf(
+        TvType.AnimeMovie,
+        TvType.Anime,
+        TvType.OVA
+    )
+
+    val headers = mapOf(
+        "authority" to "ajax.gogo-load.com",
+        "sec-ch-ua" to "\"Google Chrome\";v=\"89\", \"Chromium\";v=\"89\", \";Not A Brand\";v=\"99\"",
+        "accept" to "text/html, */*; q=0.01",
+        "dnt" to "1",
+        "sec-ch-ua-mobile" to "?0",
+        "user-agent" to "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36",
+        "origin" to mainUrl,
+        "sec-fetch-site" to "cross-site",
+        "sec-fetch-mode" to "cors",
+        "sec-fetch-dest" to "empty",
+        "referer" to "$mainUrl/"
+    )
+    val parseRegex =
+        Regex("""<li>\s*\n.*\n.*<a\s*href=["'](.*?-episode-(\d+))["']\s*title=["'](.*?)["']>\n.*?img src="(.*?)"""")
+
+    override val mainPage = mainPageOf(
+        Pair("1", "Recent Release - Sub"),
+        Pair("2", "Recent Release - Dub"),
+        Pair("3", "Recent Release - Chinese"),
+    )
+
+    override suspend fun getMainPage(
+        page: Int,
+        request : MainPageRequest
+    ): HomePageResponse {
+        val params = mapOf("page" to page.toString(), "type" to request.data)
+        val html = app.get(
+            "https://ajax.gogo-load.com/ajax/page-recent-release.html",
+            headers = headers,
+            params = params
+        )
+        val isSub = listOf(1, 3).contains(request.data.toInt())
+
+        val home = parseRegex.findAll(html.text).map {
+            val (link, epNum, title, poster) = it.destructured
+            newAnimeSearchResponse(title, link) {
+                this.posterUrl = poster
+                addDubStatus(!isSub, epNum.toIntOrNull())
+            }
+        }.toList()
+
+        return newHomePageResponse(request.name, home)
+    }
+
+    override suspend fun search(query: String): ArrayList<SearchResponse> {
+        val link = "$mainUrl/search.html?keyword=$query"
+        val html = app.get(link).text
+        val doc = Jsoup.parse(html)
+
+        val episodes = doc.select(""".last_episodes li""").mapNotNull {
+            AnimeSearchResponse(
+                it.selectFirst(".name")?.text()?.replace(" (Dub)", "") ?: return@mapNotNull null,
+                fixUrl(it.selectFirst(".name > a")?.attr("href") ?: return@mapNotNull null),
+                this.name,
+                TvType.Anime,
+                it.selectFirst("img")?.attr("src"),
+                it.selectFirst(".released")?.text()?.split(":")?.getOrNull(1)?.trim()
+                    ?.toIntOrNull(),
+                if (it.selectFirst(".name")?.text()
+                        ?.contains("Dub") == true
+                ) EnumSet.of(DubStatus.Dubbed) else EnumSet.of(
+                    DubStatus.Subbed
+                ),
+            )
+        }
+
+        return ArrayList(episodes)
+    }
+
+    private fun getProperAnimeLink(uri: String): String {
+        if (uri.contains("-episode")) {
+            val split = uri.split("/")
+            val slug = split[split.size - 1].split("-episode")[0]
+            return "$mainUrl/category/$slug"
+        }
+        return uri
+    }
+
+    override suspend fun load(url: String): LoadResponse {
+        val link = getProperAnimeLink(url)
+        val episodeloadApi = "https://ajax.gogo-load.com/ajax/load-list-episode"
+        val doc = app.get(link).document
+
+        val animeBody = doc.selectFirst(".anime_info_body_bg")
+        val title = animeBody?.selectFirst("h1")!!.text()
+        val poster = animeBody.selectFirst("img")?.attr("src")
+        var description: String? = null
+        val genre = ArrayList<String>()
+        var year: Int? = null
+        var status: String? = null
+        var nativeName: String? = null
+        var type: String? = null
+
+        animeBody.select("p.type").forEach { pType ->
+            when (pType.selectFirst("span")?.text()?.trim()) {
+                "Plot Summary:" -> {
+                    description = pType.text().replace("Plot Summary:", "").trim()
+                }
+                "Genre:" -> {
+                    genre.addAll(pType.select("a").map {
+                        it.attr("title")
+                    })
+                }
+                "Released:" -> {
+                    year = pType.text().replace("Released:", "").trim().toIntOrNull()
+                }
+                "Status:" -> {
+                    status = pType.text().replace("Status:", "").trim()
+                }
+                "Other name:" -> {
+                    nativeName = pType.text().replace("Other name:", "").trim()
+                }
+                "Type:" -> {
+                    type = pType.text().replace("type:", "").trim()
+                }
+            }
+        }
+
+        val animeId = doc.selectFirst("#movie_id")!!.attr("value")
+        val params = mapOf("ep_start" to "0", "ep_end" to "2000", "id" to animeId)
+
+        val episodes = app.get(episodeloadApi, params = params).document.select("a").map {
+            Episode(
+                fixUrl(it.attr("href").trim()),
+                "Episode " + it.selectFirst(".name")?.text()?.replace("EP", "")?.trim()
+            )
+        }.reversed()
+
+        return newAnimeLoadResponse(title, link, getType(type.toString())) {
+            japName = nativeName
+            engName = title
+            posterUrl = poster
+            this.year = year
+            addEpisodes(DubStatus.Subbed, episodes) // TODO CHECK
+            plot = description
+            tags = genre
+
+            showStatus = getStatus(status.toString())
+        }
+    }
+
+    data class GogoSources(
+        @JsonProperty("source") val source: List<GogoSource>?,
+        @JsonProperty("sourceBk") val sourceBk: List<GogoSource>?,
+        //val track: List<Any?>,
+        //val advertising: List<Any?>,
+        //val linkiframe: String
+    )
+
+    data class GogoSource(
+        @JsonProperty("file") val file: String,
+        @JsonProperty("label") val label: String?,
+        @JsonProperty("type") val type: String?,
+        @JsonProperty("default") val default: String? = null
+    )
+
+    private suspend fun extractVideos(
+        uri: String,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ) {
+        val doc = app.get(uri).document
+
+        val iframe = fixUrlNull(doc.selectFirst("div.play-video > iframe")?.attr("src")) ?: return
+
+        argamap(
+            {
+                val link = iframe.replace("streaming.php", "download")
+                val page = app.get(link, headers = mapOf("Referer" to iframe))
+
+                page.document.select(".dowload > a").apmap {
+                    if (it.hasAttr("download")) {
+                        val qual = if (it.text()
+                                .contains("HDP")
+                        ) "1080" else qualityRegex.find(it.text())?.destructured?.component1()
+                            .toString()
+                        callback(
+                            ExtractorLink(
+                                "Gogoanime",
+                                "Gogoanime",
+                                it.attr("href"),
+                                page.url,
+                                getQualityFromName(qual),
+                                it.attr("href").contains(".m3u8")
+                            )
+                        )
+                    } else {
+                        val url = it.attr("href")
+                        loadExtractor(url, null, subtitleCallback, callback)
+                    }
+                }
+            }, {
+                val streamingResponse = app.get(iframe, headers = mapOf("Referer" to iframe))
+                val streamingDocument = streamingResponse.document
+                argamap({
+                    streamingDocument.select(".list-server-items > .linkserver")
+                        .forEach { element ->
+                            val status = element.attr("data-status") ?: return@forEach
+                            if (status != "1") return@forEach
+                            val data = element.attr("data-video") ?: return@forEach
+                            loadExtractor(data, streamingResponse.url, subtitleCallback, callback)
+                        }
+                }, {
+                    val iv = "3134003223491201"
+                    val secretKey = "37911490979715163134003223491201"
+                    val secretDecryptKey = "54674138327930866480207815084989"
+                    extractVidstream(
+                        iframe,
+                        this.name,
+                        callback,
+                        iv,
+                        secretKey,
+                        secretDecryptKey,
+                        isUsingAdaptiveKeys = false,
+                        isUsingAdaptiveData = true
+                    )
+                })
+            }
+        )
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+        extractVideos(data, subtitleCallback, callback)
+        return true
+    }
+}

GogoanimeProvider/src/main/kotlin/com/lagradost/GogoanimeProviderPlugin.kt

@@ -0,0 +1,14 @@
+
+package com.lagradost
+
+import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
+import com.lagradost.cloudstream3.plugins.Plugin
+import android.content.Context
+
+@CloudstreamPlugin
+class GogoanimeProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(GogoanimeProvider())
+    }
+}