fix(id/minioppai): Migrate to Animestream + add search filters (#1778)

multisrc/overrides/animestream/minioppai/additional.gradle

@@ -0,0 +1,4 @@
+dependencies {
+    implementation(project(":lib-gdriveplayer-extractor"))
+    implementation(project(":lib-unpacker"))
+}

multisrc/overrides/animestream/minioppai/src/MiniOppai.kt

@@ -0,0 +1,125 @@
+package eu.kanade.tachiyomi.animeextension.id.minioppai
+
+import eu.kanade.tachiyomi.animeextension.id.minioppai.extractors.MiniOppaiExtractor
+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.lib.gdriveplayerextractor.GdrivePlayerExtractor
+import eu.kanade.tachiyomi.multisrc.animestream.AnimeStream
+import eu.kanade.tachiyomi.network.GET
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.Request
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+class MiniOppai : AnimeStream(
+    "id",
+    "MiniOppai",
+    "https://minioppai.org",
+) {
+    override fun headersBuilder() = super.headersBuilder().add("Referer", baseUrl)
+
+    override val animeListUrl = "$baseUrl/advanced-search"
+
+    override val dateFormatter by lazy {
+        SimpleDateFormat("MMMM d, yyyy", Locale(lang))
+    }
+
+    // ============================== Popular ===============================
+    override fun popularAnimeRequest(page: Int) = GET("$animeListUrl/page/$page/?order=popular")
+
+    // =============================== Latest ===============================
+    override fun latestUpdatesRequest(page: Int) = GET("$animeListUrl/page/$page/?order=update")
+
+    // ============================== Episodes ==============================
+    override fun episodeListSelector() = "div.epsdlist > ul > li > a"
+
+    override fun episodeFromElement(element: Element): SEpisode {
+        return SEpisode.create().apply {
+            setUrlWithoutDomain(element.attr("href"))
+            element.selectFirst(".epl-num")!!.text().let {
+                val num = it.substringAfterLast(" ")
+                episode_number = num.toFloatOrNull() ?: 0F
+                name = when {
+                    it.contains("OVA", true) -> "OVA $num"
+                    else -> "Episode $num"
+                }
+            }
+            element.selectFirst(".epl-sub")?.text()?.let { scanlator = it }
+            date_upload = element.selectFirst(".epl-date")?.text().toDate()
+        }
+    }
+
+    // ============================ Video Links =============================
+    override fun getVideoList(url: String, name: String): List<Video> {
+        return when {
+            "gdriveplayer" in url -> {
+                val playerUrl = buildString {
+                    val data = url.toHttpUrl().queryParameter("data")
+                        ?: return emptyList()
+                    if (data.startsWith("//")) append("https:")
+                    append(data)
+                }
+                GdrivePlayerExtractor(client).videosFromUrl(playerUrl, name, headers)
+            }
+            "paistream.my.id" in url ->
+                MiniOppaiExtractor(client).videosFromUrl(url, headers)
+            else -> emptyList()
+        }
+    }
+
+    // =========================== Anime Details ============================
+    override fun getAnimeDescription(document: Document) =
+        document.select("div.entry-content > p").eachText().joinToString("\n")
+
+    override fun animeDetailsParse(document: Document) = super.animeDetailsParse(document).apply {
+        title = title.substringBefore("Episode").substringBefore(" OVA ")
+    }
+
+    // =============================== Search ===============================
+    override fun searchAnimeSelector() = "div.latest article a.tip"
+
+    override fun searchAnimeFromElement(element: Element): SAnime {
+        return SAnime.create().apply {
+            setUrlWithoutDomain(element.attr("href"))
+            title = element.selectFirst("h2.entry-title")!!.ownText()
+            thumbnail_url = element.selectFirst("img")!!.getImageUrl()
+        }
+    }
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val params = MiniOppaiFilters.getSearchParameters(filters)
+        return if (query.isNotEmpty()) {
+            GET("$baseUrl/page/$page/?s=$query")
+        } else {
+            val multiString = listOf(
+                params.genres,
+                params.countries,
+                params.qualities,
+                params.year,
+                params.status,
+            ).filter(String::isNotBlank).joinToString("&").let {
+                when {
+                    it.isBlank() -> it
+                    else -> "&$it"
+                }
+            }
+
+            GET("$animeListUrl/page/$page/?order=${params.order}$multiString")
+        }
+    }
+
+    // ============================== Filters ===============================
+    override val fetchFilters = false
+    override fun getFilterList() = MiniOppaiFilters.FILTER_LIST
+
+    // ============================= Utilities ==============================
+    override fun Element.getInfo(text: String): String? {
+        return selectFirst("li:has(b:contains($text))")
+            ?.selectFirst("span.colspan")
+            ?.text()
+    }
+}

