feat(src/fr): Add FRAnime source (#1905)

lib/mytv-extractor/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+    id("com.android.library")
+    kotlin("android")
+}
+
+android {
+    compileSdk = AndroidConfig.compileSdk
+    namespace = "eu.kanade.tachiyomi.lib.mytvextractor"
+
+    defaultConfig {
+        minSdk = AndroidConfig.minSdk
+    }
+}
+
+dependencies {
+    compileOnly(libs.bundles.common)
+}

lib/mytv-extractor/src/main/java/eu/kanade/tachiyomi/lib/mytvextractor/MytvExtractor.kt

@@ -0,0 +1,28 @@
+package eu.kanade.tachiyomi.lib.mytvextractor
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.OkHttpClient
+
+class MytvExtractor(private val client: OkHttpClient) {
+
+    fun videosFromUrl(url: String): List<Video> {
+        val document = client.newCall(GET(url)).execute().asJsoup()
+        val videoList = mutableListOf<Video>()
+        document.select("script").forEach { script ->
+            if (script.data().contains("CreatePlayer(\"v")) {
+                val videosString = script.data().toString()
+                val videoUrl = videosString.substringAfter("\"v=").substringBefore("\\u0026tp=video").replace("%26", "&").replace("%3a", ":").replace("%2f", "/").replace("%3f", "?").replace("%3d", "=")
+                if (!videoUrl.contains("https:")) {
+                    val videoUrl = "https:$videoUrl"
+                    videoList.add(Video(videoUrl, "Stream", videoUrl))
+                } else {
+                    videoList.add(Video(videoUrl, "Mytv", videoUrl))
+                }
+            }
+        }
+        return videoList
+    }
+
+}

lib/sendvid-extractor/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+    id("com.android.library")
+    kotlin("android")
+}
+
+android {
+    compileSdk = AndroidConfig.compileSdk
+    namespace = "eu.kanade.tachiyomi.lib.sendvidextractor"
+
+    defaultConfig {
+        minSdk = AndroidConfig.minSdk
+    }
+}
+
+dependencies {
+    compileOnly(libs.bundles.common)
+}

lib/sendvid-extractor/src/main/java/eu/kanade/tachiyomi/lib/sendvidextractor/SendvidExtractor.kt

@@ -0,0 +1,45 @@
+package eu.kanade.tachiyomi.lib.sendvidextractor
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+
+class SendvidExtractor(private val client: OkHttpClient, private val headers: Headers) {
+    fun videosFromUrl(url: String, prefix: String = ""): List<Video> {
+        val videoList = mutableListOf<Video>()
+        val document = client.newCall(GET(url)).execute().asJsoup()
+        val masterUrl = document.selectFirst("source#video_source")?.attr("src") ?: return emptyList()
+
+        val masterHeaders = headers.newBuilder()
+            .add("Accept", "*/*")
+            .add("Host", masterUrl.toHttpUrl().host)
+            .add("Origin", "https://${url.toHttpUrl().host}")
+            .add("Referer", "https://${url.toHttpUrl().host}/")
+            .build()
+        val masterPlaylist = client.newCall(
+            GET(masterUrl, headers = masterHeaders),
+        ).execute().body.string()
+
+        val masterBase = "https://${masterUrl.toHttpUrl().host}${masterUrl.toHttpUrl().encodedPath}"
+            .substringBeforeLast("/") + "/"
+
+        masterPlaylist.substringAfter("#EXT-X-STREAM-INF:").split("#EXT-X-STREAM-INF:")
+            .forEach {
+                val quality = "Sendvid:" + it.substringAfter("RESOLUTION=").substringAfter("x").substringBefore(",") + "p "
+                val videoUrl = masterBase + it.substringAfter("\n").substringBefore("\n")
+
+                val videoHeaders = headers.newBuilder()
+                    .add("Accept", "*/*")
+                    .add("Host", videoUrl.toHttpUrl().host)
+                    .add("Origin", "https://${url.toHttpUrl().host}")
+                    .add("Referer", "https://${url.toHttpUrl().host}/")
+                    .build()
+
+                videoList.add(Video(videoUrl, prefix + quality, videoUrl, headers = videoHeaders))
+            }
+        return videoList
+    }
+}

lib/sibnet-extractor/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+    id("com.android.library")
+    kotlin("android")
+}
+
+android {
+    compileSdk = AndroidConfig.compileSdk
+    namespace = "eu.kanade.tachiyomi.lib.sibnetextractor"
+
+    defaultConfig {
+        minSdk = AndroidConfig.minSdk
+    }
+}
+
+dependencies {
+    compileOnly(libs.bundles.common)
+}

lib/sibnet-extractor/src/main/java/eu/kanade/tachiyomi/lib/sibnetextractor/SibnetExtractor.kt

