Ported over all movie providers (some disabled)

BflixProvider/build.gradle.kts

@@ -0,0 +1,22 @@
+// use an integer for version numbers
+version = 1
+
+
+cloudstream {
+    // 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
+
+    // Set to true to get an 18+ symbol next to the plugin
+    adult = false // will be false if unspecified
+}

BflixProvider/src/main/AndroidManifest.xml

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

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

@@ -0,0 +1,300 @@
+package com.lagradost
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.animeproviders.NineAnimeProvider.Companion.decodeVrf
+import com.lagradost.cloudstream3.animeproviders.NineAnimeProvider.Companion.encode
+import com.lagradost.cloudstream3.animeproviders.NineAnimeProvider.Companion.encodeVrf
+import com.lagradost.cloudstream3.utils.AppUtils.parseJson
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.loadExtractor
+import org.jsoup.Jsoup
+
+open class BflixProvider : MainAPI() {
+    override var mainUrl = "https://bflix.ru"
+    override var name = "Bflix"
+    override val hasMainPage = true
+    override val hasChromecastSupport = true
+    override val hasDownloadSupport = true
+    override val supportedTypes = setOf(
+        TvType.Movie,
+        TvType.TvSeries,
+    )
+
+    //override val uniqueId: Int by lazy { "BflixProvider".hashCode() }
+
+    override suspend fun getMainPage(page: Int, request : MainPageRequest): HomePageResponse {
+        val items = ArrayList<HomePageList>()
+        val soup = app.get("$mainUrl/home").document
+        val testa = listOf(
+            Pair("Movies", "div.tab-content[data-name=movies] div.filmlist div.item"),
+            Pair("Shows", "div.tab-content[data-name=shows] div.filmlist div.item"),
+            Pair("Trending", "div.tab-content[data-name=trending] div.filmlist div.item"),
+            Pair(
+                "Latest Movies",
+                "div.container section.bl:contains(Latest Movies) div.filmlist div.item"
+            ),
+            Pair(
+                "Latest TV-Series",
+                "div.container section.bl:contains(Latest TV-Series) div.filmlist div.item"
+            ),
+        )
+        for ((name, element) in testa) try {
+            val test = soup.select(element).map {
+                val title = it.selectFirst("h3 a")!!.text()
+                val link = fixUrl(it.selectFirst("a")!!.attr("href"))
+                val qualityInfo = it.selectFirst("div.quality")!!.text()
+                val quality = getQualityFromString(qualityInfo)
+                TvSeriesSearchResponse(
+                    title,
+                    link,
+                    this.name,
+                    if (link.contains("/movie/")) TvType.Movie else TvType.TvSeries,
+                    it.selectFirst("a.poster img")!!.attr("src"),
+                    null,
+                    null,
+                    quality = quality
+                )
+            }
+            items.add(HomePageList(name, test))
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+        if (items.size <= 0) throw ErrorLoadingException()
+        return HomePageResponse(items)
+    }
+
+    override suspend fun search(query: String): List<SearchResponse>? {
+        val encodedquery = encodeVrf(query, mainKey)
+        val url = "$mainUrl/search?keyword=$query&vrf=$encodedquery"
+        val html = app.get(url).text
+        val document = Jsoup.parse(html)
+
+        return document.select(".filmlist div.item").map {
+            val title = it.selectFirst("h3 a")!!.text()
+            val href = fixUrl(it.selectFirst("a")!!.attr("href"))
+            val image = it.selectFirst("a.poster img")!!.attr("src")
+            val isMovie = href.contains("/movie/")
+            val qualityInfo = it.selectFirst("div.quality")!!.text()
+            val quality = getQualityFromString(qualityInfo)
+
+            if (isMovie) {
+                MovieSearchResponse(
+                    title,
+                    href,
+                    this.name,
+                    TvType.Movie,
+                    image,
+                    null,
+                    quality = quality
+                )
+            } else {
+                TvSeriesSearchResponse(
+                    title,
+                    href,
+                    this.name,
+                    TvType.TvSeries,
+                    image,
+                    null,
+                    null,
+                    quality = quality
+                )
+            }
+        }
+    }
+
+    data class Response(
+        @JsonProperty("html") val html: String
+    )
+
+    companion object {
+        val mainKey = "OrAimkpzm6phmN3j"
+    }
+
+    override suspend fun load(url: String): LoadResponse? {
+        val soup = app.get(url).document
+        val movieid = soup.selectFirst("div#watch")!!.attr("data-id")
+        val movieidencoded = encodeVrf(movieid, mainKey)
+        val title = soup.selectFirst("div.info h1")!!.text()
+        val description = soup.selectFirst(".info .desc")?.text()?.trim()
+        val poster: String? = try {
+            soup.selectFirst("img.poster")!!.attr("src")
+        } catch (e: Exception) {
+            soup.selectFirst(".info .poster img")!!.attr("src")
+        }
+
+        val tags = soup.select("div.info .meta div:contains(Genre) a").map { it.text() }
+        val vrfUrl = "$mainUrl/ajax/film/servers?id=$movieid&vrf=$movieidencoded"
+        println("VRF___ $vrfUrl")
+        val episodes = Jsoup.parse(
+            app.get(
+                vrfUrl
+            ).parsed<Response>().html
+        ).select("div.episode").map {
+            val a = it.selectFirst("a")
+            val href = fixUrl(a!!.attr("href"))
+            val extraData = a.attr("data-kname").let { str ->
+                str.split("-").mapNotNull { subStr -> subStr.toIntOrNull() }
+            }
+            val isValid = extraData.size == 2
+            val episode = if (isValid) extraData.getOrNull(1) else null
+            val season = if (isValid) extraData.getOrNull(0) else null
+
+            val eptitle = it.selectFirst(".episode a span.name")!!.text()
+            val secondtitle = it.selectFirst(".episode a span")!!.text()
+                .replace(Regex("(Episode (\\d+):|Episode (\\d+)-|Episode (\\d+))"), "") ?: ""
+            Episode(
+                href,
+                secondtitle + eptitle,
+                season,
+                episode,
+            )
+        }
+        val tvType =
+            if (url.contains("/movie/") && episodes.size == 1) TvType.Movie else TvType.TvSeries
+        val recommendations =
+            soup.select("div.bl-2 section.bl div.content div.filmlist div.item")
+                .mapNotNull { element ->
+                    val recTitle = element.select("h3 a").text() ?: return@mapNotNull null
+                    val image = element.select("a.poster img")?.attr("src")
+                    val recUrl = fixUrl(element.select("a").attr("href"))
+                    MovieSearchResponse(
+                        recTitle,
+                        recUrl,
+                        this.name,
+                        if (recUrl.contains("/movie/")) TvType.Movie else TvType.TvSeries,
+                        image,
+                        year = null
+                    )
+                }
+        val rating = soup.selectFirst(".info span.imdb")?.text()?.toRatingInt()
+        val durationdoc = soup.selectFirst("div.info div.meta").toString()
+        val durationregex = Regex("((\\d+) min)")
+        val yearegex = Regex("<span>(\\d+)</span>")
+        val duration = if (durationdoc.contains("na min")) null
+        else durationregex.find(durationdoc)?.destructured?.component1()?.replace(" min", "")
+            ?.toIntOrNull()
+        val year = if (mainUrl == "https://bflix.ru") {
+            yearegex.find(durationdoc)?.destructured?.component1()
+                ?.replace(Regex("<span>|</span>"), "")
+        } else null
+        return when (tvType) {
+            TvType.TvSeries -> {
+                TvSeriesLoadResponse(
+                    title,
+                    url,
+                    this.name,
+                    tvType,
+                    episodes,
+                    poster,
+                    year?.toIntOrNull(),
+                    description,
+                    null,
+                    rating,
+                    tags,
+                    recommendations = recommendations,
+                    duration = duration,
+                )
+            }
+            TvType.Movie -> {
+                MovieLoadResponse(
+                    title,
+                    url,
+                    this.name,
+                    tvType,
+                    url,
+                    poster,
+                    year?.toIntOrNull(),
+                    description,
+                    rating,
+                    tags,
+                    recommendations = recommendations,
+                    duration = duration
+                )
+            }
+            else -> null
+        }
+    }
+
+
+    data class Subtitles(
+        @JsonProperty("file") val file: String,
+        @JsonProperty("label") val label: String,
+        @JsonProperty("kind") val kind: String
+    )
+
+    data class Links(
+        @JsonProperty("url") val url: String
+    )
+
+    data class Servers(
+        @JsonProperty("28") val mcloud: String?,
+        @JsonProperty("35") val mp4upload: String?,
+        @JsonProperty("40") val streamtape: String?,
+        @JsonProperty("41") val vidstream: String?,
+        @JsonProperty("43") val videovard: String?
+    )
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+        val soup = app.get(data).document
+
+        val movieid = encode(soup.selectFirst("div#watch")?.attr("data-id") ?: return false)
+        val movieidencoded = encodeVrf(movieid, mainKey)
+        Jsoup.parse(
+            parseJson<Response>(
+                app.get(
+                    "$mainUrl/ajax/film/servers?id=$movieid&vrf=$movieidencoded"
+                ).text
+            ).html
+        )
+            .select("html body #episodes").map {
+                val cleandata = data.replace(mainUrl, "")
+                val a = it.select("a").map {
+                    it.attr("data-kname")
+                }
+                val tvType =
+                    if (data.contains("movie/") && a.size == 1) TvType.Movie else TvType.TvSeries
+                val servers = if (tvType == TvType.Movie) it.select(".episode a").attr("data-ep")
+                else
+                    it.select(".episode a[href=$cleandata]").attr("data-ep")
+                        ?: it.select(".episode a[href=${cleandata.replace("/1-full", "")}]")
+                            .attr("data-ep")
+                val jsonservers = parseJson<Servers?>(servers) ?: return@map
+                listOfNotNull(
+                    jsonservers.vidstream,
+                    jsonservers.mcloud,
+                    jsonservers.mp4upload,
+                    jsonservers.streamtape,
+                    jsonservers.videovard,
+                ).mapNotNull {
+                    val epserver = app.get("$mainUrl/ajax/episode/info?id=$it").text
+                    (if (epserver.contains("url")) {
+                        parseJson<Links>(epserver)
+                    } else null)?.url?.let {
+                        decodeVrf(it, mainKey)
+                    }
+                }.apmap { url ->
+                    loadExtractor(
+                        url, data, subtitleCallback, callback
+                    )
+                }
+                //Apparently any server works, I haven't found any diference
+                val sublink =
+                    app.get("$mainUrl/ajax/episode/subtitles/${jsonservers.mcloud}").text
+                val jsonsub = parseJson<List<Subtitles>>(sublink)
+                jsonsub.forEach { subtitle ->
+                    subtitleCallback(
+                        SubtitleFile(subtitle.label, subtitle.file)
+                    )
+                }
+            }
+
+        return true
+    }
+}

BflixProvider/src/main/kotlin/com/lagradost/BflixProviderPlugin.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 BflixProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(BflixProvider())
+    }
+}