multisrc/overrides/animestream/minioppai/src/MiniOppaiFilters.kt

@@ -0,0 +1,202 @@
+package eu.kanade.tachiyomi.animeextension.id.minioppai
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.multisrc.animestream.AnimeStreamFilters.CheckBoxFilterList
+import eu.kanade.tachiyomi.multisrc.animestream.AnimeStreamFilters.QueryPartFilter
+
+object MiniOppaiFilters {
+    private inline fun <reified R> AnimeFilterList.asQueryPart(): String {
+        return (getFirst<R>() as QueryPartFilter).toQueryPart()
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return first { it is R } as R
+    }
+
+    private inline fun <reified R> AnimeFilterList.parseCheckbox(
+        options: Array<Pair<String, String>>,
+        name: String,
+    ): String {
+        return (getFirst<R>() as CheckBoxFilterList).state
+            .filter { it.state }
+            .map { checkbox -> options.find { it.first == checkbox.name }!!.second }
+            .filter(String::isNotBlank)
+            .joinToString("&") { "$name[]=$it" }
+    }
+
+    class OrderFilter : QueryPartFilter("Order", MiniOppaiFiltersData.ORDER_LIST)
+
+    class GenresFilter : CheckBoxFilterList("Genres", MiniOppaiFiltersData.GENRES_LIST)
+    class CountriesFilter : CheckBoxFilterList("Countries", MiniOppaiFiltersData.COUNTRIES_LIST)
+    class QualitiesFilter : CheckBoxFilterList("Qualities", MiniOppaiFiltersData.QUALITIES_LIST)
+    class YearsFilter : CheckBoxFilterList("Years", MiniOppaiFiltersData.YEARS_LIST)
+    class StatusFilter : CheckBoxFilterList("Status", MiniOppaiFiltersData.STATUS_LIST)
+
+    val FILTER_LIST get() = AnimeFilterList(
+        OrderFilter(),
+        GenresFilter(),
+        CountriesFilter(),
+        QualitiesFilter(),
+        YearsFilter(),
+        StatusFilter(),
+    )
+
+    data class FilterSearchParams(
+        val order: String = "",
+        val genres: String = "",
+        val countries: String = "",
+        val qualities: String = "",
+        val year: String = "",
+        val status: String = "",
+    )
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+
+        return FilterSearchParams(
+            filters.asQueryPart<OrderFilter>(),
+            filters.parseCheckbox<GenresFilter>(MiniOppaiFiltersData.GENRES_LIST, "genre"),
+            filters.parseCheckbox<CountriesFilter>(MiniOppaiFiltersData.COUNTRIES_LIST, "country"),
+            filters.parseCheckbox<QualitiesFilter>(MiniOppaiFiltersData.QUALITIES_LIST, "quality"),
+            filters.parseCheckbox<YearsFilter>(MiniOppaiFiltersData.YEARS_LIST, "years"),
+            filters.parseCheckbox<StatusFilter>(MiniOppaiFiltersData.STATUS_LIST, "status"),
+        )
+    }
+
+    private object MiniOppaiFiltersData {
+        val ORDER_LIST = arrayOf(
+            Pair("Release date", "added"),
+            Pair("IMDb", "imdb"),
+            Pair("Latest", "latest"),
+            Pair("Most viewed", "popular"),
+            Pair("Name", "title"),
+        )
+
+        val GENRES_LIST = arrayOf(
+            Pair("3D Hentai", "3d-hentai"),
+            Pair("Action", "action"),
+            Pair("Adventure", "adventure"),
+            Pair("Ahegao", "ahegao"),
+            Pair("Anal", "anal"),
+            Pair("Armpit", "armpit"),
+            Pair("Ashikoki", "ashikoki"),
+            Pair("BDSM", "bdsm"),
+            Pair("Big Oppai", "big-oppai"),
+            Pair("Blowjob", "blowjob"),
+            Pair("Bondage", "bondage"),
+            Pair("Censored", "censored"),
+            Pair("Cheating", "cheating"),
+            Pair("Chikan", "chikan"),
+            Pair("Comedy", "comedy"),
+            Pair("Cosplay", "cosplay"),
+            Pair("Creampie", "creampie"),
+            Pair("Crime", "crime"),
+            Pair("Dark Skin", "dark-skin"),
+            Pair("Demons", "demons"),
+            Pair("Doctor", "doctor"),
+            Pair("Domination", "domination"),
+            Pair("Drama", "drama"),
+            Pair("Ecchi", "ecchi"),
+            Pair("Elf", "elf"),
+            Pair("Eroge", "eroge"),
+            Pair("Exhibitionist", "exhibitionist"),
+            Pair("Facial", "facial"),
+            Pair("Fantasy", "fantasy"),
+            Pair("Fellatio", "fellatio"),
+            Pair("Female Monster", "female-monster"),
+            Pair("Femdom", "femdom"),
+            Pair("Fetish", "fetish"),
+            Pair("Footjob", "footjob"),
+            Pair("Forced", "forced"),
+            Pair("Futanari", "futanari"),
+            Pair("Gal", "gal"),
+            Pair("Gangbang", "gangbang"),
+            Pair("Group", "group"),
+            Pair("Harem", "harem"),
+            Pair("Historical", "historical"),
+            Pair("Housewife", "housewife"),
+            Pair("Humiliation", "humiliation"),
+            Pair("Idol", "idol"),
+            Pair("Incest", "incest"),
+            Pair("Intercrural", "intercrural"),
+            Pair("Josei", "josei"),
+            Pair("Kemonomimi", "kemonomimi"),
+            Pair("Kimono", "kimono"),
+            Pair("Lactation", "lactation"),
+            Pair("Lingerie", "lingerie"),
+            Pair("MILF", "milf"),
+            Pair("Magic", "magic"),
+            Pair("Maid", "maid"),
+            Pair("Male Monster", "male-monster"),
+            Pair("Martial Arts", "martial-arts"),
+            Pair("Masturbation", "masturbation"),
+            Pair("Mecha", "mecha"),
+            Pair("Megane", "megane"),
+            Pair("Mind Control", "mind-control"),
+            Pair("Mizugi", "mizugi"),
+            Pair("Monster", "monster"),
+            Pair("Mystery", "mystery"),
+            Pair("Neko", "neko"),
+            Pair("Netorare", "netorare"),
+            Pair("Nurse", "nurse"),
+            Pair("Office", "office"),
+            Pair("Onee-san", "onee-san"),
+            Pair("Onsen", "onsen"),
+            Pair("Oppai", "oppai"),
+            Pair("Oral", "oral"),
+            Pair("Osananajimi", "osananajimi"),
+            Pair("Outdoor", "outdoor"),
+            Pair("Paizuri", "paizuri"),
+            Pair("Pantyhose", "pantyhose"),
+            Pair("Pantyhouse", "pantyhouse"),
+            Pair("Parody", "parody"),
+            Pair("Pregnant", "pregnant"),
+            Pair("Prostitution", "prostitution"),
+            Pair("Rape", "rape"),
+            Pair("Romance", "romance"),
+            Pair("School", "school"),
+            Pair("Schoolgirl", "schoolgirl"),
+            Pair("Seinen", "seinen"),
+            Pair("Sex Toys", "sex-toys"),
+            Pair("Shibari", "shibari"),
+            Pair("Shota", "shota"),
+            Pair("Shoujo", "shoujo"),
+            Pair("Shounen", "shounen"),
+            Pair("Stocking", "stocking"),
+            Pair("Succubus", "succubus"),
+            Pair("Supernatural", "supernatural"),
+            Pair("Swimsuit", "swimsuit"),
+            Pair("Teacher", "teacher"),
+            Pair("Tennis", "tennis"),
+            Pair("Tentacles", "tentacles"),
+            Pair("Threesome", "threesome"),
+            Pair("Tsundere", "tsundere"),
+            Pair("Uncensored", "uncensored"),
+            Pair("stock", "stock"),
+        )
+
+        val COUNTRIES_LIST = arrayOf(
+            Pair("JP", "jp"),
+            Pair("TH", "th"),
+        )
+
+        val QUALITIES_LIST = arrayOf(
+            Pair("BD", "bd"),
+            Pair("Censored", "censored"),
+            Pair("HD", "hd"),
+            Pair("TV", "tv"),
+            Pair("Uncensored", "uncensored"),
+            Pair("Web", "web"),
+        )
+
+        val YEARS_LIST = (2023 downTo 2001).map {
+            Pair(it.toString(), it.toString())
+        }.toTypedArray()
+
+        val STATUS_LIST = arrayOf(
+            Pair("Completed", "completed"),
+            Pair("Dropped", "dropped"),
+            Pair("Ongoing", "ongoing"),
+        )
+    }
+}

