recloudstream
/
cloudstream-extensions-multilingual
mirror of https://github.com/recloudstream/cloudstream-extensions-multilingual.git
2
1
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'master' of github.com:recloudstream/cloudstream-extensions-multilingual

This commit is contained in:
sarlay 2022-10-01 20:32:36 +02:00
parent 7aeb20692e b368fcce02
commit d3acd05c2c
61 changed files with 2592 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
Anizm/build.gradle.kts Normal file
View File

@ -0,0 +1,27 @@
// use an integer for version numbers
version = 1
cloudstream {
language = "tr"
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
authors = listOf("Hexated")
/**
* 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=anizm.net&sz=%size%"
}

2
Anizm/src/main/AndroidManifest.xml Normal file
View File

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

195
Anizm/src/main/kotlin/com/lagradost/Anizm.kt Normal file
View File

@ -0,0 +1,195 @@
package com.lagradost
import android.util.Log
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
import com.lagradost.cloudstream3.mvvm.safeApiCall
import com.lagradost.cloudstream3.utils.*
import org.jsoup.Jsoup
import org.jsoup.nodes.Element
class Anizm : MainAPI() {
override var mainUrl = "https://anizm.net"
override var name = "Anizm"
override val hasMainPage = true
override var lang = "tr"
override val hasDownloadSupport = true
override val supportedTypes = setOf(
TvType.Anime,
TvType.AnimeMovie,
TvType.OVA
)
companion object {
private const val mainServer = "https://anizmplayer.com"
}
override val mainPage = mainPageOf(
"$mainUrl/anime-izle?sayfa=" to "Son Eklenen Animeler",
)
override suspend fun getMainPage(
page: Int,
request: MainPageRequest
): HomePageResponse {
val document = app.get(request.data + page).document
val home = document.select("div.restrictedWidth div#episodesMiddle").mapNotNull {
it.toSearchResult()
}
return newHomePageResponse(request.name, home)
}
private fun getProperAnimeLink(uri: String): String {
return if (uri.contains("-bolum")) {
"$mainUrl/${uri.substringAfter("$mainUrl/").replace(Regex("-[0-9]+-bolum.*"), "")}"
} else {
uri
}
}
private fun Element.toSearchResult(): AnimeSearchResponse? {
val href = getProperAnimeLink(this.selectFirst("a")!!.attr("href"))
val title = this.selectFirst("div.title, h5.animeTitle a")?.text() ?: return null
val posterUrl = fixUrlNull(this.selectFirst("img")?.attr("src"))
val episode = this.selectFirst("div.truncateText")?.text()?.let {
Regex("([0-9]+).\\s?Bölüm").find(it)?.groupValues?.getOrNull(1)?.toIntOrNull()
}
return newAnimeSearchResponse(title, href, TvType.Anime) {
this.posterUrl = posterUrl
addSub(episode)
}
}
override suspend fun search(query: String): List<SearchResponse> {
val document = app.get(
"$mainUrl/fullViewSearch?search=$query&skip=0",
headers = mapOf("X-Requested-With" to "XMLHttpRequest")
).document
return document.select("div.searchResultItem").mapNotNull {
it.toSearchResult()
}
}
override suspend fun load(url: String): LoadResponse {
val document = app.get(url).document
val title = document.selectFirst("h2.anizm_pageTitle a")!!.text().trim()
val type =
if (document.select("div.ui.grid div.four.wide").size == 1) TvType.Movie else TvType.Anime
val trailer = document.select("div.yt-hd-thumbnail-inner-container iframe").attr("src")
val episodes = document.select("div.ui.grid div.four.wide").map {
val name = it.select("div.episodeBlock").text()
val link = fixUrl(it.selectFirst("a")?.attr("href").toString())
Episode(link, name)
}
return newAnimeLoadResponse(title, url, type) {
posterUrl = fixUrlNull(document.selectFirst("div.infoPosterImg > img")?.attr("src"))
this.year = document.select("div.infoSta ul li:first-child").text().trim().toIntOrNull()
addEpisodes(DubStatus.Subbed, episodes)
plot = document.select("div.infoDesc").text().trim()
this.tags = document.select("span.dataValue span.ui.label").map { it.text() }
addTrailer(trailer)
}
}
private suspend fun invokeLokalSource(
url: String,
translator: String,
sourceCallback: (ExtractorLink) -> Unit
) {
app.get(url, referer = "$mainUrl/").document.select("script").find { script ->
script.data().contains("eval(function(p,a,c,k,e,d)")
}?.let {
val key = getAndUnpack(it.data()).substringAfter("FirePlayer(\"").substringBefore("\",")
val referer = "$mainServer/video/$key"
val link = "$mainServer/player/index.php?data=$key&do=getVideo"
Log.i("hexated", link)
app.post(
link,
data = mapOf("hash" to key, "r" to "$mainUrl/"),
referer = referer,
headers = mapOf(
"Accept" to "*/*",
"Origin" to mainServer,
"Content-Type" to "application/x-www-form-urlencoded; charset=UTF-8",
"X-Requested-With" to "XMLHttpRequest"
)
).parsedSafe<Source>()?.videoSource?.let { m3uLink ->
M3u8Helper.generateM3u8(
"${this.name} ($translator)",
m3uLink,
referer
).forEach(sourceCallback)
}
}
}
override suspend fun loadLinks(
data: String,
isCasting: Boolean,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit
): Boolean {
val document = app.get(data).document
document.select("div.episodeTranslators div#fansec").map {
Pair(it.select("a").attr("translator"), it.select("div.title").text())
}.apmap { (url, translator) ->
safeApiCall {
app.get(
url,
referer = data,
headers = mapOf(
"Accept" to "application/json, text/javascript, */*; q=0.01",
"X-Requested-With" to "XMLHttpRequest"
)
).parsedSafe<Translators>()?.data?.let {
Jsoup.parse(it).select("a").apmap { video ->
app.get(
video.attr("video"),
referer = data,
headers = mapOf(
"Accept" to "application/json, text/javascript, */*; q=0.01",
"X-Requested-With" to "XMLHttpRequest"
)
).parsedSafe<Videos>()?.player?.let { iframe ->
Jsoup.parse(iframe).select("iframe").attr("src").let { link ->
when {
link.startsWith(mainServer) -> {
invokeLokalSource(link, translator, callback)
}
else -> {
loadExtractor(
fixUrl(link),
"$mainUrl/",
subtitleCallback,
callback
)
}
}
}
}
}
}
}
}
return true
}
data class Source(
@JsonProperty("videoSource") val videoSource: String?,
)
data class Videos(
@JsonProperty("player") val player: String?,
)
data class Translators(
@JsonProperty("data") val data: String?,
)
}

14
Anizm/src/main/kotlin/com/lagradost/AnizmPlugin.kt Normal file
View File

@ -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 AnizmPlugin: Plugin() {
override fun load(context: Context) {
// All providers should be added in this manner. Please don't edit the providers list directly.
registerMainAPI(Anizm())
}
}

