add english extension: Animerush (#1126)

one last extension before new year

src/en/animerush/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="eu.kanade.tachiyomi.animeextension" />

src/en/animerush/build.gradle

@@ -0,0 +1,12 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+
+ext {
+    extName = 'Animerush'
+    pkgNameSuffix = 'en.animerush'
+    extClass = '.Animerush'
+    extVersionCode = 1
+    libVersion = '13'
+}
+
+apply from: "$rootDir/common.gradle"

src/en/animerush/src/eu/kanade/tachiyomi/animeextension/en/animerush/Animerush.kt

@@ -0,0 +1,236 @@
+package eu.kanade.tachiyomi.animeextension.en.animerush
+
+import android.app.Application
+import android.content.SharedPreferences
+import android.os.Build
+import android.text.Html
+import androidx.annotation.RequiresApi
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+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.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import kotlin.Exception
+
+class Animerush : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+
+    override val name = "Animerush"
+
+    override val baseUrl = "https://www.animerush.tv"
+
+    override val lang = "en"
+
+    override val supportsLatest = false
+
+    override val client: OkHttpClient = network.cloudflareClient
+
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    // Popular Anime
+
+    override fun popularAnimeSelector(): String = "div#popular ul li a"
+
+    override fun popularAnimeRequest(page: Int): Request = GET(baseUrl)
+
+    override fun popularAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+        anime.setUrlWithoutDomain(element.attr("href"))
+        anime.title = element.select("img").attr("title")
+        anime.thumbnail_url = baseUrl + element.select("img").attr("src")
+        return anime
+    }
+
+    override fun popularAnimeNextPageSelector(): String? = null
+
+    // Episodes
+
+    override fun episodeListSelector() = throw Exception("not used")
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val document = response.asJsoup()
+        val episodeList = mutableListOf<SEpisode>()
+        val epElements = document.select("div.desc_box_mid div.episode_list")
+        epElements.forEach {
+            val episode = episodeFromElement(it)
+            episodeList.add(episode)
+        }
+        return episodeList
+    }
+
+    override fun episodeFromElement(element: Element): SEpisode {
+        val episode = SEpisode.create()
+        episode.episode_number = element.select("a.fixedLinkColor").attr("title").substringAfter("Episode ").toFloat()
+        episode.name = element.select("a.fixedLinkColor").attr("title")
+        episode.setUrlWithoutDomain(element.select("a.fixedLinkColor").attr("href"))
+        return episode
+    }
+
+    // Video urls
+
+    @RequiresApi(Build.VERSION_CODES.N)
+    override fun videoListParse(response: Response): List<Video> {
+        val document = response.asJsoup()
+        val videoList = mutableListOf<Video>()
+        val episodes = document.select("div#episodes div.episode1")
+        episodes.forEach {
+            val quality = it.select("h3 a").text()
+            val epurl = "https:" + it.select("h3 a").attr("href")
+            val epdoc = client.newCall(GET(epurl)).execute().asJsoup()
+            val urlenc = epdoc.select("div#embed_holder iframe").attr("src")
+            val urldec = Html.fromHtml(urlenc, 1).toString()
+            val emdoc = client.newCall(GET(urldec)).execute().asJsoup().toString()
+            val script = emdoc.substringAfter("eval(function").substringBefore("</script>")
+            val videoUrlstring = JsUnpacker("eval(function$script").unpack().toString()
+            when {
+
+                videoUrlstring.contains("player.src") -> {
+                    val videoUrl = videoUrlstring.substringAfter("player.src(\"").substringBefore("\")")
+                    val videoHeaders = Headers.headersOf("Referer", "https://www.mp4upload.com/", "Accept", "video/webm,video/ogg,video/*;q=0.9,application/ogg;q=0.7,audio/*;q=0.6,*/*;q=0.5")
+                    val video = Video(videoUrl, quality, videoUrl, headers = videoHeaders)
+                    videoList.add(video)
+                }
+                videoUrlstring.contains("MDCore.wurl") -> {
+                    val videoUrl = "https:" + videoUrlstring.substringAfter("MDCore.wurl=\"").substringBefore("\";")
+                    val videoHeaders = Headers.headersOf("Referer", "https://mixdrop.co/", "Accept", "video/webm,video/ogg,video/*;q=0.9,application/ogg;q=0.7,audio/*;q=0.6,*/*;q=0.5", "origin", "https://mixdrop.co")
+                    val video = Video(videoUrl, quality, videoUrl, headers = videoHeaders)
+                    videoList.add(video)
+                }
+            }
+        }
+        return videoList
+    }
+
+    override fun videoListSelector() = throw Exception("not Used")
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString("preferred_quality", null)
+        if (quality != null) {
+            val newList = mutableListOf<Video>()
+            var preferred = 0
+            for (video in this) {
+                if (video.quality.contains(quality)) {
+                    newList.add(preferred, video)
+                    preferred++
+                } else {
+                    newList.add(video)
+                }
+            }
+            return newList
+        }
+        return this
+    }
+
+    override fun videoFromElement(element: Element) = throw Exception("not used")
+
+    override fun videoUrlParse(document: Document) = throw Exception("not used")
+
+    // search
+
+    override fun searchAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+        anime.setUrlWithoutDomain(element.select("a.highlightit, div.genre_title a").attr("href"))
+        anime.title = element.select("a.highlightit h3, div.genre_title a").text()
+        anime.thumbnail_url = "https:" + element.select("a.highlightit object, object").attr("data")
+        return anime
+    }
+
+    override fun searchAnimeNextPageSelector(): String? = null
+
+    override fun searchAnimeSelector(): String = "div#left-column div.search-page_in_box_mid_link"
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        return if (query.isNotBlank()) {
+            GET("$baseUrl/search.php?searchquery=$query")
+        } else {
+            val url = "$baseUrl/genres/".toHttpUrlOrNull()!!.newBuilder()
+            filters.forEach { filter ->
+                when (filter) {
+                    is GenreFilter -> url.addPathSegment(filter.toUriPart())
+                    else -> {}
+                }
+            }
+            GET(url.toString())
+        }
+    }
+
+    // Details
+
+    override fun animeDetailsParse(document: Document): SAnime {
+        val anime = SAnime.create()
+        anime.title = document.select("div.amin_week_box_up1 h1").text()
+        anime.genre = document.select("div.cat_box_desc a").joinToString(", ") { it.text() }
+        anime.status = parseStatus(document.select("div.cat_box_desc ").toString().substringAfter("Status:</h3>").substringBefore("<br>")) // span.Qlty
+        anime.description = document.select("div.cat_box_desc div[align]").text()
+        return anime
+    }
+
+    private fun parseStatus(status: String?) = when {
+        status == null -> SAnime.UNKNOWN
+        status.contains("On-Going", ignoreCase = true) -> SAnime.ONGOING
+        else -> SAnime.COMPLETED
+    }
+
+    // Latest
+
+    override fun latestUpdatesNextPageSelector(): String = throw Exception("Not used")
+
+    override fun latestUpdatesFromElement(element: Element): SAnime = throw Exception("Not used")
+
+    override fun latestUpdatesRequest(page: Int): Request = throw Exception("Not used")
+
+    override fun latestUpdatesSelector(): String = throw Exception("Not used")
+
+    // Filters
+
+    override fun getFilterList() = AnimeFilterList(
+        AnimeFilter.Header("NOTE: Ignored if using text search!"),
+        AnimeFilter.Separator(),
+        GenreFilter(getGenreList())
+    )
+
+    private class GenreFilter(vals: Array<Pair<String, String>>) : UriPartFilter("Genres", vals)
+
+    private fun getGenreList() = arrayOf(
+        Pair("Action", "Action"),
+        Pair("Adventure", "Adventure"),
+        Pair("Comedy", "Comedy"),
+        Pair("Crime", "Crime"),
+        Pair("Drama", "Drama"),
+        Pair("Family", "Family"),
+        Pair("Fantasy", "Fantasy"),
+        Pair("History", "History"),
+        Pair("Horror", "Horror"),
+        Pair("Kids", "Kids"),
+        Pair("Music", "Music"),
+        Pair("Mystery", "Mystery"),
+        Pair("Romance", "Romance"),
+        Pair("Sci-Fi", "Sci-Fi"),
+        Pair("Science Fiction", "Science Fiction"),
+        Pair("Thriller", "Thriller"),
+    )
+
+    open class UriPartFilter(displayName: String, private val vals: Array<Pair<String, String>>) :
+        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
+        fun toUriPart() = vals[state].second
+    }
+
+    // settings
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {}
+}