multisrc/overrides/animestream/minioppai/src/extractors/MiniOppaiExtractor.kt

@@ -0,0 +1,51 @@
+package eu.kanade.tachiyomi.animeextension.id.minioppai.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Track
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.unpacker.Unpacker
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+
+class MiniOppaiExtractor(private val client: OkHttpClient) {
+    fun videosFromUrl(url: String, headers: Headers): List<Video> {
+        val playerDoc = client.newCall(GET(url, headers)).execute().asJsoup()
+        val scriptData = playerDoc.selectFirst("script:containsData(eval):containsData(p,a,c,k,e,d)")
+            ?.data()
+            ?.let(Unpacker::unpack)
+            ?.takeIf(String::isNotBlank)
+            ?: return emptyList()
+
+        val baseUrl = "https://" + url.substringAfter("//").substringBefore("/")
+
+        val subs = scriptData.getItems("\"tracks\"", baseUrl) { subUrl, label ->
+            Track(subUrl, label)
+        }
+
+        return scriptData.getItems("sources", baseUrl) { videoUrl, quality ->
+            val videoQuality = "MiniOppai - $quality"
+            Video(videoUrl, videoQuality, videoUrl, headers, subtitleTracks = subs)
+        }
+    }
+
+    // time to over-engineer things for no reason at all
+    private fun <T> String.getItems(key: String, baseUrl: String, transformer: (String, String) -> T): List<T> {
+        return substringAfter("$key:[").substringBefore("]")
+            .split("{")
+            .drop(1)
+            .map {
+                val url = "$baseUrl${it.extractKey("file")}"
+                val label = it.extractKey("label")
+                transformer(url, label)
+            }
+    }
+
+    private fun String.extractKey(key: String) =
+        substringAfter(key)
+            .substringBefore("}")
+            .substringBefore(",")
+            .substringAfter(":")
+            .trim('"')
+            .trim('\'')
+}

