src/es/animeonlineninja/build.gradle

@@ -3,7 +3,7 @@ ext {
     extClass = '.AnimeOnlineNinja'
     themePkg = 'dooplay'
     baseUrl = 'https://ww3.animeonline.ninja'
-    overrideVersionCode = 39
+    overrideVersionCode = 40
 }
 
 apply from: "$rootDir/common.gradle"
@@ -14,4 +14,7 @@ dependencies {
     implementation(project(':lib:filemoon-extractor'))
     implementation(project(':lib:mixdrop-extractor'))
     implementation(project(':lib:uqload-extractor'))
+    implementation(project(':lib:vidhide-extractor'))
+    implementation(project(':lib:streamwish-extractor'))
+    implementation(project(':lib:mp4upload-extractor'))
 }

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/AnimeOnlineNinja.kt

@@ -4,20 +4,24 @@ import androidx.preference.CheckBoxPreference
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
 import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
 import eu.kanade.tachiyomi.lib.mixdropextractor.MixDropExtractor
+import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
 import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
+import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.uqloadextractor.UqloadExtractor
+import eu.kanade.tachiyomi.lib.vidhideextractor.VidHideExtractor
 import eu.kanade.tachiyomi.multisrc.dooplay.DooPlay
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import okhttp3.Request
 import okhttp3.Response
 import org.jsoup.nodes.Document
 import org.jsoup.nodes.Element
-import uy.kohesive.injekt.api.get
 
 class AnimeOnlineNinja : DooPlay(
     "es",
@@ -91,7 +95,7 @@ class AnimeOnlineNinja : DooPlay(
         } else if (path.startsWith("/letra") || path.startsWith("/tendencias")) {
             val before = path.substringBeforeLast("/")
             val after = path.substringAfterLast("/")
-            GET(baseUrl + before + "/page/$page/" + after)
+            GET("$baseUrl$before/page/$page/$after")
         } else {
             GET("$baseUrl$path/page/$page")
         }
@@ -100,11 +104,29 @@ class AnimeOnlineNinja : DooPlay(
     // ============================== Episodes ==============================
     override val episodeMovieText = "Película"
 
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val doc = getRealAnimeDoc(response.asJsoup())
+        val seasonList = doc.select(seasonListSelector)
+        return if (seasonList.isEmpty()) {
+            listOf(
+                SEpisode.create().apply {
+                    setUrlWithoutDomain(doc.location())
+                    episode_number = 1F
+                    name = episodeMovieText
+                },
+            )
+        } else {
+            seasonList.reversed().flatMap { seasonElement ->
+                getSeasonEpisodes(seasonElement).reversed()
+            }
+        }
+    }
+
     // ============================ Video Links =============================
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
         val players = document.select("ul#playeroptionsul li")
-        return players.flatMap { player ->
+        return players.parallelCatchingFlatMapBlocking { player ->
             val name = player.selectFirst("span.title")!!.text()
             val url = getPlayerUrl(player)
             extractVideos(url, name)
@@ -116,23 +138,19 @@ class AnimeOnlineNinja : DooPlay(
     private val streamTapeExtractor by lazy { StreamTapeExtractor(client) }
     private val mixDropExtractor by lazy { MixDropExtractor(client) }
     private val uqloadExtractor by lazy { UqloadExtractor(client) }
+    private val vidHideExtractor by lazy { VidHideExtractor(client, headers) }
+    private val streamWishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
 
     private fun extractVideos(url: String, lang: String): List<Video> {
+        try {
             return when {
-            "saidochesto.top" in url || "MULTISERVER" in lang.uppercase() ->
+                arrayOf("saidochesto.top").any(url) || "MULTISERVER" in lang.uppercase() -> extractFromMulti(url)
-                extractFromMulti(url)
+                arrayOf("filemoon", "filemooon", "moon").any(url) -> filemoonExtractor.videosFromUrl(url, "$lang Filemoon:", headers)
-            "filemoon" in url ->
+                arrayOf("doodstream", "dood.", "ds2play", "doods.").any(url) -> doodExtractor.videosFromUrl(url, "$lang DoodStream", false)
-                filemoonExtractor.videosFromUrl(url, "$lang Filemoon - ", headers)
+                arrayOf("streamtape", "stp", "stape").any(url) -> streamTapeExtractor.videosFromUrl(url, "$lang StreamTape")
-            "dood" in url ->
+                arrayOf("mixdrop").any(url) -> mixDropExtractor.videoFromUrl(url, prefix = "$lang ")
-                doodExtractor.videoFromUrl(url, "$lang DoodStream", false)
+                arrayOf("uqload").any(url) -> uqloadExtractor.videosFromUrl(url, prefix = lang)
-                    ?.let(::listOf)
-            "streamtape" in url ->
-                streamTapeExtractor.videoFromUrl(url, "$lang StreamTape")
-                    ?.let(::listOf)
-            "mixdrop" in url ->
-                mixDropExtractor.videoFromUrl(url, lang)
-            "uqload" in url ->
-                uqloadExtractor.videosFromUrl(url)
                 "wolfstream" in url -> {
                     client.newCall(GET(url, headers)).execute()
                         .asJsoup()
@@ -143,9 +161,17 @@ class AnimeOnlineNinja : DooPlay(
                             listOf(Video(videoUrl, "$lang WolfStream", videoUrl, headers = headers))
                         }
                 }
+                arrayOf("mp4upload").any(url) -> mp4uploadExtractor.videosFromUrl(url, headers, prefix = "$lang ")
+                arrayOf("vidhide", "filelions.top", "vid.").any(url) -> vidHideExtractor.videosFromUrl(url) { "$lang VidHide:$it" }
+                arrayOf("wishembed", "streamwish", "strwish", "wish").any(url) -> streamWishExtractor.videosFromUrl(url, videoNameGen = { "$lang StreamWish:$it" })
                 else -> null
-        } ?: emptyList<Video>()
+            } ?: emptyList()
+        } catch (e: Exception) {
+            return emptyList()
         }
+    }
+
+    private fun Array<String>.any(url: String): Boolean = this.any { url.contains(it, ignoreCase = true) }
 
     private fun extractFromMulti(url: String): List<Video> {
         val document = client.newCall(GET(url)).execute().asJsoup()
@@ -267,6 +293,7 @@ class AnimeOnlineNinja : DooPlay(
 
     override val prefQualityValues = arrayOf("480p", "720p", "1080p")
     override val prefQualityEntries = prefQualityValues
+    override val episodeNumberRegex by lazy { Regex("""(\d+(?:\.\d+)?)$""") }
 
     companion object {
         private const val PREF_LANG_KEY = "preferred_lang"
@@ -276,7 +303,7 @@ class AnimeOnlineNinja : DooPlay(
         private const val PREF_SERVER_DEFAULT = "Uqload"
         private val PREF_LANG_ENTRIES = arrayOf("SUB", "All", "ES", "LAT")
         private val PREF_LANG_VALUES = arrayOf("SUB", "", "ES", "LAT")
-        private val SERVER_LIST = arrayOf("Filemoon", "DoodStream", "StreamTape", "MixDrop", "Uqload", "WolfStream", "saidochesto.top")
+        private val SERVER_LIST = arrayOf("Filemoon", "DoodStream", "StreamTape", "MixDrop", "Uqload", "WolfStream", "saidochesto.top", "VidHide", "StreamWish", "Mp4Upload")
 
         private const val PREF_VRF_INTERCEPT_KEY = "vrf_intercept"
         private const val PREF_VRF_INTERCEPT_TITLE = "Intercept VRF links (Requiere Reiniciar)"