src/en/animerush/src/eu/kanade/tachiyomi/animeextension/en/animerush/JsUnpacker.kt

@@ -0,0 +1,214 @@
+package eu.kanade.tachiyomi.animeextension.en.animerush
+
+import java.util.regex.Pattern
+import kotlin.math.pow
+
+// https://github.com/cylonu87/JsUnpacker
+class JsUnpacker(packedJS: String?) {
+    private var packedJS: String? = null
+
+    /**
+     * Detects whether the javascript is P.A.C.K.E.R. coded.
+     *
+     * @return true if it's P.A.C.K.E.R. coded.
+     */
+    fun detect(): Boolean {
+        val js = packedJS!!.replace(" ", "")
+        val p = Pattern.compile("eval\\(function\\(p,a,c,k,e,[rd]")
+        val m = p.matcher(js)
+        return m.find()
+    }
+
+    /**
+     * Unpack the javascript
+     *
+     * @return the javascript unpacked or null.
+     */
+    fun unpack(): String? {
+        val js = packedJS
+        try {
+            var p =
+                Pattern.compile("""\}\s*\('(.*)',\s*(.*?),\s*(\d+),\s*'(.*?)'\.split\('\|'\)""", Pattern.DOTALL)
+            var m = p.matcher(js)
+            if (m.find() && m.groupCount() == 4) {
+                val payload = m.group(1).replace("\\'", "'")
+                val radixStr = m.group(2)
+                val countStr = m.group(3)
+                val symtab = m.group(4).split("\\|".toRegex()).toTypedArray()
+                var radix = 36
+                var count = 0
+                try {
+                    radix = radixStr.toInt()
+                } catch (e: Exception) {
+                }
+                try {
+                    count = countStr.toInt()
+                } catch (e: Exception) {
+                }
+                if (symtab.size != count) {
+                    throw Exception("Unknown p.a.c.k.e.r. encoding")
+                }
+                val unbase = Unbase(radix)
+                p = Pattern.compile("\\b\\w+\\b")
+                m = p.matcher(payload)
+                val decoded = StringBuilder(payload)
+                var replaceOffset = 0
+                while (m.find()) {
+                    val word = m.group(0)
+                    val x = unbase.unbase(word)
+                    var value: String? = null
+                    if (x < symtab.size && x >= 0) {
+                        value = symtab[x]
+                    }
+                    if (value != null && value.isNotEmpty()) {
+                        decoded.replace(m.start() + replaceOffset, m.end() + replaceOffset, value)
+                        replaceOffset += value.length - word.length
+                    }
+                }
+                return decoded.toString()
+            }
+        } catch (e: Exception) {
+        }
+        return null
+    }
+
+    private inner class Unbase(private val radix: Int) {
+        private val ALPHABET_62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        private val ALPHABET_95 =
+            " !\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+        private var alphabet: String? = null
+        private var dictionary: HashMap<String, Int>? = null
+        fun unbase(str: String): Int {
+            var ret = 0
+            if (alphabet == null) {
+                ret = str.toInt(radix)
+            } else {
+                val tmp = StringBuilder(str).reverse().toString()
+                for (i in tmp.indices) {
+                    ret += (radix.toDouble().pow(i.toDouble()) * dictionary!![tmp.substring(i, i + 1)]!!).toInt()
+                }
+            }
+            return ret
+        }
+
+        init {
+            if (radix > 36) {
+                when {
+                    radix < 62 -> {
+                        alphabet = ALPHABET_62.substring(0, radix)
+                    }
+                    radix in 63..94 -> {
+                        alphabet = ALPHABET_95.substring(0, radix)
+                    }
+                    radix == 62 -> {
+                        alphabet = ALPHABET_62
+                    }
+                    radix == 95 -> {
+                        alphabet = ALPHABET_95
+                    }
+                }
+                dictionary = HashMap(95)
+                for (i in 0 until alphabet!!.length) {
+                    dictionary!![alphabet!!.substring(i, i + 1)] = i
+                }
+            }
+        }
+    }
+
+    /**
+     * @param packedJS javascript P.A.C.K.E.R. coded.
+     */
+    init {
+        this.packedJS = packedJS
+    }
+
+    companion object {
+        val c =
+            listOf(
+                0x63,
+                0x6f,
+                0x6d,
+                0x2e,
+                0x67,
+                0x6f,
+                0x6f,
+                0x67,
+                0x6c,
+                0x65,
+                0x2e,
+                0x61,
+                0x6e,
+                0x64,
+                0x72,
+                0x6f,
+                0x69,
+                0x64,
+                0x2e,
+                0x67,
+                0x6d,
+                0x73,
+                0x2e,
+                0x61,
+                0x64,
+                0x73,
+                0x2e,
+                0x4d,
+                0x6f,
+                0x62,
+                0x69,
+                0x6c,
+                0x65,
+                0x41,
+                0x64,
+                0x73
+            )
+        val z =
+            listOf(
+                0x63,
+                0x6f,
+                0x6d,
+                0x2e,
+                0x66,
+                0x61,
+                0x63,
+                0x65,
+                0x62,
+                0x6f,
+                0x6f,
+                0x6b,
+                0x2e,
+                0x61,
+                0x64,
+                0x73,
+                0x2e,
+                0x41,
+                0x64
+            )
+
+        fun String.load(): String? {
+            return try {
+                var load = this
+
+                for (q in c.indices) {
+                    if (c[q % 4] > 270) {
+                        load += c[q % 3]
+                    } else {
+                        load += c[q].toChar()
+                    }
+                }
+
+                Class.forName(load.substring(load.length - c.size, load.length)).name
+            } catch (_: Exception) {
+                try {
+                    var f = c[2].toChar().toString()
+                    for (w in z.indices) {
+                        f += z[w].toChar()
+                    }
+                    return Class.forName(f.substring(0b001, f.length)).name
+                } catch (_: Exception) {
+                    null
+                }
+            }
+        }
+    }
+}