multisrc/src/main/java/eu/kanade/tachiyomi/multisrc/animestream/AnimeStreamGenerator.kt

@@ -15,6 +15,7 @@ class AnimeStreamGenerator : ThemeSourceGenerator {
         SingleLang("LMAnime", "https://lmanime.com", "all", isNsfw = false, overrideVersionCode = 2),
         SingleLang("RineCloud", "https://rine.cloud", "pt-BR", isNsfw = false),
         SingleLang("Animenosub", "https://animenosub.com", "en", isNsfw = true),
+        SingleLang("MiniOppai", "https://minioppai.org", "id", isNsfw = true, overrideVersionCode = 2),
         SingleLang("AnimeKhor", "https://animekhor.xyz", "en", isNsfw = false),
         SingleLang("AnimeTitans", "https://animetitans.com", "ar", isNsfw = false, overrideVersionCode = 11),
     )

src/id/minioppai/AndroidManifest.xml

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

src/id/minioppai/build.gradle

@@ -1,13 +0,0 @@
-apply plugin: 'com.android.application'
-apply plugin: 'kotlin-android'
-
-ext {
-    extName = 'MiniOppai'
-    pkgNameSuffix = 'id.minioppai'
-    extClass = '.MiniOppai'
-    extVersionCode = 3
-    libVersion = '13'
-    containsNsfw = true
-}
-
-apply from: "$rootDir/common.gradle"

src/id/minioppai/src/eu/kanade/tachiyomi/animeextension/id/minioppai/MiniOppai.kt