@@ -0,0 +1,40 @@
+package eu.kanade.tachiyomi.lib.sibnetextractor
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+
+class SibnetExtractor(private val client: OkHttpClient) {
+
+    fun videosFromUrl(url: String): List<Video> {
+        val videoList = mutableListOf<Video>()
+
+        val document = client.newCall(
+            GET(url),
+        ).execute().asJsoup()
+        val script = document.selectFirst("script:containsData(player.src)")?.data() ?: return emptyList()
+        val slug = script.substringAfter("player.src").substringAfter("src:")
+            .substringAfter("\"").substringBefore("\"")
+
+        val videoUrl = if (slug.contains("http")) {
+            slug
+        } else {
+            "https://${url.toHttpUrl().host}$slug"
+        }
+
+        val videoHeaders = Headers.headersOf(
+            "Referer",
+            url,
+        )
+
+        videoList.add(
+            Video(videoUrl, "Sibnet", videoUrl, headers = videoHeaders),
+        )
+
+        return videoList
+    }
+
+}

src/fr/franime/AndroidManifest.xml

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

src/fr/franime/build.gradle

@@ -0,0 +1,21 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlinx-serialization'
+
+ext {
+    extName = 'FrAnime'
+    pkgNameSuffix = 'fr.franime'
+    extClass = '.FrAnime'
+    extVersionCode = 1
+    libVersion = '13'
+    containsNsfw = true
+}
+
+dependencies {
+    implementation(project(':lib-mytv-extractor'))
+    implementation(project(':lib-sendvid-extractor'))
+    implementation(project(':lib-sibnet-extractor'))
+    implementation(project(':lib-streamsb-extractor'))
+}
+
+apply from: "$rootDir/common.gradle"

src/fr/franime/src/eu/kanade/tachiyomi/animeextension/fr/franime/FrAnime.kt

