fix(notifications): extra padding

app/src/main/java/ani/dantotsu/MainActivity.kt

@@ -312,6 +312,7 @@ class MainActivity : AppCompatActivity() {
             mainViewPager.adapter =
                 ViewPagerAdapter(supportFragmentManager, lifecycle)
             mainViewPager.setPageTransformer(ZoomOutPageTransformer())
+            mainViewPager.offscreenPageLimit = 1
             navbar.selectTabAt(selectedOption)
             navbar.setOnTabSelectListener(object :
                 AnimatedBottomBar.OnTabSelectListener {

app/src/main/java/ani/dantotsu/connections/anilist/AnilistQueries.kt

@@ -1055,172 +1055,110 @@ query (${"$"}page: Int = 1, ${"$"}id: Int, ${"$"}type: MediaType, ${"$"}isAdult:
         return null
     }
 
-    private val onListAnime =
+    private fun mediaList(media1: Page?): ArrayList<Media> {
-        (if (PrefManager.getVal(PrefName.IncludeAnimeList)) "" else "onList:false").replace(
+        val combinedList = arrayListOf<Media>()
-            "\"",
+        media1?.media?.mapTo(combinedList) { Media(it) }
-            ""
+        return combinedList
-        )
+    }
-    private val isAdult =
+    private fun getPreference(pref: PrefName): Boolean = PrefManager.getVal(pref)
-        (if (PrefManager.getVal(PrefName.AdultOnly)) "isAdult:true" else "").replace("\"", "")
+    private fun buildQueryString(sort: String, type: String, format: String? = null, country: String? = null): String {
+        val includeList = if (type == "ANIME" && !getPreference(PrefName.IncludeAnimeList)) "onList:false" else if (type == "MANGA" && !getPreference(PrefName.IncludeMangaList)) "onList:false" else ""
+        val isAdult = if (getPreference(PrefName.AdultOnly)) "isAdult:true" else ""
+        val formatFilter = format?.let { "format: $it, " } ?: ""
+        val countryFilter = country?.let { "countryOfOrigin: $it, " } ?: ""
+
+        return """Page(page:1,perPage:50){
+        pageInfo{hasNextPage total}
+        media(sort:$sort, type:$type, $formatFilter $countryFilter $includeList $isAdult){
+            id idMal status chapters episodes nextAiringEpisode{episode}
+            isAdult type meanScore isFavourite format bannerImage countryOfOrigin
+            coverImage{large} title{english romaji userPreferred}
+            mediaListEntry{progress private score(format:POINT_100) status}
+        }
+    }"""
+    }
 
     private fun recentAnimeUpdates(page: Int): String {
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}airingSchedules(airingAt_greater:0 airingAt_lesser:${System.currentTimeMillis() / 1000 - 10000} sort:TIME_DESC){episode airingAt media{id idMal status chapters episodes nextAiringEpisode{episode} isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large} title{english romaji userPreferred} mediaListEntry{progress private score(format:POINT_100) status}}}}"""
+        val currentTime = System.currentTimeMillis() / 1000
+        return """Page(page:$page,perPage:50){
+        pageInfo{hasNextPage total}
+        airingSchedules(airingAt_greater:0 airingAt_lesser:${currentTime - 10000} sort:TIME_DESC){
+            episode airingAt media{
+                id idMal status chapters episodes nextAiringEpisode{episode}
+                isAdult type meanScore isFavourite format bannerImage countryOfOrigin
+                coverImage{large} title{english romaji userPreferred}
+                mediaListEntry{progress private score(format:POINT_100) status}
+            }
+        }
+    }"""
     }
-
+    private fun queryAnimeList(): String {
-    private fun trendingMovies(page: Int): String {
+        return """{
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: ANIME, format: MOVIE, $onListAnime, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
+        recentUpdates:${recentAnimeUpdates(1)}
+        recentUpdates2:${recentAnimeUpdates(2)}
+        trendingMovies:${buildQueryString("POPULARITY_DESC", "ANIME", "MOVIE")}
+        topRated:${buildQueryString("SCORE_DESC", "ANIME")}
+        mostFav:${buildQueryString("FAVOURITES_DESC", "ANIME")}
+    }"""
     }
+    private fun queryMangaList(): String {
+        return """{
+        trendingManga:${buildQueryString("POPULARITY_DESC", "MANGA", country = "JP")}
+        trendingManhwa:${buildQueryString("POPULARITY_DESC", "MANGA", country = "KR")}
+        trendingNovel:${buildQueryString("POPULARITY_DESC", "MANGA", format = "NOVEL", country = "JP")}
+        topRated:${buildQueryString("SCORE_DESC", "MANGA")}
+        mostFav:${buildQueryString("FAVOURITES_DESC", "MANGA")}
  
-    private fun topRatedAnime(page: Int): String {
+    }"""
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort: SCORE_DESC, type: ANIME, $onListAnime, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
-    }
-
-    private fun mostFavAnime(page: Int): String {
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:FAVOURITES_DESC,type: ANIME, $onListAnime, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
 
     suspend fun loadAnimeList(): Map<String, ArrayList<Media>> {
         val list = mutableMapOf<String, ArrayList<Media>>()
-        fun query(): String {
+
-            return """{
+        fun filterRecentUpdates(
-                recentUpdates:${recentAnimeUpdates(1)}
+            page: Page?,
-                recentUpdates2:${recentAnimeUpdates(2)}
+        ): ArrayList<Media> {
-                trendingMovies:${trendingMovies(1)}
-                trendingMovies2:${trendingMovies(2)}
-                topRated:${topRatedAnime(1)}
-                topRated2:${topRatedAnime(2)}
-                mostFav:${mostFavAnime(1)}
-                mostFav2:${mostFavAnime(2)}
-            }""".trimIndent()
-        }
-        executeQuery<Query.AnimeList>(query(), force = true)?.data?.apply {
             val listOnly: Boolean = PrefManager.getVal(PrefName.RecentlyListOnly)
             val adultOnly: Boolean = PrefManager.getVal(PrefName.AdultOnly)
             val idArr = mutableListOf<Int>()
-            list["recentUpdates"] = recentUpdates?.airingSchedules?.mapNotNull { i ->
+            return page?.airingSchedules?.mapNotNull { i ->
                 i.media?.let {
-                    if (!idArr.contains(it.id))
+                    if (!idArr.contains(it.id)) {
-                        if (!listOnly && it.countryOfOrigin == "JP" && Anilist.adult && adultOnly && it.isAdult == true) {
+                        val shouldAdd = when {
-                            idArr.add(it.id)
+                            !listOnly && it.countryOfOrigin == "JP" && Anilist.adult && adultOnly && it.isAdult == true -> true
-                            Media(it)
+                            !listOnly && !adultOnly && it.countryOfOrigin == "JP" && it.isAdult == false -> true
-                        } else if (!listOnly && !adultOnly && (it.countryOfOrigin == "JP" && it.isAdult == false)) {
+                            listOnly && it.mediaListEntry != null -> true
-                            idArr.add(it.id)
+                            else -> false
-                            Media(it)
+                        }
-                        } else if ((listOnly && it.mediaListEntry != null)) {
+                        if (shouldAdd) {
                             idArr.add(it.id)
                             Media(it)
                         } else null
-                    else null
+                    } else null
                 }
             }?.toCollection(ArrayList()) ?: arrayListOf()
-
+        }
-            list["trendingMovies"] =
+        executeQuery<Query.AnimeList>(queryAnimeList(), force = true)?.data?.apply {
-                trendingMovies?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
+            list["recentUpdates"] = filterRecentUpdates(recentUpdates)
-            list["topRated"] =
+            list["trendingMovies"] = mediaList(trendingMovies)
-                topRated?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
+            list["topRated"] = mediaList(topRated)
-            list["mostFav"] =
+            list["mostFav"] = mediaList(mostFav)
-                mostFav?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-
-            list["recentUpdates"]?.addAll(recentUpdates2?.airingSchedules?.mapNotNull { i ->
-                i.media?.let {
-                    if (!idArr.contains(it.id))
-                        if (!listOnly && it.countryOfOrigin == "JP" && Anilist.adult && adultOnly && it.isAdult == true) {
-                            idArr.add(it.id)
-                            Media(it)
-                        } else if (!listOnly && !adultOnly && (it.countryOfOrigin == "JP" && it.isAdult == false)) {
-                            idArr.add(it.id)
-                            Media(it)
-                        } else if ((listOnly && it.mediaListEntry != null)) {
-                            idArr.add(it.id)
-                            Media(it)
-                        } else null
-                    else null
-                }
-            }?.toCollection(ArrayList()) ?: arrayListOf())
-            list["trendingMovies"]?.addAll(trendingMovies2?.media?.map { Media(it) }
-                ?.toCollection(ArrayList()) ?: arrayListOf())
-            list["topRated"]?.addAll(
-                topRated2?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-            )
-            list["mostFav"]?.addAll(
-                mostFav2?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-            )
         }
         return list
     }
-
-    private val onListManga =
-        (if (PrefManager.getVal(PrefName.IncludeMangaList)) "" else "onList:false").replace(
-            "\"",
-            ""
-        )
-
-    private fun trendingManga(page: Int): String {
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: MANGA,countryOfOrigin:JP, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
-    }
-
-    private fun trendingManhwa(page: Int): String {
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: MANGA, countryOfOrigin:KR, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
-    }
-
-    private fun trendingNovel(page: Int): String {
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: MANGA, format: NOVEL, countryOfOrigin:JP, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
-    }
-
-    private fun topRatedManga(page: Int): String {
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort: SCORE_DESC, type: MANGA, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
-    }
-
-    private fun mostFavManga(page: Int): String {
-        return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:FAVOURITES_DESC,type: MANGA, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
-    }
-
     suspend fun loadMangaList(): Map<String, ArrayList<Media>> {
         val list = mutableMapOf<String, ArrayList<Media>>()
-        fun query(): String {
+        executeQuery<Query.MangaList>(queryMangaList(), force = true)?.data?.apply {
-            return """{
+            list["trendingManga"] = mediaList(trendingManga)
-                trendingManga:${trendingManga(1)}
+            list["trendingManhwa"] = mediaList(trendingManhwa)
-                trendingManga2:${trendingManga(2)}
+            list["trendingNovel"] = mediaList(trendingNovel)
-                trendingManhwa:${trendingManhwa(1)}
+            list["topRated"] = mediaList(topRated)
-                trendingManhwa2:${trendingManhwa(2)}
+            list["mostFav"] = mediaList(mostFav)
-                trendingNovel:${trendingNovel(1)}
-                trendingNovel2:${trendingNovel(2)}
-                topRated:${topRatedManga(1)}
-                topRated2:${topRatedManga(2)}
-                mostFav:${mostFavManga(1)}
-                mostFav2:${mostFavManga(2)}
-            }""".trimIndent()
         }
-
-        executeQuery<Query.MangaList>(query(), force = true)?.data?.apply {
-            list["trendingManga"] =
-                trendingManga?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-            list["trendingManhwa"] =
-                trendingManhwa?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-            list["trendingNovel"] =
-                trendingNovel?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-            list["topRated"] =
-                topRated?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-            list["mostFav"] =
-                mostFav?.media?.map { Media(it) }?.toCollection(ArrayList()) ?: arrayListOf()
-
-            list["trendingManga"]?.addAll(
-                trendingManga2?.media?.map { Media(it) }?.toList() ?: arrayListOf()
-            )
-            list["trendingManhwa"]?.addAll(
-                trendingManhwa2?.media?.map { Media(it) }?.toList() ?: arrayListOf()
-            )
-            list["trendingNovel"]?.addAll(
-                trendingNovel2?.media?.map { Media(it) }?.toList() ?: arrayListOf()
-            )
-            list["topRated"]?.addAll(topRated2?.media?.map { Media(it) }?.toList() ?: arrayListOf())
-            list["mostFav"]?.addAll(mostFav2?.media?.map { Media(it) }?.toList() ?: arrayListOf())
-        }
-
-
         return list
     }
 
+
     suspend fun recentlyUpdated(
         greater: Long = 0,
         lesser: Long = System.currentTimeMillis() / 1000 - 10000

app/src/main/java/ani/dantotsu/connections/anilist/api/Data.kt

@@ -163,13 +163,9 @@ class Query {
         @Serializable
         data class Data(
             @SerialName("recentUpdates") val recentUpdates: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("recentUpdates2") val recentUpdates2: ani.dantotsu.connections.anilist.api.Page?,
             @SerialName("trendingMovies") val trendingMovies: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("trendingMovies2") val trendingMovies2: ani.dantotsu.connections.anilist.api.Page?,
             @SerialName("topRated") val topRated: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("topRated2") val topRated2: ani.dantotsu.connections.anilist.api.Page?,
             @SerialName("mostFav") val mostFav: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("mostFav2") val mostFav2: ani.dantotsu.connections.anilist.api.Page?,
         )
     }
 
@@ -181,15 +177,10 @@ class Query {
         @Serializable
         data class Data(
             @SerialName("trendingManga") val trendingManga: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("trendingManga2") val trendingManga2: ani.dantotsu.connections.anilist.api.Page?,
             @SerialName("trendingManhwa") val trendingManhwa: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("trendingManhwa2") val trendingManhwa2: ani.dantotsu.connections.anilist.api.Page?,
             @SerialName("trendingNovel") val trendingNovel: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("trendingNovel2") val trendingNovel2: ani.dantotsu.connections.anilist.api.Page?,
             @SerialName("topRated") val topRated: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("topRated2") val topRated2: ani.dantotsu.connections.anilist.api.Page?,
             @SerialName("mostFav") val mostFav: ani.dantotsu.connections.anilist.api.Page?,
-            @SerialName("mostFav2") val mostFav2: ani.dantotsu.connections.anilist.api.Page?,
         )
     }