@@ -1,185 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.id.minioppai
-
-import android.app.Application
-import android.content.SharedPreferences
-import androidx.preference.ListPreference
-import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-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.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 java.lang.Exception
-import java.net.URLDecoder
-import java.util.Locale
-
-class MiniOppai : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
-    override val baseUrl: String = "https://minioppai.org"
-    override val lang: String = "id"
-    override val name: String = "MiniOppai"
-    override val supportsLatest: Boolean = true
-
-    private val preferences: SharedPreferences by lazy {
-        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
-    }
-
-    override fun animeDetailsParse(document: Document): SAnime {
-        val anime = SAnime.create()
-        val infox = document.select("div.infox")
-        val status = parseStatus(infox.select("div.spe > span:nth-child(2)").text().replace("Status: ", ""))
-        anime.title = infox.select("div.infox > h1").text().replace("Judul: ", "")
-        anime.genre = infox.select("div.spe > span:nth-child(1)").joinToString(", ") { it.text() }
-        anime.status = status
-        anime.artist = infox.select("div.spe > span:nth-child(3)").text().replace("Studio: ", "")
-        anime.author = "UNKNOWN"
-        anime.description = "Synopsis: \n" + document.select("div.desc > div > span").text()
-        return anime
-    }
-
-    private fun parseStatus(statusString: String): Int {
-        return when (statusString.toLowerCase(Locale.US)) {
-            "ongoing" -> SAnime.ONGOING
-            "completed" -> SAnime.COMPLETED
-            else -> SAnime.UNKNOWN
-        }
-    }
-
-    override fun episodeFromElement(element: Element): SEpisode {
-        val episode = SEpisode.create()
-        val epsNum = getNumberFromEpsString(element.select("span.lchx").text())
-        episode.setUrlWithoutDomain(element.selectFirst("a")!!.attr("href"))
-        episode.episode_number = when {
-            (epsNum.isNotEmpty()) -> epsNum.toFloat()
-            else -> 1F
-        }
-        episode.name = element.select("span.lchx").text()
-
-        return episode
-    }
-
-    private fun getNumberFromEpsString(epsStr: String): String {
-        return epsStr.filter { it.isDigit() }
-    }
-
-    override fun episodeListSelector(): String = "div.bixbox.bxcl > ul > li"
-
-    override fun latestUpdatesFromElement(element: Element): SAnime = getAnimeFromAnimeElement(element)
-
-    private fun getAnimeFromAnimeElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.setUrlWithoutDomain(element.selectFirst("div > a")!!.attr("href"))
-        anime.thumbnail_url = element.selectFirst("img")!!.attr("data-src")
-        anime.title = element.select("div > a > div.tt").text()
-        return anime
-    }
-    override fun latestUpdatesNextPageSelector(): String = "div.pagination > a.next"
-
-    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/anime/?page=$page&status=ongoing&sub=&order=update")
-
-    override fun latestUpdatesSelector(): String = "div.listupd > div"
-
-    override fun popularAnimeFromElement(element: Element): SAnime = getAnimeFromAnimeElement(element)
-
-    override fun popularAnimeNextPageSelector(): String = "div.pagination > a.next"
-
-    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/anime/?page=$page")
-
-    override fun popularAnimeSelector(): String = "div.listupd > div"
-
-    override fun searchAnimeFromElement(element: Element): SAnime = getAnimeFromAnimeElement(element)
-
-    override fun searchAnimeNextPageSelector(): String = "a.next.page-numbers"
-
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        // filter and stuff in v2
-        return GET("$baseUrl/page/$page/?s=$query")
-    }
-
-    override fun searchAnimeSelector(): String = "div.listupd > div"
-
-    override fun videoListParse(response: Response): List<Video> {
-        val document = response.asJsoup()
-        val patternZippy = "div.bixbox.mctn > div.soraddlx > div.dlmx > a:contains(zippy)"
-
-        val zippy = document.select(patternZippy).mapNotNull {
-            runCatching { zippyFromElement(it) }.getOrNull()
-        }
-
-        return zippy
-    }
-
-    override fun videoFromElement(element: Element): Video = throw Exception("not used")
-
-    private fun zippyFromElement(element: Element): Video {
-        val zipurl = URLDecoder.decode(element.attr("href"), "UTF-8").substringAfter("?s=")
-        val res = client.newCall(GET(zipurl)).execute().asJsoup()
-        val scr = res.select("script:containsData(dlbutton)").html()
-        var url = zipurl.substringBefore("/v/")
-        val numbs = scr.substringAfter("\" + (").substringBefore(") + \"")
-        val firstString = scr.substringAfter(" = \"").substringBefore("\" + (")
-        val num = numbs.substringBefore(" % ").toInt()
-        val lastString = scr.substringAfter("913) + \"").substringBefore("\";")
-        val nums = num % 51245 + num % 913
-        url += firstString + nums.toString() + lastString
-        val quality = with(lastString) {
-            when {
-                contains("1080p") -> "ZippyShare - 1080p"
-                contains("720p") -> "ZippyShare - 720p"
-                contains("480p") -> "ZippyShare - 480p"
-                contains("360p") -> "ZippyShare - 360p"
-                else -> "ZippyShare - Unknown Resolution"
-            }
-        }
-        return Video(url, quality, url)
-    }
-
-    override fun videoListSelector(): String = throw Exception("not used")
-
-    override fun videoUrlParse(document: Document) = 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 setupPreferenceScreen(screen: PreferenceScreen) {
-        val videoQualityPref = ListPreference(screen.context).apply {
-            key = "preferred_quality"
-            title = "Preferred quality"
-            entries = arrayOf("1080p", "720p", "480p", "360p")
-            entryValues = arrayOf("1080", "720", "480", "360")
-            setDefaultValue("1080")
-            summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
-        }
-        screen.addPreference(videoQualityPref)
-    }
-}