@@ -0,0 +1,201 @@
+package eu.kanade.tachiyomi.animeextension.fr.franime
+
+import android.net.UrlQuerySanitizer
+import eu.kanade.tachiyomi.animeextension.fr.franime.dto.Anime
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.lib.mytvextractor.MytvExtractor
+import eu.kanade.tachiyomi.lib.sendvidextractor.SendvidExtractor
+import eu.kanade.tachiyomi.lib.sibnetextractor.SibnetExtractor
+import eu.kanade.tachiyomi.lib.streamsbextractor.StreamSBExtractor
+import eu.kanade.tachiyomi.network.GET
+import kotlinx.serialization.json.Json
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import rx.Observable
+import uy.kohesive.injekt.injectLazy
+import java.lang.Exception
+import java.net.URI
+import kotlin.io.path.Path
+import kotlin.io.path.name
+
+class FrAnime : AnimeHttpSource() {
+
+    override val name = "FRAnime"
+
+    private val domain = "franime.fr"
+
+    override val baseUrl = "https://$domain"
+
+    private val baseApiUrl = "https://api.$domain/api"
+    private val baseApiAnimeUrl = "$baseApiUrl/anime"
+
+    override val lang = "fr"
+
+    override val supportsLatest = true
+
+    override val client: OkHttpClient = network.cloudflareClient
+
+    private val json: Json by injectLazy()
+
+    private val database by lazy {
+        client.newCall(GET("$baseApiUrl/animes/")).execute()
+            .use { it.body.string() }
+            .let { json.decodeFromString<Array<Anime>>(it) }
+    }
+
+    // === Anime Details
+
+    override fun animeDetailsParse(response: Response): SAnime = throw Exception("not used")
+
+    // === Episodes
+
+    override fun fetchEpisodeList(anime: SAnime): Observable<List<SEpisode>> {
+        val stem = Path(URI(anime.url).path).name // WILL break on API update ! name becomes fileName in new versions !
+        val language = UrlQuerySanitizer(anime.url).getValue("lang")
+        val season = UrlQuerySanitizer(anime.url).getValue("s").toInt()
+        val animeData = database.first { titleToUrl(it.originalTitle) == stem }
+        val episodes = mutableListOf<SEpisode>()
+        animeData.seasons[season - 1].episodes.forEachIndexed { index, episode ->
+            val players = (if (language == "vo") episode.languages.vo else episode.languages.vf).players
+            if (players.isNotEmpty()) {
+                episodes += SEpisode.create().apply {
+                    setUrlWithoutDomain(anime.url + "&ep=${index + 1}")
+                    name = episode.title
+                    episode_number = index.toFloat()
+                }
+            }
+        }
+        return Observable.just(episodes.sortedByDescending { it.episode_number })
+    }
+
+    override fun episodeListParse(response: Response): List<SEpisode> = throw Exception("not used")
+
+    // === Players
+
+    override fun fetchVideoList(episode: SEpisode): Observable<List<Video>> {
+        val seasonNumber = UrlQuerySanitizer(episode.url).getValue("s").toInt()
+        val episodeNumber = UrlQuerySanitizer(episode.url).getValue("ep").toInt()
+        val episodeLang = UrlQuerySanitizer(episode.url).getValue("lang")
+        val stem = Path(URI(episode.url).path).name
+        val animeData = database.first { titleToUrl(it.originalTitle) == stem }
+        val episodeData = animeData.seasons[seasonNumber - 1].episodes[episodeNumber - 1]
+        val videoBaseUrl = "$baseApiAnimeUrl/${animeData.id}/${seasonNumber - 1}/${episodeNumber - 1}"
+
+        val videos = mutableListOf<Video>()
+        val players = if (episodeLang == "vo") episodeData.languages.vo.players else episodeData.languages.vf.players
+
+        players.forEachIndexed { index, playerName ->
+            val apiUrl = "$videoBaseUrl/$episodeLang/$index"
+            val playerUrl = client.newCall(GET(apiUrl)).execute().body.string()
+            val playerVideos = when (playerName) {
+                "franime_myvi" -> listOf(Video(playerUrl, "FRAnime", playerUrl))
+                "myvi" -> MytvExtractor(client).videosFromUrl(playerUrl)
+                "sendvid" -> SendvidExtractor(client, headers).videosFromUrl(playerUrl)
+                "sibnet" -> SibnetExtractor(client).videosFromUrl(playerUrl)
+                "sbfull" -> StreamSBExtractor(client).videosFromUrl(playerUrl, headers)
+                else -> null
+            }
+            if (playerVideos != null) videos.addAll(playerVideos)
+        }
+        return Observable.just(videos)
+    }
+
+    // === Latest
+
+    override fun fetchLatestUpdates(page: Int): Observable<AnimesPage> {
+        val pages = database.reversed().toList().chunked(50)
+        val hasNextPage = pages.size > page
+        val entries = pageToSAnimes(pages.getOrNull(page - 1))
+        return Observable.just(AnimesPage(entries, hasNextPage))
+    }
+
+    override fun latestUpdatesParse(response: Response): AnimesPage = throw Exception("not used")
+
+    override fun latestUpdatesRequest(page: Int): Request = throw Exception("not used")
+
+    // === Popular
+
+    override fun fetchPopularAnime(page: Int): Observable<AnimesPage> {
+        val pages = database.sortedByDescending { it.note }.chunked(50)
+        val hasNextPage = pages.size > page
+        val entries = pageToSAnimes(pages.getOrNull(page - 1))
+        return Observable.just(AnimesPage(entries, hasNextPage))
+    }
+
+    override fun popularAnimeParse(response: Response) = throw Exception("not used")
+
+    override fun popularAnimeRequest(page: Int) = throw Exception("not used")
+
+    // === Search
+
+    override fun fetchSearchAnime(page: Int, query: String, filters: AnimeFilterList): Observable<AnimesPage> {
+        val pages = database.filter {
+            it.title.contains(query, true) ||
+                it.originalTitle.contains(query, true) ||
+                it.titlesAlt.en?.contains(query, true) == true ||
+                it.titlesAlt.enJp?.contains(query, true) == true ||
+                it.titlesAlt.jaJp?.contains(query, true) == true
+        }.chunked(50)
+        val hasNextPage = pages.size > page
+        val entries = pageToSAnimes(pages.getOrNull(page - 1))
+        return Observable.just(AnimesPage(entries, hasNextPage))
+    }
+
+    override fun searchAnimeParse(response: Response): AnimesPage = throw Exception("not used")
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request = throw Exception("not used")
+
+    // === Utils
+
+    private fun titleToUrl(title: String): String = Regex("[^A-Za-z0-9 ]").replace(title, "").replace(" ", "-").lowercase()
+
+    private fun pageToSAnimes(page: List<Anime>?): List<SAnime> {
+        val entries = mutableListOf<SAnime>()
+        page?.forEach {
+            for ((index, season) in it.seasons.withIndex()) {
+                val seasonTitle = it.title + if (it.seasons.size > 1) " S${index + 1}" else ""
+                val hasVostfr = season.episodes.fold(false) { v, e -> v or e.languages.vo.players.isNotEmpty() }
+                val hasVf = season.episodes.fold(false) { v, e -> v or e.languages.vf.players.isNotEmpty() }
+                // I want to die for writing this
+                if (hasVostfr) {
+                    entries += SAnime.create().apply {
+                        title = seasonTitle + if (hasVf) " (VOSTFR)" else ""
+                        thumbnail_url = it.poster
+                        genre = it.genres.joinToString()
+                        status = parseStatus(it.status, it.seasons.size, index + 1)
+                        description = it.description
+                        setUrlWithoutDomain("/anime/${titleToUrl(it.originalTitle)}?lang=vo&s=${index + 1}")
+                        initialized = true
+                    }
+                }
+                if (hasVf) {
+                    entries += SAnime.create().apply {
+                        title = seasonTitle + if (hasVostfr) " (VF)" else ""
+                        thumbnail_url = it.poster
+                        genre = it.genres.joinToString()
+                        status = parseStatus(it.status, it.seasons.size, index + 1)
+                        description = it.description
+                        setUrlWithoutDomain("/anime/${titleToUrl(it.originalTitle)}?lang=vf&s=${index + 1}")
+                        initialized = true
+                    }
+                }
+            }
+        }
+        return entries
+    }
+
+    private fun parseStatus(statusString: String?, seasonCount: Int = 1, season: Int = 1): Int {
+        if (season < seasonCount) return SAnime.COMPLETED
+        return when (statusString?.trim()) {
+            "EN COURS" -> SAnime.COMPLETED
+            "TERMINÉ" -> SAnime.COMPLETED
+            else -> SAnime.UNKNOWN
+        }
+    }
+}