6
DramaidProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 2
cloudstream {
@ -7,7 +7,7 @@ cloudstream {
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
// authors = listOf("Cloudburst")
authors = listOf("Hexated")
/**
* Status int as the following:
@ -22,5 +22,5 @@ cloudstream {
"Movie",
)
iconUrl = "https://www.google.com/s2/favicons?domain=185.224.83.103&sz=%size%"
iconUrl = "https://www.google.com/s2/favicons?domain=dramaid.asia&sz=%size%"
}

2
DramaidProvider/src/main/kotlin/com/lagradost/DramaidProvider.kt
View File

@ -10,7 +10,7 @@ import org.jsoup.Jsoup
import org.jsoup.nodes.Element
class DramaidProvider : MainAPI() {
override var mainUrl = "https://185.224.83.103"
override var mainUrl = "https://dramaid.asia"
override var name = "DramaId"
override val hasQuickSearch = false
override val hasMainPage = true

4
FilmanProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 2
cloudstream {
@ -23,4 +23,4 @@ cloudstream {
)
iconUrl = "https://www.google.com/s2/favicons?domain=filman.cc&sz=%size%"
}
}

7
FilmanProvider/src/main/kotlin/com/lagradost/FilmanProvider.kt
View File

@ -137,8 +137,13 @@ class FilmanProvider : MainAPI() {
document?.select(".link-to-video")?.apmap { item ->
val decoded = base64Decode(item.select("a").attr("data-iframe"))
val videoType = item.parent()?.select("td:nth-child(2)")?.text()
val link = tryParseJson<LinkElement>(decoded)?.src ?: return@apmap
loadExtractor(link, subtitleCallback, callback)
loadExtractor(link, subtitleCallback) { extractedLink ->
run {
callback(ExtractorLink(extractedLink.source, extractedLink.name + " " + videoType, extractedLink.url, extractedLink.referer, extractedLink.quality, extractedLink.isM3u8, extractedLink.headers, extractedLink.extractorData))
}
}
}
return true
}

7
FrenchStreamProvider/build.gradle.kts
View File

@ -6,8 +6,8 @@ cloudstream {
language = "fr"
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
// authors = listOf("Cloudburst")
description = "FRENCH STREAM en plus d'être un site efficace et plaisant dispose d'un contenu visuel diversifié"
authors = listOf("Sarlay", "Eddy976")
/**
* Status int as the following:
@ -18,10 +18,9 @@ cloudstream {
* */
status = 1 // will be 3 if unspecified
tvTypes = listOf(
"AnimeMovie",
"TvSeries",
"Movie",
)
iconUrl = "https://www.google.com/s2/favicons?domain=french-stream.re&sz=%size%"
iconUrl = "https://www.google.com/s2/favicons?domain=french-stream.ac&sz=%size%"
}

220
FrenchStreamProvider/src/main/kotlin/com/lagradost/FrenchStreamProvider.kt
View File

@ -1,54 +1,31 @@
package com.lagradost
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.LoadResponse.Companion.addRating
import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
import com.lagradost.cloudstream3.utils.ExtractorLink
import com.lagradost.cloudstream3.utils.extractorApis
import org.jsoup.nodes.Element
class FrenchStreamProvider : MainAPI() {
override var mainUrl = "https://french-stream.re"
override var name = "French Stream"
override var mainUrl = "https://french-stream.cx" //re ou ac ou city
override var name = "FrenchStream"
override val hasQuickSearch = false
override val hasMainPage = true
override var lang = "fr"
override val supportedTypes = setOf(TvType.AnimeMovie, TvType.TvSeries, TvType.Movie)
override val supportedTypes = setOf(TvType.Movie, TvType.TvSeries)
override suspend fun search(query: String): List<SearchResponse> {
val link = "$mainUrl/?do=search&subaction=search&story=$query"
val soup = app.post(link).document
val link = "$mainUrl/?do=search&subaction=search&story=$query" // search'
val document =
app.post(link).document // app.get() permet de télécharger la page html avec une requete HTTP (get)
val results = document.select("div#dle-content > > div.short")
return soup.select("div.short-in.nl").map { li ->
val href = fixUrl(li.selectFirst("a.short-poster")!!.attr("href"))
val poster = li.selectFirst("img")?.attr("src")
val title = li.selectFirst("> a.short-poster")!!.text().toString().replace(". ", "")
val year = li.selectFirst(".date")?.text()?.split("-")?.get(0)?.toIntOrNull()
if (title.contains(
"saison",
ignoreCase = true
)
) { // if saison in title ==> it's a TV serie
TvSeriesSearchResponse(
title,
href,
this.name,
TvType.TvSeries,
poster,
year,
(title.split("Eps ", " ")[1]).split(" ")[0].toIntOrNull()
)
} else { // it's a movie
MovieSearchResponse(
title,
href,
this.name,
TvType.Movie,
poster,
year,
)
val allresultshome =
results.apmap { article -> // avec mapnotnull si un élément est null, il sera automatiquement enlevé de la liste
article.toSearchResponse()
}
}
return allresultshome
}
override suspend fun load(url: String): LoadResponse {
@ -58,45 +35,45 @@ class FrenchStreamProvider : MainAPI() {
val isMovie = !title.contains("saison", ignoreCase = true)
val description =
soup.selectFirst("div.fdesc")!!.text().toString()
.split("streaming", ignoreCase = true)[1].replace(" : ", "")
var poster = fixUrlNull(soup.selectFirst("div.fposter > img")?.attr("src"))
.split("streaming", ignoreCase = true)[1].replace(":", "")
var poster = soup.selectFirst("div.fposter > img")?.attr("src")
val listEpisode = soup.select("div.elink")
val tags = soup.select("ul.flist-col > li").getOrNull(1)
//val rating = soup.select("span[id^=vote-num-id]")?.getOrNull(1)?.text()?.toInt()
if (isMovie) {
val tags = soup.select("ul.flist-col > li").getOrNull(1)
val yearRegex = Regex("""ate de sortie\: (\d*)""")
val year = yearRegex.find(soup.text())?.groupValues?.get(1)
val tagsList = tags?.select("a")
?.mapNotNull { // all the tags like action, thriller ...; unused variable
it?.text()
}
return newMovieLoadResponse(title, url, TvType.Movie, url) {
this.posterUrl = poster
addRating(soup.select("div.fr-count > div").text())
this.year = soup.select("ul.flist-col > li").getOrNull(2)?.text()?.toIntOrNull()
this.year = year?.toIntOrNull()
this.tags = tagsList
this.plot = description
addTrailer(soup.selectFirst("div.fleft > span > a")?.attr("href"))
//this.rating = rating
addTrailer(soup.selectFirst("button#myBtn > a")?.attr("href"))
}
} else // a tv serie
{
//println(listEpisode)
//println("listeEpisode:")
val episodeList = if ("<a" !in (listEpisode[0]).toString()) { // check if VF is empty
listEpisode[1] // no vf, return vostfr
} else {
listEpisode[0] // no vostfr, return vf
}
//println(url)
val episodes = episodeList.select("a").map { a ->
val epNum = a.text().split("Episode")[1].trim().toIntOrNull()
val epTitle = if (a.text().contains("Episode")) {
val type = if ("honey" in a.attr("id")) {
"VF"
} else {
"VOSTFR"
"Vostfr"
}
"Episode " + epNum?.toString() + " en " + type
"Episode " + type
} else {
a.text()
}
@ -112,17 +89,24 @@ class FrenchStreamProvider : MainAPI() {
null // episode date
)
}
return TvSeriesLoadResponse(
// val tagsList = tags?.text()?.replace("Genre :","")
val yearRegex = Regex("""Titre .* \/ (\d*)""")
val year = yearRegex.find(soup.text())?.groupValues?.get(1)
return newTvSeriesLoadResponse(
title,
url,
this.name,
TvType.TvSeries,
episodes,
poster,
null,
description,
ShowStatus.Ongoing,
)
) {
this.posterUrl = poster
this.plot = description
this.year = year?.toInt()
//this.rating = rating
//this.showStatus = ShowStatus.Ongoing
//this.tags = tagsList
addTrailer(soup.selectFirst("button#myBtn > a")?.attr("href"))
}
}
}
@ -219,10 +203,27 @@ class FrenchStreamProvider : MainAPI() {
servers.apmap {
for (extractor in extractorApis) {
if (it.first.contains(extractor.name, ignoreCase = true)) {
// val name = it.first
// print("true for $name")
extractor.getSafeUrl(it.second, it.second, subtitleCallback, callback)
var playerName = it.first
if (playerName.contains("Stream.B")) {
playerName = it.first.replace("Stream.B", "StreamSB")
}
if (it.second.contains("streamlare")) {
playerName = "Streamlare"
}
if (playerName.contains(extractor.name, ignoreCase = true)) {
val header = app.get(
"https" + it.second.split("https").get(1),
allowRedirects = false
).headers
val urlplayer = it.second
var playerUrl = when (!urlplayer.isNullOrEmpty()) {
urlplayer.contains("opsktp.com") -> header.get("location")
.toString() // case where there is redirection to opsktp
else -> it.second
}
extractor.getSafeUrl(playerUrl, playerUrl, subtitleCallback, callback)
break
}
}
@ -232,42 +233,71 @@ class FrenchStreamProvider : MainAPI() {
}
override suspend fun getMainPage(page: Int, request : MainPageRequest): HomePageResponse? {
val document = app.get(mainUrl).document
val docs = document.select("div.sect")
val returnList = docs.mapNotNull {
val epList = it.selectFirst("> div.sect-c.floats.clearfix") ?: return@mapNotNull null
val title =
it.selectFirst("> div.sect-t.fx-row.icon-r > div.st-left > a.st-capt")!!.text()
val list = epList.select("> div.short")
val isMovieType = title.contains("Films") // if truen type is Movie
val currentList = list.map { head ->
val hrefItem = head.selectFirst("> div.short-in.nl > a")
val href = fixUrl(hrefItem!!.attr("href"))
val img = hrefItem.selectFirst("> img")
val posterUrl = img!!.attr("src")
val name = img.attr("> div.short-title").toString()
return@map if (isMovieType) MovieSearchResponse(
name,
href,
this.name,
TvType.Movie,
posterUrl,
null
) else TvSeriesSearchResponse(
name,
href,
this.name,
TvType.TvSeries,
posterUrl,
null, null
)
}
if (currentList.isNotEmpty()) {
HomePageList(title, currentList)
} else null
private fun Element.toSearchResponse(): SearchResponse {
val posterUrl = fixUrl(select("a.short-poster > img").attr("src"))
val qualityExtracted = select("span.film-ripz > a").text()
val type = select("span.mli-eps").text()
val title = select("div.short-title").text()
val link = select("a.short-poster").attr("href").replace("wvw.", "") //wvw is an issue
var quality = when (!qualityExtracted.isNullOrBlank()) {
qualityExtracted.contains("HDLight") -> getQualityFromString("HD")
qualityExtracted.contains("Bdrip") -> getQualityFromString("BlueRay")
qualityExtracted.contains("DVD") -> getQualityFromString("DVD")
qualityExtracted.contains("CAM") -> getQualityFromString("Cam")
else -> null
}
if (type.contains("Eps", false)) {
return MovieSearchResponse(
name = title,
url = link,
apiName = title,
type = TvType.Movie,
posterUrl = posterUrl,
quality = quality
)
} else // an Serie
{
return TvSeriesSearchResponse(
name = title,
url = link,
apiName = title,
type = TvType.TvSeries,
posterUrl = posterUrl,
quality = quality,
//
)
}
if (returnList.isEmpty()) return null
return HomePageResponse(returnList)
}
override val mainPage = mainPageOf(
Pair("$mainUrl/xfsearch/version-film/page/", "Derniers films"),
Pair("$mainUrl/xfsearch/version-serie/page/", "Derniers séries"),
Pair("$mainUrl/film/arts-martiaux/page/", "Films za m'ringué (Arts martiaux)"),
Pair("$mainUrl/film/action/page/", "Films Actions"),
Pair("$mainUrl/film/romance/page/", "Films za malomo (Romance)"),
Pair("$mainUrl/serie/aventure-serie/page/", "Série aventure"),
Pair("$mainUrl/film/documentaire/page/", "Documentaire")
)
override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
val url = request.data + page
val document = app.get(url).document
val movies = document.select("div#dle-content > div.short")
val home =
movies.map { article -> // avec mapnotnull si un élément est null, il sera automatiquement enlevé de la liste
article.toSearchResponse()
}
return newHomePageResponse(request.name, home)
}
}

1
FrenchStreamProvider/src/main/kotlin/com/lagradost/FrenchStreamProviderPlugin.kt
View File

@ -10,5 +10,6 @@ class FrenchStreamProviderPlugin: Plugin() {
override fun load(context: Context) {
// All providers should be added in this manner. Please don't edit the providers list directly.
registerMainAPI(FrenchStreamProvider())
registerExtractorAPI(VidoExtractor())
}
}

47
FrenchStreamProvider/src/main/kotlin/com/lagradost/VidoExtractor.kt Normal file
View File

@ -0,0 +1,47 @@
package com.lagradost
import com.lagradost.cloudstream3.app
import com.lagradost.cloudstream3.utils.ExtractorApi
import com.lagradost.cloudstream3.utils.ExtractorLink
import com.lagradost.cloudstream3.utils.Qualities
import com.lagradost.cloudstream3.utils.getAndUnpack
class VidoExtractor : ExtractorApi() {
override var name = "Vido"
override var mainUrl = "https://vido.lol"
private val srcRegex = Regex("""layer\(\{sources\:\["(.*)"\]""")
override val requiresReferer = true
override suspend fun getUrl(url: String, referer: String?): List<ExtractorLink>? {
val methode = if (url.contains("embed")) {
app.get(url) // french stream
} else {
val code = url.substringAfterLast("/")
val data = mapOf(
"op" to "embed",
"file_code" to code,
"&auto" to "1"
)
app.post("https://vido.lol/dl", referer = url, data = data) // wiflix
}
with(methode) {
getAndUnpack(this.text).let { unpackedText ->
//val quality = unpackedText.lowercase().substringAfter(" height=").substringBefore(" ").toIntOrNull()
srcRegex.find(unpackedText)?.groupValues?.get(1)?.let { link ->
return listOf(
ExtractorLink(
name,
name,
link,
url,
Qualities.Unknown.value,
true,
)
)
}
}
}
return null
}
}

4
HDMovie5/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 2
version = 3
cloudstream {
@ -22,5 +22,5 @@ cloudstream {
"Movie",
)
iconUrl = "https://www.google.com/s2/favicons?domain=hdmovie2.plus&sz=%size%"
iconUrl = "https://www.google.com/s2/favicons?domain=hdmovie2.run&sz=%size%"
}

2
HDMovie5/src/main/kotlin/com/lagradost/HDMovie5.kt
View File

@ -9,7 +9,7 @@ import org.jsoup.Jsoup
import org.jsoup.nodes.Element
class HDMovie5 : MainAPI() {
override var mainUrl = "https://hdmovie2.plus"
override var mainUrl = "https://hdmovie2.rip"
override var name = "HDMovie"
override var lang = "hi"

26
Hdfilmcehennemi/build.gradle.kts Normal file
View File

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

2
Hdfilmcehennemi/src/main/AndroidManifest.xml Normal file
View File

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

205
Hdfilmcehennemi/src/main/kotlin/com/lagradost/Hdfilmcehennemi.kt Normal file
View File

@ -0,0 +1,205 @@
package com.lagradost
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.LoadResponse.Companion.addActors
import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
import com.lagradost.cloudstream3.mvvm.safeApiCall
import com.lagradost.cloudstream3.utils.*
import org.jsoup.nodes.Element
class Hdfilmcehennemi : MainAPI() {
override var mainUrl = "https://www.hdfilmcehennemi.live"
override var name = "hdfilmcehennemi"
override val hasMainPage = true
override var lang = "tr"
override val hasQuickSearch = true
override val hasDownloadSupport = true
override val supportedTypes = setOf(
TvType.Movie,
TvType.TvSeries,
)
override val mainPage = mainPageOf(
"$mainUrl/category/tavsiye-filmler-izle1/page/" to "Tavsiye Filmler Kategorisi",
"$mainUrl/yabancidizi/page/" to "Son Eklenen Yabancı Diziler",
"$mainUrl/imdb-7-puan-uzeri-filmler/page/" to "Imdb 7+ Filmler",
"$mainUrl/en-cok-yorumlananlar/page/" to "En Çok Yorumlananlar",
"$mainUrl/en-cok-begenilen-filmleri-izle/page/" to "En Çok Beğenilenler",
)
override suspend fun getMainPage(
page: Int,
request: MainPageRequest
): HomePageResponse {
val document = app.get(request.data + page).document
val home = document.select("div.card-body div.row div.col-6.col-sm-3.poster-container")
.mapNotNull {
it.toSearchResult()
}
return newHomePageResponse(request.name, home)
}
private fun Element.toSearchResult(): SearchResponse? {
val title = this.selectFirst("a")?.text() ?: return null
val href = fixUrlNull(this.selectFirst("a")?.attr("href")) ?: return null
val posterUrl = fixUrlNull(this.selectFirst("img")?.attr("data-src"))
return newMovieSearchResponse(title, href, TvType.Movie) {
this.posterUrl = posterUrl
}
}
private fun Media.toSearchResponse(): SearchResponse? {
return newMovieSearchResponse(
title ?: return null,
"$mainUrl/$slugPrefix$slug",
TvType.TvSeries,
) {
this.posterUrl = "$mainUrl/uploads/poster/$poster"
}
}
override suspend fun quickSearch(query: String): List<SearchResponse> = search(query)
override suspend fun search(query: String): List<SearchResponse> {
return app.post(
"$mainUrl/search/",
data = mapOf("query" to query),
referer = "$mainUrl/",
headers = mapOf(
"Accept" to "application/json, text/javascript, */*; q=0.01",
"X-Requested-With" to "XMLHttpRequest"
)
).parsedSafe<Result>()?.result?.mapNotNull { media ->
media.toSearchResponse()
} ?: throw ErrorLoadingException("Invalid Json reponse")
}
override suspend fun load(url: String): LoadResponse? {
val document = app.get(url).document
val title = document.selectFirst("div.card-header > h1, div.card-header > h2")?.text()
?: return null
val poster = fixUrlNull(document.selectFirst("img.img-fluid")?.attr("src"))
val tags = document.select("div.mb-0.lh-lg div:nth-child(5) a").map { it.text() }
val year =
document.selectFirst("div.mb-0.lh-lg div:nth-child(4) a")?.text()?.trim()?.toIntOrNull()
val tvType = if (document.select("nav#seasonsTabs").isNullOrEmpty()
) TvType.Movie else TvType.TvSeries
val description = document.selectFirst("article.text-white > p")?.text()?.trim()
val rating = document.selectFirst("div.rating-votes div.rate span")?.text()?.toRatingInt()
val actors = document.select("div.mb-0.lh-lg div:last-child a.chip").map {
Actor(it.text(), it.select("img").attr("src"))
}
val recommendations =
document.select("div.swiper-wrapper div.poster.poster-pop").mapNotNull {
val recName = it.selectFirst("h2.title")?.text() ?: return@mapNotNull null
val recHref =
fixUrlNull(it.selectFirst("a")?.attr("href")) ?: return@mapNotNull null
val recPosterUrl = fixUrlNull(it.selectFirst("img")?.attr("data-src"))
newTvSeriesSearchResponse(recName, recHref, TvType.TvSeries) {
this.posterUrl = recPosterUrl
}
}
return if (tvType == TvType.TvSeries) {
val trailer =
document.selectFirst("button.btn.btn-fragman.btn-danger")?.attr("data-trailer")
?.let {
"https://www.youtube.com/embed/$it"
}
val episodes = document.select("div#seasonsTabs-tabContent div.card-list-item").map {
val href = it.select("a").attr("href")
val name = it.select("h3").text().trim()
val episode = it.select("h3").text().let { num ->
Regex("Sezon\\s?([0-9]+).").find(num)?.groupValues?.getOrNull(1)?.toIntOrNull()
}
val season = it.parents()[1].attr("id").substringAfter("-").toIntOrNull()
Episode(
href,
name,
season,
episode,
)
}
newTvSeriesLoadResponse(title, url, TvType.TvSeries, episodes) {
this.posterUrl = poster
this.year = year
this.plot = description
this.tags = tags
this.rating = rating
addActors(actors)
this.recommendations = recommendations
addTrailer(trailer)
}
} else {
val trailer =
document.selectFirst("nav.nav.card-nav.nav-slider a[data-bs-toggle=\"modal\"]")
?.attr("data-trailer")?.let {
"https://www.youtube.com/embed/$it"
}
newMovieLoadResponse(title, url, TvType.Movie, url) {
this.posterUrl = poster
this.year = year
this.plot = description
this.tags = tags
this.rating = rating
addActors(actors)
this.recommendations = recommendations
addTrailer(trailer)
}
}
}
private suspend fun invokeLocalSource(
source: String,
url: String,
sourceCallback: (ExtractorLink) -> Unit
) {
val m3uLink =
app.get(url, referer = "$mainUrl/").document.select("script")
.find {
it.data().contains("var sources = [];") || it.data()
.contains("playerInstance =")
}?.data()
?.substringAfter("[{file:\"")?.substringBefore("\"}]") ?: return
M3u8Helper.generateM3u8(
source,
m3uLink,
if (url.startsWith(mainUrl)) "$mainUrl/" else "https://vidmoly.to/"
).forEach(sourceCallback)
}
override suspend fun loadLinks(
data: String,
isCasting: Boolean,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit
): Boolean {
app.get(data).document.select("nav.nav.card-nav.nav-slider a.nav-link").map {
Pair(it.attr("href"), it.text())
}.apmap { (url, source) ->
safeApiCall {
app.get(url).document.select("div.card-video > iframe").attr("data-src")
.let { link ->
invokeLocalSource(source, link, callback)
}
}
}
return true
}
data class Result(
@JsonProperty("result") val result: ArrayList<Media>? = arrayListOf(),
)
data class Media(
@JsonProperty("title") val title: String? = null,
@JsonProperty("poster") val poster: String? = null,
@JsonProperty("slug") val slug: String? = null,
@JsonProperty("slug_prefix") val slugPrefix: String? = null,
)
}

14
Hdfilmcehennemi/src/main/kotlin/com/lagradost/HdfilmcehennemiPlugin.kt Normal file
View File

@ -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 HdfilmcehennemiPlugin: Plugin() {
override fun load(context: Context) {
// All providers should be added in this manner. Please don't edit the providers list directly.
registerMainAPI(Hdfilmcehennemi())
}
}

4
KuramanimeProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 2
cloudstream {
@ -7,7 +7,7 @@ cloudstream {
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
// authors = listOf("Cloudburst")
authors = listOf("Hexated")
/**
* Status int as the following:

26
KuramanimeProvider/src/main/kotlin/com/lagradost/KuramanimeProvider.kt
View File

@ -21,12 +21,6 @@ class KuramanimeProvider : 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) {
"Selesai Tayang" -> ShowStatus.Completed
@ -80,20 +74,11 @@ class KuramanimeProvider : MainAPI() {
}
override suspend fun search(query: String): List<SearchResponse> {
val link = "$mainUrl/anime?search=$query&order_by=oldest"
val link = "$mainUrl/anime?search=$query&order_by=latest"
val document = app.get(link).document
return document.select(".product__item").mapNotNull {
val title = it.selectFirst("div.product__item__text > h5")!!.text().trim()
val poster = it.selectFirst("a > div")!!.attr("data-setbg")
val tvType =
getType(it.selectFirst(".product__item__text > ul > li")!!.text().toString())
val href = fixUrl(it.selectFirst("a")!!.attr("href"))
newAnimeSearchResponse(title, href, tvType) {
this.posterUrl = poster
addDubStatus(dubExist = false, subExist = true)
}
return document.select("div#animeList div.col-lg-4.col-md-6.col-sm-6").mapNotNull {
it.toSearchResult()
}
}
@ -164,7 +149,10 @@ class KuramanimeProvider : MainAPI() {
name,
url,
referer = "$mainUrl/",
quality = quality
quality = quality,
headers = mapOf(
"Range" to "bytes=0-"
)
)
)
}

4
KuronimeProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 2
cloudstream {
@ -7,7 +7,7 @@ cloudstream {
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
// authors = listOf("Cloudburst")
authors = listOf("Hexated")
/**
* Status int as the following:

2
KuronimeProvider/src/main/kotlin/com/lagradost/KuronimeProvider.kt
View File

@ -111,7 +111,7 @@ class KuronimeProvider : MainAPI() {
val type = getType(
document.selectFirst(".infodetail > ul > li:nth-child(7)")?.ownText()?.trim().toString()
)
val trailer = document.selectFirst("div.tply iframe")?.attr("data-lazy-src")
val trailer = document.selectFirst("div.tply iframe")?.attr("data-src")
val year = Regex("\\d, ([0-9]*)").find(
document.select(".infodetail > ul > li:nth-child(5)").text()
)?.groupValues?.get(1)?.toIntOrNull()

8
LayarKacaProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 2
cloudstream {
@ -7,7 +7,7 @@ cloudstream {
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
// authors = listOf("Cloudburst")
authors = listOf("Hexated")
/**
* Status int as the following:
@ -23,5 +23,5 @@ cloudstream {
"Movie",
)
}
iconUrl = "https://www.google.com/s2/favicons?domain=lk21.homes&sz=%size%"
}

2
LayarKacaProvider/src/main/kotlin/com/lagradost/LayarKacaProvider.kt
View File

@ -9,7 +9,7 @@ import org.jsoup.Jsoup
import org.jsoup.nodes.Element
class LayarKacaProvider : MainAPI() {
override var mainUrl = "https://lk21.xn--6frz82g"
override var mainUrl = "https://lk21.homes"
override var name = "LayarKaca"
override val hasMainPage = true
override var lang = "id"

26
NekosamaProvider/build.gradle.kts Normal file
View File

@ -0,0 +1,26 @@
// use an integer for version numbers
version = 1
cloudstream {
language = "fr"
// All of these properties are optional, you can safely remove them
description = " Ce site fait son entrée dans la catégorie des meilleurs sites animes Français. Il est très fiable car quasiment tous ses liens vidéos marchent. Il propose des animes en « VF » version française et en « VOSTFR » version originale Sous-titrée en Français."
authors = listOf("Eddy")
/**
* Status int as the following:
* 0: Down
* 1: Ok
* 2: Slow
* 3: Beta only
* */
status = 1 // will be 3 if unspecified
tvTypes = listOf(
"Anime",
"AnimeMovie",
)
iconUrl = "https://www.google.com/s2/favicons?domain=neko-sama.fr&sz=%size%"
}

2
NekosamaProvider/src/main/AndroidManifest.xml Normal file
View File

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

443
NekosamaProvider/src/main/kotlin/com/lagradost/NekosamaProvider.kt Normal file
View File

@ -0,0 +1,443 @@
package com.lagradost
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.utils.*
import com.lagradost.cloudstream3.utils.AppUtils.toJson
import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
import org.jsoup.nodes.Element
import me.xdrop.fuzzywuzzy.FuzzySearch
import java.util.*
import kotlin.collections.ArrayList
class NekosamaProvider : MainAPI() {
override var mainUrl = "https://neko-sama.fr"
override var name = "Neko-sama"
override val hasQuickSearch = false // recherche rapide (optionel, pas vraimet utile)
override val hasMainPage = true // page d'accueil (optionel mais encoragé)
override var lang = "fr" // fournisseur est en francais
override val supportedTypes =
setOf(TvType.Anime, TvType.AnimeMovie, TvType.OVA) // animes, animesfilms
private val nCharQuery = 10 // take the lenght of the query + nCharQuery
private val resultsSearchNbr = 50 // take only n results from search function
data class EpisodeData(
@JsonProperty("id") val id: Int,
@JsonProperty("title") val title: String?,
@JsonProperty("title_english") val title_english: String?,
@JsonProperty("title_romanji") val title_romanji: String?,
@JsonProperty("title_french") val title_french: String?,
@JsonProperty("others") val others: String?,
@JsonProperty("type") val type: String?,
@JsonProperty("status") val status: String?,
@JsonProperty("popularity") val popularity: Int?,
@JsonProperty("url") val url: String,
@JsonProperty("genre") val genre: Genre?,
@JsonProperty("url_image") val url_image: String?,
@JsonProperty("score") val score: String?,
@JsonProperty("start_date_year") val start_date_year: String?,
@JsonProperty("nb_eps") val nb_eps: String?,
)
data class Genre(
@JsonProperty("0") val action: String?,
@JsonProperty("1") val adventure: String?,
@JsonProperty("2") val drama: String?,
@JsonProperty("3") val fantasy: String?,
@JsonProperty("4") val military: String?,
@JsonProperty("5") val shounen: String?,
)
// Looking for the best title matching from parsed Episode data
private fun EpisodeData.titleObtainedBysortByQuery(query: String?): String? {
if (query == null) {
// No shorting so return the first title
var title = this.title
return title
} else {
val titles = listOf(title, title_french, title_english, title_romanji).filterNotNull()
// Sorted by the best title matching
val titlesSorted = titles.sortedBy { it ->
-FuzzySearch.ratio(
it?.take(query.length + nCharQuery),
query
)
}
return titlesSorted.elementAt(0)
}
}
private fun List<EpisodeData>.sortByQuery(query: String?): List<EpisodeData> {
return if (query == null) {
// Return list to base state if no query
this.sortedBy { it.title }
} else {
this.sortedBy {
val bestTitleMatching = it.titleObtainedBysortByQuery(query)
-FuzzySearch.ratio(
bestTitleMatching?.take(query.length + nCharQuery) ?: bestTitleMatching,
query
)
}
}
}
/** This function is done because there is two database (vf and vostfr). So it allows to sort the combined database **/
private fun List<SearchResponse>.sortByname(query: String?): List<SearchResponse> {
return if (query == null) {
// Return list to base state if no query
this.sortedBy { it.name }
} else {
this.sortedBy {
val name = it.name
-FuzzySearch.ratio(name.take(query.length + nCharQuery), query)
}
}
}
/**
Cherche le site pour un titre spécifique
La recherche retourne une SearchResponse, qui peut être des classes suivants: AnimeSearchResponse, MovieSearchResponse, TorrentSearchResponse, TvSeriesSearchResponse
Chaque classes nécessite des données différentes, mais a en commun le nom, le poster et l'url
**/
override suspend fun search(query: String): List<SearchResponse> {
var listofResults = ArrayList<SearchResponse>()
listOf(
"$mainUrl/animes-search-vf.json" to "(VF) ",
"$mainUrl/animes-search-vostfr.json" to "(Vostfr) "
).apmap {(url, version) ->
val dubStatus = when (!version.isNullOrBlank()) {
version.contains("VF") -> DubStatus.Dubbed
version.contains("Vostfr") -> DubStatus.Subbed
else -> null
}
val reponse = app.get(url).text
val ParsedData = tryParseJson<ArrayList<EpisodeData>>(reponse)
ParsedData?.sortByQuery(query)?.take(resultsSearchNbr)?.forEach { it ->
val type = it.type
val mediaPoster = it.url_image
val href = fixUrl(it.url)
val bestTitleMatching = it.titleObtainedBysortByQuery(query)
val title = version + bestTitleMatching
when (type) {
"m0v1e", "special" -> (
listofResults.add(newMovieSearchResponse( // réponse du film qui sera ajoutée à la liste apmap qui sera ensuite return
title,
href,
TvType.AnimeMovie,
false
) {
this.posterUrl = mediaPoster
}
))
null, "tv", "ova", "" -> (
listofResults.add(newAnimeSearchResponse(
title,
href,
TvType.Anime,
false
) {
this.posterUrl = mediaPoster
this.dubStatus = EnumSet.of(dubStatus)
}
))
else -> {
throw ErrorLoadingException("invalid media type") // le type n'est pas reconnu ==> affiche une erreur
}
}
} ?: throw ErrorLoadingException("ParsedData failed")
}
return listofResults.sortByname(query)
.take(resultsSearchNbr) // Do that to short the vf and vostfr anime together
}
/**
* charge la page d'informations, il ya toutes les donées, les épisodes, le résumé etc ...
* Il faut retourner soit: AnimeLoadResponse, MovieLoadResponse, TorrentLoadResponse, TvSeriesLoadResponse.
*/
override suspend fun load(url: String): LoadResponse {
val document = app.get(url).document //
// url est le lien retourné par la fonction search (la variable href) ou la fonction getMainPage
val episodes = ArrayList<Episode>()
var mediaType = TvType.Anime
val script =
document.select("div#main > script:first-of-type")
val srcAllInfoEpisode =
Regex("""min\"\,\"([^\}]*)\}""")
val results = srcAllInfoEpisode.findAll(script.toString())
//srcAllInfoEpisode.find(script.toString())?.groupValues?.get(1)?
//////////////////////////////////////
var title = "" //document.select("div.offset-md-4 >:not(small)").text()
var dataUrl = ""
var link_video = ""
/////////////////////////////////////
results.forEach { infoEpisode ->
val episodeScript = infoEpisode.groupValues[1]
val srcScriptEpisode =
Regex("""episode\"\:\"Ep\. ([0-9]*)\"""")
val episodeNum = srcScriptEpisode.find(episodeScript)?.groupValues?.get(1)?.toInt()
val srcScriptTitle = Regex("""title\"\:\"([^\"]*)\"\,\"url\"\:\"\\\/anime""")
var titleE = srcScriptTitle.find(episodeScript)?.groupValues?.get(1)
if (titleE != null) title = titleE
val srcScriptlink =
Regex("""\"url\"\:\"([^\"]*)\"""") // remove\
val link = srcScriptlink.find(episodeScript)?.groupValues?.get(1)
if (link != null) link_video = fixUrl(link.replace("\\", ""))
val srcScriptposter =
Regex("""\"url_image\"\:\"([^\"]*)\"""") // remove\
val poster = srcScriptposter.find(episodeScript)?.groupValues?.get(1)
var link_poster = ""
if (poster != null) link_poster = poster.replace("\\", "")
dataUrl = link_video
episodes.add(
Episode(
link_video,
episode = episodeNum,
name = title,
posterUrl = link_poster
)
)
}
val regexYear = Regex("""Diffusion [a-zA-Z]* (\d*)""")
val infosList =
document.selectFirst("div#anime-info-list")?.text()
val isinfosList = !infosList.isNullOrBlank()
var year:Int?=null
if (isinfosList) {
if (infosList!!.contains("movie")) mediaType = TvType.AnimeMovie
year =regexYear.find(infosList)!!.groupValues.get(1).toInt()
}
val description = document.selectFirst("div.synopsis > p")?.text()
val poster = document.select("div.cover > img").attr("src")
if (mediaType == TvType.AnimeMovie) {
return newMovieLoadResponse(
title,
url,
mediaType,
dataUrl
) { // retourne les informations du film
this.posterUrl = poster
this.plot = description
this.year = year
}
} else // an anime
{
val status = when (isinfosList) {
infosList!!.contains("En cours") -> ShowStatus.Ongoing // En cours
infosList!!.contains("Terminé") -> ShowStatus.Completed
else -> null
}
return newAnimeLoadResponse(
title,
url,
mediaType,
) {
this.posterUrl = poster
this.plot = description
addEpisodes(
DubStatus.Dubbed,
episodes
)
this.showStatus = status
this.year = year
}
}
}
/** récupere les liens .mp4 ou m3u8 directement à partir du paramètre data généré avec la fonction load()**/
override suspend fun loadLinks(
data: String, // fournit par load()
isCasting: Boolean,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit,
): Boolean {
val url = data
val document = app.get(url).document
val script = document.select("""[type^="text"]""")[1]
val srcAllvideolinks =
Regex("""\'(https:\/\/[^']*)""")
val results = srcAllvideolinks.findAll(script.toString())
results.forEach { infoEpisode ->
var playerUrl = infoEpisode.groupValues[1]
if (!playerUrl.isNullOrBlank())
loadExtractor(
httpsify(playerUrl),
playerUrl,
subtitleCallback
) { link ->
callback.invoke(
ExtractorLink(
link.source,
link.name + "",
link.url,
link.referer,
getQualityFromName("HD"),
link.isM3u8,
link.headers,
link.extractorData
)
)
}
}
return true
}
private fun Element.toSearchResponse(): SearchResponse {
val poster = select("div.cover > a > div.ma-lazy-wrapper")
var posterUrl = poster.select("img:last-child").attr("src")
if (posterUrl == "#") posterUrl = poster.select("img:last-child").attr("data-src")
val type = select("div.info > p.year").text()
val title = select("div.info > a.title > div.limit").text()
val link = fixUrl(select("div.cover > a").attr("href"))
if (type.contains("Film")) {
return newMovieSearchResponse(
title,
link,
TvType.AnimeMovie,
false,
) {
this.posterUrl = posterUrl
}
} else // an Anime
{
return newAnimeSearchResponse(
title,
link,
TvType.Anime,
false,
) {
this.posterUrl = posterUrl
}
}
}
data class LastEpisodeData(
@JsonProperty("time") val time: String?,
@JsonProperty("timestamp") val timestamp: Int?,
@JsonProperty("episode") val episode: String?,
@JsonProperty("icons") val icons: String?,
@JsonProperty("title") val title: String?,
@JsonProperty("lang") val lang: String?,
@JsonProperty("url") val url: String?,
@JsonProperty("anime_url") val anime_url: String?,
@JsonProperty("url_image") val url_image: String?,
@JsonProperty("url_bg") val url_bg: String,
)
private fun LastEpisodeData.tomainHome(): SearchResponse {
var posterUrl = this.url_image?.replace("""\""", "")
val link = this.anime_url?.replace("""\""", "")?.let { fixUrl(it) }
?: throw error("Error parsing")
val title = this.title ?: throw error("Error parsing")
val type = this.episode ?: ""
var lang = this.lang
val dubStatus = if (lang?.contains("vf") == true) {
DubStatus.Dubbed
} else {
DubStatus.Subbed
}
if (type.contains("Ep")) {
return newAnimeSearchResponse(
title.take(15).replace("\n", "") + "\n" + type.replace("Ep", "Episode"),
link,
TvType.Anime,
false,
) {
this.posterUrl = posterUrl
this.dubStatus = EnumSet.of(dubStatus)
}
} else // a movie
{
return newMovieSearchResponse(
title,
link,
TvType.AnimeMovie,
false,
) {
this.posterUrl = posterUrl
}
}
}
override val mainPage = mainPageOf(
Pair("$mainUrl", "Nouveaux épisodes"),
Pair("$mainUrl/anime-vf/", "Animes et Films en version français"),
Pair("$mainUrl/anime/", "Animes et Films sous-titrés en français"),
)
override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
val categoryName = request.name
var cssSelector = ""
if (categoryName.contains("Nouveaux") && page <= 1) {
cssSelector = "div#main >script"//"div.js-last-episode-container > div.col-lg-3"
}
val url: String
url = if (page == 1) {
request.data
} else {
request.data + page
}
val document = app.get(url).document
val regexLastEpisode = Regex("""lastEpisodes = (.*)\;""")
val home = when (!categoryName.isNullOrBlank()) {
request.name.contains("Animes") -> document.select("div#regular-list-animes > div.anime")
.mapNotNull { article -> article.toSearchResponse() }
else ->
tryParseJson<ArrayList<LastEpisodeData>>(
document.selectFirst(
cssSelector
)?.let {
regexLastEpisode.find(
it.toString()
)?.groupValues?.get(1)
}
)!!.map { episode -> episode.tomainHome() }
}
return newHomePageResponse(request.name, home)
}
}

17
NekosamaProvider/src/main/kotlin/com/lagradost/NekosamaProviderPlugin.kt Normal file
View File

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

53
NekosamaProvider/src/main/kotlin/com/lagradost/PstreamExtractor.kt Normal file
View File

@ -0,0 +1,53 @@
package com.lagradost
import com.lagradost.cloudstream3.utils.*
import com.lagradost.cloudstream3.app
import okio.ByteString.Companion.decodeBase64
open class PstreamExtractor : ExtractorApi() {
override val name: String = "Pstream"
override val mainUrl: String = "https://www.pstream.net"
override val requiresReferer = true
override suspend fun getUrl(url: String, referer: String?): List<ExtractorLink>? {
val refer = url
val headers = mapOf(
"Accept" to "*/*",
"Accept-Language" to "en-US,en;q=0.5",
)
val document = app.get(url, headers = headers).document
val scriptsourceUrl =
document.select("""script[src^="https://www.pstream.net/u/player-script?"]""")
.attr("src")//** Get the url where the scritp function is **/
val Scripdocument =
app.get(scriptsourceUrl, headers = headers).document//** Open the scritp function **/
val base64CodeRegex =
Regex("""e\.parseJSON\(atob\(t\)\.slice\(2\)\)\}\(\"(.*)\=\="\)\,n\=\"""") //** Search the code64 **/
val code64 = base64CodeRegex.find(Scripdocument.toString())?.groupValues?.get(1)
val decoded = code64?.decodeBase64()?.utf8() //** decode the code64 **/
val regexLink = Regex("""\"(https:\\\/\\\/[^"]*)""") //** Extract the m3u8 link **/
val m3u8found = regexLink.find(decoded.toString())?.groupValues?.get(1)
var m3u8 = m3u8found.toString().replace("""\""", "")
return listOf(
ExtractorLink(
name,
name,
m3u8,
refer, // voir si site demande le referer à mettre ici
Qualities.Unknown.value,
true,
headers = headers
)
)
}
}

4
NontonAnimeIDProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 3
cloudstream {
@ -7,7 +7,7 @@ cloudstream {
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
// authors = listOf("Cloudburst")
authors = listOf("Hexated")
/**
* Status int as the following:

16
NontonAnimeIDProvider/src/main/kotlin/com/lagradost/NontonAnimeIDProvider.kt
View File

@ -47,15 +47,15 @@ class NontonAnimeIDProvider : MainAPI() {
document.select("section#postbaru").forEach { block ->
val header = block.selectFirst("h2")!!.text().trim()
val animes = block.select("article.animeseries").map {
val animes = block.select("article.animeseries").mapNotNull {
it.toSearchResult()
}
if (animes.isNotEmpty()) homePageList.add(HomePageList(header, animes))
}
document.select("aside#sidebar_right > div:nth-child(4)").forEach { block ->
document.select("aside#sidebar_right > div.side").forEach { block ->
val header = block.selectFirst("h3")!!.ownText().trim()
val animes = block.select("li.fullwdth").map {
val animes = block.select("ul li.fullwdth").mapNotNull {
it.toSearchResultPopular()
}
if (animes.isNotEmpty()) homePageList.add(HomePageList(header, animes))
@ -91,9 +91,9 @@ class NontonAnimeIDProvider : MainAPI() {
}
}
private fun Element.toSearchResult(): AnimeSearchResponse {
private fun Element.toSearchResult(): AnimeSearchResponse? {
val href = getProperAnimeLink(fixUrl(this.selectFirst("a")!!.attr("href")))
val title = this.selectFirst("h3.title")!!.text()
val title = this.selectFirst("h3.title")?.text() ?: return null
val posterUrl = fixUrl(this.select("img").attr("data-src"))
return newAnimeSearchResponse(title, href, TvType.Anime) {
@ -103,9 +103,9 @@ class NontonAnimeIDProvider : MainAPI() {
}
private fun Element.toSearchResultPopular(): AnimeSearchResponse {
private fun Element.toSearchResultPopular(): AnimeSearchResponse? {
val href = getProperAnimeLink(fixUrl(this.selectFirst("a")!!.attr("href")))
val title = this.select("h4").text().trim()
val title = this.selectFirst("h4")?.text()?.trim() ?: return null
val posterUrl = fixUrl(this.select("img").attr("data-src"))
return newAnimeSearchResponse(title, href, TvType.Anime) {
@ -157,7 +157,7 @@ class NontonAnimeIDProvider : MainAPI() {
val type = getType(document.select("span.typeseries").text().trim())
val rating = document.select("span.nilaiseries").text().trim().toIntOrNull()
val description = document.select(".entry-content.seriesdesc > p").text().trim()
val trailer = document.selectFirst("iframe#traileryt")?.attr("data-src")
val trailer = document.selectFirst("a.trailerbutton")?.attr("href")
val episodes = if (document.select("button.buttfilter").isNotEmpty()) {
val id = document.select("input[name=series_id]").attr("value")

4
PhimmoichillProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 2
cloudstream {
@ -7,7 +7,7 @@ cloudstream {
// All of these properties are optional, you can safely remove them
// description = "Lorem Ipsum"
// authors = listOf("Cloudburst")
authors = listOf("Hexated")
/**
* Status int as the following:

101
PhimmoichillProvider/src/main/kotlin/com/lagradost/PhimmoichillProvider.kt
View File

@ -1,6 +1,5 @@
package com.lagradost
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.LoadResponse.Companion.addActors
import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
@ -8,7 +7,6 @@ import com.lagradost.cloudstream3.mvvm.safeApiCall
import com.lagradost.cloudstream3.utils.*
import org.jsoup.nodes.Element
import java.net.URLDecoder
import java.util.ArrayList
class PhimmoichillProvider : MainAPI() {
override var mainUrl = "https://phimmoichill.net"
@ -41,7 +39,14 @@ class PhimmoichillProvider : MainAPI() {
val home = document.select("li.item").mapNotNull {
it.toSearchResult()
}
return newHomePageResponse(request.name, home)
return newHomePageResponse(
list = HomePageList(
name = request.name,
list = home,
isHorizontalImages = true
),
hasNext = true
)
}
private fun decode(input: String): String? = URLDecoder.decode(input, "utf-8")
@ -96,19 +101,11 @@ class PhimmoichillProvider : MainAPI() {
val rating =
document.select("ul.entry-meta.block-film li:nth-child(7) span").text().toRatingInt()
val actors = document.select("ul.entry-meta.block-film li:last-child a").map { it.text() }
val recommendations = document.select("ul#list-film-realted li.item").mapNotNull {
val titleHeader = it.select("p") ?: return@mapNotNull null
val recUrl = titleHeader.attr("href") ?: return@mapNotNull null
val recTitle = titleHeader.text() ?: return@mapNotNull null
val poster = it.select("img").attr("src")
MovieSearchResponse(
recTitle,
recUrl,
this.name,
TvType.Movie,
poster
)
val recommendations = document.select("ul#list-film-realted li.item").map {
it.toSearchResult().apply {
this.posterUrl = decode(it.selectFirst("img")!!.attr("data-src").substringAfter("url="))
}
}
return if (tvType == TvType.TvSeries) {
val docEpisodes = app.get(link).document
@ -155,81 +152,41 @@ class PhimmoichillProvider : MainAPI() {
): Boolean {
val document = app.get(data).document
val key = document.select("div#content script").mapNotNull { script ->
if (script.data().contains("filmInfo.episodeID =")) {
val id = script.data().substringAfter("filmInfo.episodeID = parseInt('")
.substringBefore("');")
val key = document.select("div#content script")
.find { it.data().contains("filmInfo.episodeID =") }?.data()?.let { script ->
val id = script.substringAfter("filmInfo.episodeID = parseInt('")
app.post(
// Not mainUrl
url = "https://phimmoichills.net/pmplayer.php",
data = mapOf("qcao" to id),
data = mapOf("qcao" to id, "sv" to "0"),
referer = data,
headers = mapOf(
"X-Requested-With" to "XMLHttpRequest",
"Content-Type" to "application/x-www-form-urlencoded; charset=UTF-8"
)
).text.also { println("HERERERR $it") }.substringAfterLast("iniPlayers(\"").substringBefore("\",")
} else {
null
).text.substringAfterLast("iniPlayers(\"")
.substringBefore("\",")
}
}.first()
listOf(
Pair("https://so-trym.topphimmoi.org/hlspm/$key", "PMFAST"),
Pair("https://dash.megacdn.xyz/hlspm/$key", "PMHLS"),
Pair("https://so-trym.topphimmoi.org/raw/$key/index.m3u8", "PMFAST"),
Pair("https://dash.megacdn.xyz/raw/$key/index.m3u8", "PMHLS"),
Pair("https://dash.megacdn.xyz/dast/$key/index.m3u8", "PMBK")
).apmap { (link, source) ->
safeApiCall {
if (source == "PMBK") {
callback.invoke(
ExtractorLink(
source,
source,
link,
referer = "$mainUrl/",
quality = Qualities.P1080.value,
isM3u8 = true
)
callback.invoke(
ExtractorLink(
source,
source,
link,
referer = "$mainUrl/",
quality = Qualities.P1080.value,
isM3u8 = true,
)
} else {
val playList = app.get(link, referer = "$mainUrl/")
.parsedSafe<ResponseM3u>()?.main?.segments?.map { segment ->
PlayListItem(
segment.link,
(segment.du.toFloat() * 1_000_000).toLong()
)
}
callback.invoke(
ExtractorLinkPlayList(
source,
source,
playList ?: return@safeApiCall,
referer = "$mainUrl/",
quality = Qualities.P1080.value,
headers = mapOf(
// "If-None-Match" to "*",
"Origin" to mainUrl,
)
)
)
}
)
}
}
return true
}
data class Segment(
@JsonProperty("du") val du: String,
@JsonProperty("link") val link: String,
)
data class DataM3u(
@JsonProperty("segments") val segments: List<Segment>?,
)
data class ResponseM3u(
@JsonProperty("2048p") val main: DataM3u?,
)
}

2
README.md
View File

@ -1,4 +1,4 @@
# Cloudstream Non-English Plugin Repository
# Cloudstream Non-English Plugin Repository
All available repositories: https://recloudstream.github.io/repos/

2
StreamingcommunityProvider/src/main/kotlin/com/lagradost/StreamingcommunityProvider.kt
View File

@ -128,7 +128,7 @@ data class TrailerElement(
class StreamingcommunityProvider : MainAPI() {
override var lang = "it"
override var mainUrl = "https://streamingcommunity.agency"
override var mainUrl = "https://streamingcommunity.tech"
override var name = "Streamingcommunity"
override val hasMainPage = true
override val hasChromecastSupport = true

2
UseeTv/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 1
version = 2
cloudstream {

2
UseeTv/src/main/kotlin/com/lagradost/UseeTv.kt
View File

@ -32,7 +32,7 @@ class UseeTv : MainAPI() {
}.mapNotNull {
it.toSearchResult()
}
HomePageList(name, home)
HomePageList(name, home, true)
}.filter { it.list.isNotEmpty() }
return HomePageResponse(home)

2
VizjerProvider/build.gradle.kts
View File

@ -1,5 +1,5 @@
// use an integer for version numbers
version = 3
version = 4
cloudstream {

19
VizjerProvider/src/main/kotlin/com/lagradost/VizjerProvider.kt
View File

@ -5,11 +5,12 @@ import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
import com.lagradost.cloudstream3.utils.ExtractorLink
import com.lagradost.cloudstream3.utils.loadExtractor
import com.lagradost.cloudstream3.network.CloudflareKiller
import org.jsoup.Jsoup
import org.jsoup.select.Elements
class VizjerProvider : MainAPI() {
override var mainUrl = "http://93.185.166.160"
override var mainUrl = "https://vizjer.pl"
override var name = "Vizjer.pl"
override var lang = "pl"
override val hasMainPage = true
@ -19,8 +20,10 @@ class VizjerProvider : MainAPI() {
TvType.Movie
)
private val interceptor = CloudflareKiller()
override suspend fun getMainPage(page: Int, request : MainPageRequest): HomePageResponse {
val document = app.get(mainUrl).document
val document = app.get(mainUrl, interceptor = interceptor).document
val lists = document.select(".item-list")
val categories = ArrayList<HomePageList>()
for (l in lists) {
@ -37,7 +40,9 @@ class VizjerProvider : MainAPI() {
this.name,
TvType.Movie,
properUrl(poster)!!,
year
year,
null,
posterHeaders = interceptor.getCookieHeaders(mainUrl).toMap()
)
}
categories.add(HomePageList(title, items))
@ -47,7 +52,7 @@ class VizjerProvider : MainAPI() {
override suspend fun search(query: String): List<SearchResponse> {
val url = "$mainUrl/wyszukaj?phrase=$query"
val document = app.get(url).document
val document = app.get(url, interceptor = interceptor).document
val lists = document.select("#advanced-search > div")
val movies = lists[1].select("div:not(.clearfix)")
val series = lists[3].select("div:not(.clearfix)")
@ -66,10 +71,10 @@ class VizjerProvider : MainAPI() {
type,
properUrl(img)!!,
null,
null
posterHeaders = interceptor.getCookieHeaders(url).toMap()
)
} else {
MovieSearchResponse(name, properUrl(href)!!, this.name, type, properUrl(img)!!, null)
MovieSearchResponse(name, properUrl(href)!!, this.name, type, properUrl(img)!!, null, posterHeaders = interceptor.getCookieHeaders(url).toMap())
}
}
}
@ -77,7 +82,7 @@ class VizjerProvider : MainAPI() {
}
override suspend fun load(url: String): LoadResponse {
val document = app.get(url).document
val document = app.get(url, interceptor = interceptor).document
val documentTitle = document.select("title").text().trim()
if (documentTitle.startsWith("Logowanie")) {

26
VostfreeProvider/build.gradle.kts Normal file
View File

@ -0,0 +1,26 @@
// use an integer for version numbers
version = 1
cloudstream {
language = "fr"
// All of these properties are optional, you can safely remove them
description = " Ce site est certainement l’un des meilleurs sites permettant de regarder des animes en ligne et gratuitement. Il vous propose la version « VF » version française et la « VOSTFR » version originale Sous-titrée en Français."
authors = listOf("Eddy")
/**
* Status int as the following:
* 0: Down
* 1: Ok
* 2: Slow
* 3: Beta only
* */
status = 1 // will be 3 if unspecified
tvTypes = listOf(
"Anime",
"AnimeMovie",
)
iconUrl = "https://www.google.com/s2/favicons?domain=vostfree.cx&sz=%size%"
}

2
VostfreeProvider/src/main/AndroidManifest.xml Normal file
View File

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

42
VostfreeProvider/src/main/kotlin/com/lagradost/MytvExtractor.kt Normal file
View File

@ -0,0 +1,42 @@
package com.lagradost
import com.lagradost.cloudstream3.utils.*
import com.lagradost.cloudstream3.app
import org.jsoup.Jsoup
open class MytvExtractor : ExtractorApi() {
override val name: String = "Mytv"
override val mainUrl: String = "https://www.myvi.tv/"
private val srcRegex =
Regex("""PlayerLoader\.CreatePlayer\(\"v\=(.*)\\u0026tp""") // would be possible to use the parse and find src attribute
override val requiresReferer = false
override suspend fun getUrl(url: String, referer: String?): List<ExtractorLink>? {
val cleaned_url = url
val html = app.get(cleaned_url)
with(html) { // raised error ERROR_CODE_PARSING_CONTAINER_UNSUPPORTED (3003) is due to the response: "error_nofile"
srcRegex.find(this.text)?.groupValues?.get(1)?.let { link ->
var lien = link
lien = lien.replace("%2f", "/").replace("%3a", ":").replace("%3f", "?")
.replace("%3d", "=").replace("%26", "&")
//val html = app.get(url).text
//val document = Jsoup.parse(html)
//val link1 = document.select("script")
return listOf(
ExtractorLink(
name,
name,
lien,
cleaned_url, // voir si site demande le referer à mettre ici
Qualities.Unknown.value,
)
)
}
}
return null
}
}

35
VostfreeProvider/src/main/kotlin/com/lagradost/SibnetExtractor.kt Normal file
View File

@ -0,0 +1,35 @@
package com.lagradost
import com.lagradost.cloudstream3.utils.*
import com.lagradost.cloudstream3.app
import org.jsoup.Jsoup
open class SibnetExtractor : ExtractorApi() {
override val name: String = "Sibnet"
override val mainUrl: String = "https://video.sibnet.ru"
private val srcRegex =
Regex("""player\.src\(\[\{src: \"(.*?)\"""") // would be possible to use the parse and find src attribute
override val requiresReferer = true
override suspend fun getUrl(url: String, referer: String?): List<ExtractorLink>? {
val cleaned_url = url
val html = app.get(cleaned_url)
with(html) { // raised error ERROR_CODE_PARSING_CONTAINER_UNSUPPORTED (3003) is due to the response: "error_nofile"
srcRegex.find(this.text)?.groupValues?.get(1)?.let { link ->
return listOf(
ExtractorLink(
name,
name,
mainUrl + link,
cleaned_url, // voir si site demande le referer à mettre ici
Qualities.Unknown.value,
)
)
}
}
return null
}
}

368
VostfreeProvider/src/main/kotlin/com/lagradost/VostfreeProvider.kt Normal file
View File

@ -0,0 +1,368 @@
package com.lagradost
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.utils.*
import com.lagradost.cloudstream3.utils.AppUtils.toJson
import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
import org.jsoup.nodes.Element
import java.util.*
import kotlin.collections.ArrayList
class VostfreeProvider : MainAPI() {
// VostFreeProvider() est ajouté à la liste allProviders dans MainAPI.kt
override var mainUrl = "https://vostfree.cx"
override var name = "Vostfree"
override val hasQuickSearch = false // recherche rapide (optionel, pas vraimet utile)
override val hasMainPage = true // page d'accueil (optionel mais encoragé)
override var lang = "fr" // fournisseur est en francais
override val supportedTypes =
setOf(TvType.Anime, TvType.AnimeMovie, TvType.OVA) // animes, animesfilms
// liste des types: https://recloudstream.github.io/dokka/app/com.lagradost.cloudstream3/-tv-type/index.html
/**
Cherche le site pour un titre spécifique
La recherche retourne une SearchResponse, qui peut être des classes suivants: AnimeSearchResponse, MovieSearchResponse, TorrentSearchResponse, TvSeriesSearchResponse
Chaque classes nécessite des données différentes, mais a en commun le nom, le poster et l'url
**/
override suspend fun search(query: String): List<SearchResponse> {
val link =
"$mainUrl/index.php?do=search&subaction=search&story=$query&submit=Submit+Query" // L'url pour chercher un anime de dragon sera donc: 'https://vostfree.cx/index.php?story=dragon&do=search&subaction=search'
var mediaType = TvType.Anime
val document =
app.post(link).document // app.get() permet de télécharger la page html avec une requete HTTP (get)
return document.select("div.search-result") // on séléctione tous les éléments 'enfant' du type articles
.mapNotNull { div -> // map crée une liste des éléments (ici newMovieSearchResponse et newAnimeSearchResponse)
val type =
div?.selectFirst("div.genre")
?.text() // replace enlève tous les '\t' et '\n' du titre
val mediaPoster =
div?.selectFirst("span.image > img")?.attr("src")
?.let { fixUrl(it) } // récupère le texte de l'attribut src de l'élément
val href = div?.selectFirst("div.info > div.title > a")?.attr("href")
?: throw ErrorLoadingException("invalid link") // renvoie une erreur si il n'y a pas de lien vers le média
val title = div.selectFirst("> div.info > div.title > a")?.text().toString()
val version = div.selectFirst("> div.info > ul > li")?.text().toString()
if (type == "OAV") mediaType = TvType.OVA
when (type) {
"FILM" -> (
newMovieSearchResponse( // réponse du film qui sera ajoutée à la liste map qui sera ensuite return
title,
href,
TvType.AnimeMovie,
false
) {
this.posterUrl = mediaPoster
// this.rating = rating
}
)
null, "OAV" -> (
newAnimeSearchResponse(
title,
href,
mediaType,
false
) {
this.posterUrl = mediaPoster
this.dubStatus =
if (version.contains("VF")) EnumSet.of(DubStatus.Dubbed) else EnumSet.of(
DubStatus.Subbed
)
// this.rating = rating
}
)
else -> {
throw ErrorLoadingException("invalid media type") // le type n'est pas reconnu ==> affiche une erreur
}
}
}
}
/**
* charge la page d'informations, il ya toutes les donées, les épisodes, le résumé etc ...
* Il faut retourner soit: AnimeLoadResponse, MovieLoadResponse, TorrentLoadResponse, TvSeriesLoadResponse.
*/
data class EpisodeData(
@JsonProperty("url") val url: String,
@JsonProperty("episodeNumber") val episodeNumber: String,
)
override suspend fun load(url: String): LoadResponse {
val document = app.get(url).document // récupere le texte sur la page (requète http)
// url est le lien retourné par la fonction search (la variable href) ou la fonction getMainPage
var mediaType = TvType.Anime
val episodes = ArrayList<Episode>()
val urlSaison = ArrayList<String>()
val meta =
document.selectFirst("div#dle-content > div.watch-top > div.image-bg > div.image-bg-content > div.slide-block ")
val description = meta?.select("div.slide-middle > div.slide-desc")?.first()
?.text() // first() selectione le premier élément de la liste
var title = meta?.select("div.slide-middle > h1")?.text()
?: "Invalid title"
title = title.replace("Saison", "").replace("saison", "").replace("SAISON", "")
.replace("Season", "").replace("season", "").replace("SEASON", "")
val poster = fixUrl(
meta?.select(" div.slide-poster > img")
?.attr("src")!!
)// récupere le texte de l'attribut 'data-src'
var year = document.select("div.slide-info > p > b > a")?.text()?.toInt()
urlSaison.add(url)
var seasonNumber: Int? = null
val otherSaisonFound = document.select("div.new_player_series_count > a")
otherSaisonFound.forEach {
urlSaison.add(it.attr("href"))
}
urlSaison.apmap { urlseason ->
val document =
app.get(urlseason).document // récupere le texte sur la page (requète http)
val meta =
document.selectFirst("div#dle-content > div.watch-top > div.image-bg > div.image-bg-content > div.slide-block ")
val poster_saison = mainUrl + meta?.select(" div.slide-poster > img")
?.attr("src")
val seasontext = meta?.select("ul.slide-top > li:last-child > b:last-child")?.text()
var indication: String? = null
if (!seasontext.isNullOrBlank() && !seasontext.contains("""([a-zA-Z])""".toRegex())) {
seasonNumber = seasontext.toInt()
if (seasonNumber!! < 1) { // seem a an OVA has 0 as season number
seasonNumber = 1000
indication = "Vous regardez un OVA"
}
}
document.select(" select.new_player_selector > option").forEach {
val typeOftheAnime = it.text()
if (typeOftheAnime != "Film") {
mediaType = TvType.Anime
val link =
EpisodeData(
urlseason,
typeOftheAnime.replace("Episode ", ""),
).toJson()
episodes.add(
Episode(
link,
episode = typeOftheAnime.replace("Episode ", "").toInt(),
season = seasonNumber,
name = typeOftheAnime,
description = indication,
posterUrl = poster_saison
)
)
} else {
mediaType = TvType.AnimeMovie
}
}
}
if (mediaType == TvType.AnimeMovie) {
return newMovieLoadResponse(
title,
url,
mediaType,
url
) { // retourne les informations du film
this.posterUrl = poster
this.plot = description
this.year = year
}
} else // an anime
{
return newAnimeLoadResponse(
title,
url,
mediaType,
) {
this.posterUrl = poster
this.plot = description
this.year = year
addEpisodes(
if (title.contains("VF")) DubStatus.Dubbed else DubStatus.Subbed,
episodes
)
}
}
}
// récupere les liens .mp4 ou m3u8 directement à partir du paramètre data généré avec la fonction load()
override suspend fun loadLinks(
data: String, // fournit par load()
isCasting: Boolean,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit,
): Boolean {
val parsedInfo = tryParseJson<EpisodeData>(data)
val url = parsedInfo?.url ?: data
val noMovie = "1"
val numeroEpisode = parsedInfo?.episodeNumber
?: noMovie // if is not a movie then take the episode number else for movie it is 1
val document = app.get(url).document
document.select("div.new_player_bottom")
.forEach { player_bottom -> // séléctione tous les players
// supprimer les zéro de 0015 pour obtenir l'episode 15
var index = numeroEpisode.indexOf('0')
var numero = numeroEpisode
while (index == 0) {
numero = numeroEpisode.drop(1)
index = numero.indexOf('0')
}
val cssQuery = " div#buttons_$numero" // numero épisode
val buttonsNepisode = player_bottom?.select(cssQuery)
?: throw ErrorLoadingException("Non player") //séléctione tous les players pour l'episode NoEpisode
buttonsNepisode.select("> div").apmap {
val player = it.attr("id")
.toString() //prend tous les players resultat : "player_2140" et "player_6521"
val playerName = it.select("div#$player")
.text() // prend le nom du player ex : "Uqload" et "Sibnet"
val codePlayload =
document.selectFirst("div#content_$player")?.text()
.toString() // result : "325544" ou "https:..."
var playerUrl = when (playerName) {
"VIP", "Upvid", "Dstream", "Streamsb", "Vudeo", "NinjaS", "Upstream" -> codePlayload // case https
"Uqload" -> "https://uqload.com/embed-$codePlayload.html"
"Mytv" -> "https://www.myvi.tv/embed/$codePlayload"
"Sibnet" -> "https://video.sibnet.ru/shell.php?videoid=$codePlayload"
"Stream" -> "https://myvi.ru/player/embed/html/$codePlayload"
else -> return@apmap
}
loadExtractor(
httpsify(playerUrl),
playerUrl,
subtitleCallback
) { link -> // charge un extracteur d'extraire le lien direct .mp4
callback.invoke(
ExtractorLink( // ici je modifie le callback pour ajouter des informations, normalement ce n'est pas nécessaire
link.source,
link.name + "",
link.url,
link.referer,
getQualityFromName("HD"),
link.isM3u8,
link.headers,
link.extractorData
)
)
}
// }
}
}
return true
}
private fun Element.toSearchResponse(): SearchResponse {
val poster = select("span.image")
val posterUrl = fixUrl(poster.select("> img").attr("src"))
val subdub = select("div.quality").text()
val genre = select("div.genre").text()
val title = select("div.info > div.title").text()
val link = select("div.play > a").attr("href")
if (genre == "FILM") {
return newMovieSearchResponse(
title,
link,
TvType.AnimeMovie,
false,
) {
this.posterUrl = posterUrl
//this.quality = quality
}
} else // an Anime
{
return newAnimeSearchResponse(
title,
link,
TvType.Anime,
false,
) {
this.posterUrl = posterUrl
this.dubStatus =
if (subdub == "VF") EnumSet.of(DubStatus.Dubbed) else EnumSet.of(DubStatus.Subbed)
}
}
}
private fun Element.toSearchResponse1(): SearchResponse {
val poster = select("span.image")
val posterUrl = fixUrl(poster.select("> img").attr("src"))
val subdub = select("div.quality").text()
//val genre = select("div.info > ul.additional > li").text()
val title = select("div.info > div.title").text()
val link = select(" div.info > div.title > a").attr("href")
return newAnimeSearchResponse(
title,
link,
TvType.Anime,
false,
) {
this.posterUrl = posterUrl
this.dubStatus =
if (subdub == "VF") EnumSet.of(DubStatus.Dubbed) else EnumSet.of(DubStatus.Subbed)
}
}
override val mainPage = mainPageOf(
Pair("$mainUrl/last-episode.html/page/", "Nouveaux épisodes en Vostfr"),
Pair(
"$mainUrl/animes-vostfr-recement-ajoutees.html/page/",
"Animes Vostfr récemment ajoutés"
),
Pair("$mainUrl/last-episode-vf.html/page/", "Nouveaux épisodes en français"),
Pair("$mainUrl/last-anime-vf.html/page/", "Animes VF récemment ajoutés"),
Pair("$mainUrl/animes-vf/page/", "Animes en version français"),
Pair("$mainUrl/animes-vostfr/page/", "Animes sous-titrés en français"),
Pair("$mainUrl/films-vf-vostfr/page/", "Films en Fr et Vostfr")
)
override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
val categoryName = request.name
var cssSelector = ""
if (categoryName.contains("récemment")) {
cssSelector = "div#content > div.movie-poster"
} else {
cssSelector = "div#content > div#dle-content > div.movie-poster"
}
val url = request.data + page
val document = app.get(url).document
val home =
when (!categoryName.isNullOrBlank()) {
request.name.contains("Nouveaux") -> document.select("div#content > div.last-episode")
.mapNotNull { article -> article.toSearchResponse1() }
else ->
document.select(cssSelector)
.mapNotNull { article -> // avec mapnotnull si un élément est null, il sera automatiquement enlevé de la liste
article.toSearchResponse()
}
}
return newHomePageResponse(request.name, home)
}
}

18
VostfreeProvider/src/main/kotlin/com/lagradost/VostfreeProviderPlugin.kt Normal file
View File

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

34
VostfreeProvider/src/main/kotlin/com/lagradost/VudeoExtractor.kt Normal file
View File

@ -0,0 +1,34 @@
package com.lagradost
import com.lagradost.cloudstream3.utils.*
import com.lagradost.cloudstream3.app
open class VudeoExtractor : ExtractorApi() {
override val name: String = "Vudeo"
override val mainUrl: String = "https://vudeo.io/"
private val srcRegex =
Regex("""sources\: \[\"(.*)\"""") // would be possible to use the parse and find src attribute
override val requiresReferer = false
override suspend fun getUrl(url: String, referer: String?): List<ExtractorLink>? {
val cleaned_url = url
with(app.get(cleaned_url)) { // raised error ERROR_CODE_PARSING_CONTAINER_UNSUPPORTED (3003) is due to the response: "error_nofile"
srcRegex.find(this.text)?.groupValues?.get(1)?.let { link ->
return listOf(
ExtractorLink(
name,
name,
link,
cleaned_url, // voir si site demande le referer à mettre ici
Qualities.Unknown.value,
)
)
}
}
return null
}
}

25
WebFlix/build.gradle.kts Normal file
View File

@ -0,0 +1,25 @@
// use an integer for version numbers
version = 3
cloudstream {
// All of these properties are optional, you can safely remove them
description = "Adds multiple sites using WebFlix. This includes sites in English, Polish, Portuguese and Arabic"
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(
"Movies",
"TvSeries",
"Live"
)
iconUrl = "https://raw.githubusercontent.com/recloudstream/cloudstream-extensions-multilingual/master/WebFlix/icon.png"
}

BIN
WebFlix/icon.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.7 KiB

2
WebFlix/src/main/AndroidManifest.xml Normal file
View File

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

226
WebFlix/src/main/kotlin/com/lagradost/WebFlixProvider.kt Normal file
View File

@ -0,0 +1,226 @@
package com.lagradost
import android.util.Base64
import android.util.Log
import com.lagradost.WebFlixProvider.Companion.toHomePageList
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.utils.AppUtils.toJson
import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
import com.lagradost.cloudstream3.utils.ExtractorLink
import com.lagradost.cloudstream3.utils.Qualities
import com.lagradost.cloudstream3.utils.loadExtractor
import java.net.URLEncoder
class WebFlixProvider(override var lang: String, override var mainUrl: String, override var name: String, override val supportedTypes: Set<TvType>) : MainAPI() {
val magicPath = base64Decode("NEY1QTlDM0Q5QTg2RkE1NEVBQ0VEREQ2MzUxODUvZDUwNmFiZmQtOWZlMi00YjcxLWI5NzktZmVmZjIxYmNhZDEzLw==")
override val hasMainPage = true
override val hasChromecastSupport = true
override suspend fun getMainPage(
page: Int,
request : MainPageRequest
): HomePageResponse? {
val res = tryParseJson<HomeResponse>(app.get("$mainUrl/api/first/$magicPath").text) ?: return null
return HomePageResponse(
res.getHomePageLists(this),
false
)
}
override suspend fun search(query: String): List<SearchResponse>? {
val res = tryParseJson<ApiSearchResponse>(app.get("$mainUrl/api/search/${query.encodeUri()}/$magicPath").text) ?: return null
return res.posters.map { it.toSearchResponse(this) }
}
override suspend fun load(url: String): LoadResponse? {
val data = tryParseJson<Entry>(app.get(url).text) ?: return null
return data.toLoadResponse(this)
}
override suspend fun loadLinks(
data: String,
isCasting: Boolean,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit
): Boolean {
val sources = tryParseJson<List<Source>>(data) ?: return false
sources.forEach {
it.load(subtitleCallback, callback)
}
return true
}
private data class ApiSearchResponse(
val posters: List<Entry>
)
private data class HomeResponse(
val genres: List<HomeReponseGenre> = emptyList(),
val channels: List<Entry> = emptyList(),
// val slides: List<Entry> = emptyList()
) {
fun getHomePageLists(provider: WebFlixProvider): List<HomePageList> {
val lists = mutableListOf<HomePageList>()
if (channels.isNotEmpty()) {
channels.forEach {
if (it.type == null) it.type = "channel"
}
lists.add(channels.toHomePageList("Channels", provider))
}
//if (slides.isNotEmpty()) lists.add(slides.toHomePageList("Slides", provider))
lists.addAll(genres.map { it.toHomePageList(provider) })
return lists
}
}
private data class HomeReponseGenre(
val title: String,
val posters: List<Entry>
) {
fun toHomePageList(provider: WebFlixProvider) = posters.toHomePageList(title, provider)
}
data class Source(
val title: String?,
val url: String?,
val quality: String?,
) {
suspend fun load(subtitleCallback: (SubtitleFile) -> Unit, callback: (ExtractorLink) -> Unit) {
if (url == null) return;
when (url.split(".").last()) {
"mp4", "m3u8", "mov" -> callback.invoke(
ExtractorLink(
quality ?: "",
title ?: "",
url,
"",
Qualities.Unknown.value,
isM3u8 = (url.endsWith("m3u8"))
))
else -> loadExtractor(url, subtitleCallback, callback)
}
}
}
private data class ApiEpisode(
val id: Int,
val title: String?,
val description: String?,
val sources: List<Source> = emptyList()
) {
fun toEpisode(season: Int, episode: Int) = Episode(
sources.toJson(),
title,
season,
episode,
null,
null,
description
)
}
private data class ApiSeason(
val title: String?,
val episodes: List<ApiEpisode> = emptyList()
) {
fun getEpisodes(season: Int): List<Episode> = episodes.mapIndexed { idx, episode -> episode.toEpisode(season, idx + 1) }
}
data class Entry(
val id: Int,
val title: String,
val label: String?,
val sublabel: String?,
val image: String?,
val description: String?,
var type: String?,
val year: String?,
val imdb: Double?,
val sources: List<Source> = emptyList()
) {
fun getTvType() = when (type) {
"serie" -> TvType.TvSeries
"movie" -> TvType.Movie
"channel", "4" -> TvType.Live
else -> {
Log.d("WebFlix", "other: $type")
TvType.Others
}
}
fun toSearchResponse(provider: WebFlixProvider): SearchResponse {
val entry = this
return when(getTvType()) {
TvType.Movie -> provider.newMovieSearchResponse(
title,
"${provider.mainUrl}/api/movie/by/$id/${provider.magicPath}",
getTvType(),
) {
posterUrl = image
year = entry.year?.toIntOrNull()
}
TvType.TvSeries -> provider.newTvSeriesSearchResponse(
title,
"${provider.mainUrl}/api/movie/by/$id/${provider.magicPath}",
TvType.TvSeries
) {
posterUrl = image
//year = entry.year?.toIntOrNull()
}
TvType.Live -> provider.newMovieSearchResponse(
title,
"${provider.mainUrl}/api/channel/by/$id/${provider.magicPath}",
getTvType(),
) {
posterUrl = image
year = entry.year?.toIntOrNull()
}
else -> provider.newMovieSearchResponse(
title,
"${provider.mainUrl}/api/$type/by/$id/${provider.magicPath}",
getTvType(),
) {
posterUrl = image
year = entry.year?.toIntOrNull()
}
}
}
suspend fun toLoadResponse(provider: WebFlixProvider): LoadResponse? {
val entry = this
return when(getTvType()) {
TvType.TvSeries -> {
val res = tryParseJson<List<ApiSeason>>(app.get("${provider.mainUrl}/api/season/by/serie/${id}/${provider.magicPath}").text) ?: return null
provider.newTvSeriesLoadResponse(
title,
"",
TvType.TvSeries,
res.mapIndexed { idx, season -> season.getEpisodes(idx + 1) }
.flatten()
) {
this.posterUrl = entry.image
this.year = entry.year?.toIntOrNull()
this.plot = description
this.rating = if (entry.imdb != null) (entry.imdb*10).toInt() else null
}
}
else -> provider.newMovieLoadResponse(
title,
"",
getTvType(),
sources.toJson()
) {
this.posterUrl = entry.image
this.year = entry.year?.toIntOrNull()
this.plot = description
this.rating = if (entry.imdb != null) (entry.imdb*10).toInt() else null
}
}
}
}
companion object {
fun String.encodeUri() = URLEncoder.encode(this, "utf8")
fun List<Entry>.toHomePageList(name: String, provider: WebFlixProvider) = HomePageList(name, this.map { it.toSearchResponse(provider) })
}
}

20
WebFlix/src/main/kotlin/com/lagradost/WebFlixProviderPlugin.kt Normal file
View File

@ -0,0 +1,20 @@
package com.lagradost
import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
import com.lagradost.cloudstream3.plugins.Plugin
import android.content.Context
import com.lagradost.cloudstream3.TvType
@CloudstreamPlugin
class WebFlixProviderPlugin: Plugin() {
override fun load(context: Context) {
// All providers should be added in this manner. Please don't edit the providers list directly.
registerMainAPI(WebFlixProvider("en", "https://dhfilmtv.com", "DHFilmTv", setOf(TvType.Movie, TvType.TvSeries)))
registerMainAPI(WebFlixProvider("pl", "https://app.vodi.cc", "Vodi.cc", setOf(TvType.Movie, TvType.TvSeries)))
registerMainAPI(WebFlixProvider("fr", "http://www.vanflix.cm", "Vanflix", setOf(TvType.Movie, TvType.TvSeries, TvType.Live)))
registerMainAPI(WebFlixProvider("pt-pt", "https://www.brflix.xyz", "BrFlix", setOf(TvType.Movie, TvType.TvSeries, TvType.Live)))
registerMainAPI(WebFlixProvider("ar", "https://ifilm.live", "ifilm.live", setOf(TvType.Movie, TvType.TvSeries)))
registerMainAPI(WebFlixProvider("en", "https://karmadarna.com", "KarMaDarNa", setOf(TvType.NSFW)))
}
}

26
WiflixProvider/build.gradle.kts Normal file
View File

@ -0,0 +1,26 @@
// use an integer for version numbers
version = 1
cloudstream {
language = "fr"
// All of these properties are optional, you can safely remove them
description = "WIFLIX, le site grâce auquel vous allez pouvoir regarder vos films et séries préférées"
authors = listOf("Eddy")
/**
* Status int as the following:
* 0: Down
* 1: Ok
* 2: Slow
* 3: Beta only
* */
status = 1 // will be 3 if unspecified
tvTypes = listOf(
"TvSeries",
"Movie",
)
iconUrl = "https://www.google.com/s2/favicons?domain=wiflix.zone&sz=%size%"
}

2
WiflixProvider/src/main/AndroidManifest.xml Normal file
View File

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

35
WiflixProvider/src/main/kotlin/com/lagradost/DoodStreamExtractor.kt Normal file
View File

@ -0,0 +1,35 @@
package com.lagradost
import com.lagradost.cloudstream3.app
import com.lagradost.cloudstream3.utils.ExtractorApi
import com.lagradost.cloudstream3.utils.ExtractorLink
import com.lagradost.cloudstream3.utils.getQualityFromName
open class DoodStreamExtractor : ExtractorApi() {
override var name = "DoodStream"
override var mainUrl = "https://doodstream.com"
override val requiresReferer = false
override fun getExtractorUrl(id: String): String {
return "$mainUrl/d/$id"
}
override suspend fun getUrl(url: String, referer: String?): List<ExtractorLink>? {
val response0 = app.get(url).text // html of DoodStream page to look for /pass_md5/...
val md5 =mainUrl+(Regex("/pass_md5/[^']*").find(response0)?.value ?: return null) // get https://dood.ws/pass_md5/...
val trueUrl = app.get(md5, referer = url).text + "zUEJeL3mUN?token=" + md5.substringAfterLast("/") //direct link to extract (zUEJeL3mUN is random)
val quality = Regex("\\d{3,4}p").find(response0.substringAfter("<title>").substringBefore("</title>"))?.groupValues?.get(0)
return listOf(
ExtractorLink(
trueUrl,
this.name,
trueUrl,
mainUrl,
getQualityFromName(quality),
false
)
) // links are valid in 8h
}
}

81
WiflixProvider/src/main/kotlin/com/lagradost/StreamSBPlusExtractor.kt Normal file
View File

@ -0,0 +1,81 @@
package com.lagradost
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.SubtitleFile
import com.lagradost.cloudstream3.app
import com.lagradost.cloudstream3.utils.ExtractorApi
import com.lagradost.cloudstream3.utils.ExtractorLink
import com.lagradost.cloudstream3.utils.M3u8Helper
// This is a modified version of https://github.com/jmir1/aniyomi-extensions/blob/master/src/en/genoanime/src/eu/kanade/tachiyomi/animeextension/en/genoanime/extractors/StreamSBExtractor.kt
// The following code is under the Apache License 2.0 https://github.com/jmir1/aniyomi-extensions/blob/master/LICENSE
open class StreamSBPlusExtractor : ExtractorApi() {
override var name = "StreamSB"
override var mainUrl = "https://sbspeed.com"
override val requiresReferer = false
private val hexArray = "0123456789ABCDEF".toCharArray()
private fun bytesToHex(bytes: ByteArray): String {
val hexChars = CharArray(bytes.size * 2)
for (j in bytes.indices) {
val v = bytes[j].toInt() and 0xFF
hexChars[j * 2] = hexArray[v ushr 4]
hexChars[j * 2 + 1] = hexArray[v and 0x0F]
}
return String(hexChars)
}
data class Subs (
@JsonProperty("file") val file: String,
@JsonProperty("label") val label: String,
)
data class StreamData (
@JsonProperty("file") val file: String,
@JsonProperty("cdn_img") val cdnImg: String,
@JsonProperty("hash") val hash: String,
@JsonProperty("subs") val subs: List<Subs>?,
@JsonProperty("length") val length: String,
@JsonProperty("id") val id: String,
@JsonProperty("title") val title: String,
@JsonProperty("backup") val backup: String,
)
data class Main (
@JsonProperty("stream_data") val streamData: StreamData,
@JsonProperty("status_code") val statusCode: Int,
)
override suspend fun getUrl(
url: String,
referer: String?,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit
) {
val regexID =
Regex("(embed-[a-zA-Z0-9]{0,8}[a-zA-Z0-9_-]+|/e/[a-zA-Z0-9]{0,8}[a-zA-Z0-9_-]+)")
val id = regexID.findAll(url).map {
it.value.replace(Regex("(embed-|/e/)"), "")
}.first()
// val master = "$mainUrl/sources48/6d6144797752744a454267617c7c${bytesToHex.lowercase()}7c7c4e61755a56456f34385243727c7c73747265616d7362/6b4a33767968506e4e71374f7c7c343837323439333133333462353935333633373836643638376337633462333634663539343137373761333635313533333835333763376333393636363133393635366136323733343435323332376137633763373337343732363536313664373336327c7c504d754478413835306633797c7c73747265616d7362"
val master = "$mainUrl/sources48/" + bytesToHex("||$id||||streamsb".toByteArray()) + "/"
val headers = mapOf(
"watchsb" to "sbstream",
)
val mapped = app.get(
master.lowercase(),
headers = headers,
referer = url,
).parsedSafe<Main>()
// val urlmain = mapped.streamData.file.substringBefore("/hls/")
M3u8Helper.generateM3u8(
name,
mapped?.streamData?.file ?: return,
url,
headers = headers
).forEach(callback)
}
}

307
WiflixProvider/src/main/kotlin/com/lagradost/WiflixProvider.kt Normal file
View File

@ -0,0 +1,307 @@
package com.lagradost
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.utils.*
import com.lagradost.cloudstream3.utils.AppUtils.toJson
import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
import org.jsoup.nodes.Element
import org.jsoup.select.Elements
import kotlin.collections.ArrayList
class WiflixProvider : MainAPI() {
override var mainUrl = "https://wiflix.zone"
override var name = "Wiflix"
override val hasQuickSearch = false // recherche rapide (optionel, pas vraimet utile)
override val hasMainPage = true // page d'accueil (optionel mais encoragé)
override var lang = "fr" // fournisseur est en francais
override val supportedTypes =
setOf(TvType.Movie, TvType.TvSeries) // series, films
// liste des types: https://recloudstream.github.io/dokka/app/com.lagradost.cloudstream3/-tv-type/index.html
/**
Cherche le site pour un titre spécifique
La recherche retourne une SearchResponse, qui peut être des classes suivants: AnimeSearchResponse, MovieSearchResponse, TorrentSearchResponse, TvSeriesSearchResponse
Chaque classes nécessite des données différentes, mais a en commun le nom, le poster et l'url
**/
override suspend fun search(query: String): List<SearchResponse> {
val link =
"$mainUrl/index.php?do=search&subaction=search&search_start=0&full_search=1&result_from=1&story=$query&titleonly=3&searchuser=&replyless=0&replylimit=0&searchdate=0&beforeafter=after&sortby=date&resorder=desc&showposts=0&catlist%5B%5D=0" // search'
val document =
app.post(link).document // app.get() permet de télécharger la page html avec une requete HTTP (get)
val results = document.select("div#dle-content > div.clearfix")
val allresultshome =
results.mapNotNull { article -> // avec mapnotnull si un élément est null, il sera automatiquement enlevé de la liste
article.toSearchResponse()
}
return allresultshome
}
/**
* charge la page d'informations, il ya toutes les donées, les épisodes, le résumé etc ...
* Il faut retourner soit: AnimeLoadResponse, MovieLoadResponse, TorrentLoadResponse, TvSeriesLoadResponse.
*/
data class EpisodeData(
@JsonProperty("url") val url: String,
@JsonProperty("episodeNumber") val episodeNumber: String,
)
private fun Elements.takeEpisode(url: String, duborSub: String?): ArrayList<Episode> {
val episodes = ArrayList<Episode>()
this.select("ul.eplist > li").forEach {
val strEpisode = it.text()
val strEpisodeN = strEpisode.replace("Episode ", "")
val link =
EpisodeData(
url,
strEpisodeN,
).toJson()
episodes.add(
Episode(
link,
name = duborSub,
episode = strEpisodeN.toInt(),
)
)
}
return episodes
}
override suspend fun load(url: String): LoadResponse {
val document = app.get(url).document //
// url est le lien retourné par la fonction search (la variable href) ou la fonction getMainPage
var episodes = ArrayList<Episode>()
var mediaType: TvType
val episodeFrfound =
document.select("div.blocfr")
val episodeVostfrfound =
document.select("div.blocvostfr")
val title =
document.select("h1[itemprop]").text()
val posterUrl =
document.select("img#posterimg").attr("src")
val yearRegex = Regex("""ate de sortie\: (\d*)""")
val year = yearRegex.find(document.text())?.groupValues?.get(1)
val tags = document.select("[itemprop=genre] > a")
.map { it.text() } // séléctione tous les tags et les ajoutes à une liste
if (episodeFrfound.text().contains("Episode")) {
mediaType = TvType.TvSeries
val duborSub = "Episode en VF"
episodes = episodeFrfound.takeEpisode(url, duborSub)
} else if (episodeVostfrfound.text().contains("Episode")) {
mediaType = TvType.TvSeries
val duborSub = "Episode sous-titré"
episodes = episodeVostfrfound.takeEpisode(url, duborSub)
} else {
mediaType = TvType.Movie
}
///////////////////////////////////////////
///////////////////////////////////////////
var type_rec: TvType
val recommendations =
document.select("div.clearfixme > div > div")?.mapNotNull { element ->
val recTitle =
element.select("a").text() ?: return@mapNotNull null
val image = element.select("a >img")?.attr("src")
val recUrl = element.select("a").attr("href")
type_rec = TvType.TvSeries
if (recUrl.contains("film")) type_rec = TvType.Movie
if (type_rec == TvType.TvSeries) {
TvSeriesSearchResponse(
recTitle,
recUrl,
this.name,
TvType.TvSeries,
image?.let { fixUrl(it) },
)
} else
MovieSearchResponse(
recTitle,
recUrl,
this.name,
TvType.Movie,
image?.let { fixUrl(it) },
)
}
var comingSoon = url.contains("films-prochainement")
if (mediaType == TvType.Movie) {
val description = document.selectFirst("div.screenshots-full")?.text()
?.replace("(.* .ynopsis)".toRegex(), "")
return newMovieLoadResponse(
name = title,
url = url,
type = TvType.Movie,
dataUrl = url
) {
this.posterUrl = fixUrl(posterUrl)
this.plot = description
this.recommendations = recommendations
this.year = year?.toIntOrNull()
this.comingSoon = comingSoon
this.tags = tags
}
} else {
val description = document.selectFirst("span[itemprop=description]")?.text()
return newTvSeriesLoadResponse(
title,
url,
mediaType,
episodes
) {
this.posterUrl = fixUrl(posterUrl)
this.plot = description
this.recommendations = recommendations
this.year = year?.toIntOrNull()
this.comingSoon = comingSoon
this.tags = tags
}
}
}
// récupere les liens .mp4 ou m3u8 directement à partir du paramètre data généré avec la fonction load()
override suspend fun loadLinks(
data: String, // fournit par load()
isCasting: Boolean,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit,
): Boolean {
val parsedInfo =
tryParseJson<EpisodeData>(data)
val url = parsedInfo?.url ?: data
val numeroEpisode = parsedInfo?.episodeNumber ?: null
val document = app.get(url).document
val episodeFrfound =
document.select("div.blocfr")
val episodeVostfrfound =
document.select("div.blocvostfr")
val cssCodeForPlayer = if (episodeFrfound.text().contains("Episode")) {
"div.ep${numeroEpisode}vf > a"
} else if (episodeVostfrfound.text().contains("Episode")) {
"div.ep${numeroEpisode}vs > a"
} else {
"div.linkstab > a"
}
document.select("$cssCodeForPlayer").apmap { player -> // séléctione tous les players
var playerUrl = "https"+player.attr("href").replace("(.*)https".toRegex(), "")
if (!playerUrl.isNullOrBlank())
if (playerUrl.contains("dood")) {
playerUrl = playerUrl.replace("doodstream.com", "dood.wf")
}
loadExtractor(
httpsify(playerUrl),
playerUrl,
subtitleCallback
) { link ->
callback.invoke(
ExtractorLink( // ici je modifie le callback pour ajouter des informations, normalement ce n'est pas nécessaire
link.source,
link.name + "",
link.url,
link.referer,
getQualityFromName("HD"),
link.isM3u8,
link.headers,
link.extractorData
)
)
}
}
return true
}
private fun Element.toSearchResponse(): SearchResponse {
val posterUrl = fixUrl(select("div.img-box > img").attr("src"))
val qualityExtracted = select("div.nbloc1-2 >span").text()
val type = select("div.nbloc3").text()
val title = select("a.nowrap").text()
val link = select("a.nowrap").attr("href")
var quality = when (!qualityExtracted.isNullOrBlank()) {
qualityExtracted.contains("HDLight") -> getQualityFromString("HD")
qualityExtracted.contains("Bdrip") -> getQualityFromString("BlueRay")
qualityExtracted.contains("DVD") -> getQualityFromString("DVD")
qualityExtracted.contains("CAM") -> getQualityFromString("Cam")
else -> null
}
if (type.contains("Film")) {
return MovieSearchResponse(
name = title,
url = link,
apiName = title,
type = TvType.Movie,
posterUrl = posterUrl,
quality = quality
)
} else // an Serie
{
return TvSeriesSearchResponse(
name = title,
url = link,
apiName = title,
type = TvType.TvSeries,
posterUrl = posterUrl,
quality = quality,
//
)
}
}
override val mainPage = mainPageOf(
Pair("$mainUrl/films-prochainement/page/", "Film Prochainement en Streaming"),
Pair("$mainUrl/film-en-streaming/page/", "Top Films cette année"),
Pair("$mainUrl/serie-en-streaming/page/", "Top Séries cette année"),
Pair("$mainUrl/saison-complete/page/", "Les saisons complètes"),
Pair("$mainUrl/film-ancien/page/", "Film zahalé (ancien)")
)
override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
val url = request.data + page
val document = app.get(url).document
val movies = document.select("div#dle-content > div.clearfix")
val home =
movies.mapNotNull { article -> // avec mapnotnull si un élément est null, il sera automatiquement enlevé de la liste
article.toSearchResponse()
}
return newHomePageResponse(request.name, home)
}
}

18
WiflixProvider/src/main/kotlin/com/lagradost/WiflixProviderPlugin.kt Normal file
View File

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

4
XcineProvider/build.gradle.kts
View File

@ -16,7 +16,7 @@ cloudstream {
* 2: Slow
* 3: Beta only
* */
status = 1 // will be 3 if unspecified
status = 0 // will be 3 if unspecified
tvTypes = listOf(
"AnimeMovie",
"Anime",
@ -25,4 +25,4 @@ cloudstream {
)
iconUrl = "https://www.google.com/s2/favicons?domain=xcine.me&sz=%size%"
}
}

2
YomoviesProvider/src/main/kotlin/com/lagradost/YomoviesProvider.kt
View File

@ -9,7 +9,7 @@ import com.lagradost.cloudstream3.utils.loadExtractor
import org.jsoup.nodes.Element
class YomoviesProvider : MainAPI() {
override var mainUrl = "https://yomovies.cloud"
override var mainUrl = "https://yomovies.homes"
override var name = "Yomovies"
override val hasMainPage = true
override var lang = "hi"

2
build.gradle.kts
View File

@ -84,6 +84,8 @@ subprojects {
//run JS
implementation("org.mozilla:rhino:1.7.14")
// Library/extensions searching with Levenshtein distance
implementation ("me.xdrop:fuzzywuzzy:1.4.0")
}
}

29
settings.gradle.kts
View File

@ -5,7 +5,34 @@ rootProject.name = "CloudstreamPlugins"
// Plugins are included like this
val disabled = listOf<String>(
"EgyBestProvider", "FaselHDProvider", "AkwamProvider", "MyCimaProvider"
"EgyBestProvider",
"FaselHDProvider",
"AkwamProvider",
"MyCimaProvider",
"AnimeIndoProvider",
"AnimeSailProvider",
"Anizm",
"DramaidProvider",
"DubokuProvider",
"Gomunimeis",
"GomunimeProvider",
"Hdfilmcehennemi",
"HDrezkaProvider",
"IdlixProvider",
"KuramanimeProvider",
"KuronimeProvider",
"LayarKacaProvider",
"MultiplexProvider",
"NeonimeProvider",
"NontonAnimeIDProvider",
"OploverzProvider",
"OtakudesuProvider",
"PhimmoichillProvider",
"RebahinProvider",
"TocanimeProvider",
"UakinoProvider",
"UseeTv",
"YomoviesProvider"
)
File(rootDir, ".").eachDir { dir ->