src/fr/franime/src/eu/kanade/tachiyomi/animeextension/fr/franime/dto/FrAnimeDto.kt

@@ -0,0 +1,91 @@
+package eu.kanade.tachiyomi.animeextension.fr.franime.dto
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonDecoder
+import kotlinx.serialization.json.JsonEncoder
+import kotlinx.serialization.json.JsonUnquotedLiteral
+import kotlinx.serialization.json.jsonPrimitive
+import java.math.BigInteger
+
+typealias BigIntegerJson =
+    @Serializable(with = BigIntegerSerializer::class)
+    BigInteger
+
+@OptIn(ExperimentalSerializationApi::class)
+private object BigIntegerSerializer : KSerializer<BigInteger> {
+
+    override val descriptor = PrimitiveSerialDescriptor("java.math.BigInteger", PrimitiveKind.LONG)
+
+    override fun deserialize(decoder: Decoder): BigInteger =
+        when (decoder) {
+            is JsonDecoder -> decoder.decodeJsonElement().jsonPrimitive.content.toBigInteger()
+            else -> decoder.decodeString().toBigInteger()
+        }
+
+    override fun serialize(encoder: Encoder, value: BigInteger) =
+        when (encoder) {
+            is JsonEncoder -> encoder.encodeJsonElement(JsonUnquotedLiteral(value.toString()))
+            else -> encoder.encodeString(value.toString())
+        }
+}
+
+@Serializable
+data class Anime(
+    @SerialName("themes") val genres: Array<String>,
+    @SerialName("saisons") val seasons: Array<Season>,
+    @SerialName("_id") val uid: String?,
+    @SerialName("id") val id: BigIntegerJson,
+    @SerialName("source_url") val sourceUrl: String,
+    @SerialName("banner") val banner: String?,
+    @SerialName("affiche") val poster: String,
+    @SerialName("titleO") val originalTitle: String,
+    @SerialName("title") val title: String,
+    @SerialName("titles") val titlesAlt: TitlesAlt,
+    @SerialName("description") val description: String,
+    @SerialName("note") val note: Float,
+    @SerialName("format") val format: String,
+    @SerialName("startDate") val startDate: String?, // deserialize as date
+    @SerialName("endDate") val endDate: String?, // ditto
+    @SerialName("status") val status: String,
+    @SerialName("nsfw") val nsfw: Boolean,
+    @SerialName("__v") val uuv: Int?, // no idea wtf is this
+    @SerialName("affiche_small") val posterSmall: String?,
+    @SerialName("updatedDate") val updateTime: Long?, // deserialize as timestamp
+)
+
+@Serializable
+data class Season(
+    @SerialName("title") val title: String,
+    @SerialName("episodes") val episodes: Array<Episode>,
+)
+
+@Serializable
+data class Episode(
+    @SerialName("title") val title: String,
+    @SerialName("lang") val languages: EpisodeLanguages,
+)
+
+@Serializable
+data class EpisodeLanguages(
+    @SerialName("vf") val vf: EpisodeLanguage,
+    @SerialName("vo") val vo: EpisodeLanguage,
+)
+
+@Serializable
+data class EpisodeLanguage(
+    @SerialName("lecteurs") val players: Array<String>,
+)
+
+@Serializable
+data class TitlesAlt(
+    @SerialName("en") val en: String?,
+    @SerialName("en_jp") val enJp: String?,
+    @SerialName("ja_jp") val jaJp: String?,
+)