Remove dependency injection from core module and data module from presentation-widget module

Includes side effects:
- No longer need to restart app for user agent string change to take effect
- parseAs extension function requires a Json instance in the calling context, which doesn't necessarily need to be the default one provided by Injekt

app/build.gradle.kts

@@ -283,6 +283,7 @@ tasks {
     // See https://kotlinlang.org/docs/reference/experimental.html#experimental-status-of-experimental-api(-markers)
     withType<KotlinCompile> {
         kotlinOptions.freeCompilerArgs += listOf(
+            "-Xcontext-receivers",
             "-opt-in=coil.annotation.ExperimentalCoilApi",
             "-opt-in=com.google.accompanist.permissions.ExperimentalPermissionsApi",
             "-opt-in=androidx.compose.foundation.layout.ExperimentalLayoutApi",

app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsAdvancedScreen.kt

@@ -222,7 +222,7 @@ object SettingsAdvancedScreen : SearchableSettings {
                 Preference.PreferenceItem.TextPreference(
                     title = stringResource(R.string.pref_clear_cookies),
                     onClick = {
-                        networkHelper.cookieManager.removeAll()
+                        networkHelper.cookieJar.removeAll()
                         context.toast(R.string.cookies_cleared)
                     },
                 ),
@@ -280,7 +280,6 @@ object SettingsAdvancedScreen : SearchableSettings {
                             context.toast(R.string.error_user_agent_string_invalid)
                             return@EditTextPreference false
                         }
-                        context.toast(R.string.requires_app_restart)
                         true
                     },
                 ),

app/src/main/java/eu/kanade/tachiyomi/AppModule.kt

@@ -118,7 +118,7 @@ class AppModule(val app: Application) : InjektModule {
         addSingletonFactory { ChapterCache(app) }
         addSingletonFactory { CoverCache(app) }
 
-        addSingletonFactory { NetworkHelper(app) }
+        addSingletonFactory { NetworkHelper(app, get()) }
         addSingletonFactory { JavaScriptEngine(app) }
 
         addSingletonFactory { SourceManager(app, get(), get()) }

app/src/main/java/eu/kanade/tachiyomi/data/track/anilist/AnilistApi.kt

@@ -9,6 +9,7 @@ import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.interceptor.rateLimit
 import eu.kanade.tachiyomi.network.jsonMime
 import eu.kanade.tachiyomi.network.parseAs
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.buildJsonObject
@@ -24,11 +25,14 @@ import kotlinx.serialization.json.putJsonObject
 import okhttp3.OkHttpClient
 import okhttp3.RequestBody.Companion.toRequestBody
 import tachiyomi.core.util.lang.withIOContext
+import uy.kohesive.injekt.injectLazy
 import java.util.Calendar
 import java.util.concurrent.TimeUnit
 
 class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
 
+    private val json: Json by injectLazy()
+
     private val authClient = client.newBuilder()
         .addInterceptor(interceptor)
         .rateLimit(permits = 85, period = 1, unit = TimeUnit.MINUTES)
@@ -53,6 +57,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
                     put("status", track.toAnilistStatus())
                 }
             }
+            with(json) {
                 authClient.newCall(
                     POST(
                         apiUrl,
@@ -68,6 +73,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
                     }
             }
         }
+    }
 
     suspend fun updateLibManga(track: Track): Track {
         return withIOContext {
@@ -137,6 +143,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
                     put("query", search)
                 }
             }
+            with(json) {
                 authClient.newCall(
                     POST(
                         apiUrl,
@@ -154,6 +161,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
                     }
             }
         }
+    }
 
     suspend fun findLibManga(track: Track, userid: Int): Track? {
         return withIOContext {
@@ -205,6 +213,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
                     put("manga_id", track.media_id)
                 }
             }
+            with(json) {
                 authClient.newCall(
                     POST(
                         apiUrl,
@@ -222,6 +231,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
                     }
             }
         }
+    }
 
     suspend fun getLibManga(track: Track, userid: Int): Track {
         return findLibManga(track, userid) ?: throw Exception("Could not find manga")
@@ -247,6 +257,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
             val payload = buildJsonObject {
                 put("query", query)
             }
+            with(json) {
                 authClient.newCall(
                     POST(
                         apiUrl,
@@ -265,6 +276,7 @@ class AnilistApi(val client: OkHttpClient, interceptor: AnilistInterceptor) {
                     }
             }
         }
+    }
 
     private fun jsonToALManga(struct: JsonObject): ALManga {
         return ALManga(

app/src/main/java/eu/kanade/tachiyomi/data/track/bangumi/BangumiApi.kt

@@ -118,12 +118,14 @@ class BangumiApi(private val client: OkHttpClient, interceptor: BangumiIntercept
 
     suspend fun findLibManga(track: Track): Track? {
         return withIOContext {
+            with(json) {
                 authClient.newCall(GET("$apiUrl/subject/${track.media_id}"))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
                     .let { jsonToSearch(it) }
             }
         }
+    }
 
     suspend fun statusLibManga(track: Track): Track? {
         return withIOContext {
@@ -155,11 +157,13 @@ class BangumiApi(private val client: OkHttpClient, interceptor: BangumiIntercept
 
     suspend fun accessToken(code: String): OAuth {
         return withIOContext {
+            with(json) {
                 client.newCall(accessTokenRequest(code))
                     .awaitSuccess()
                     .parseAs()
             }
         }
+    }
 
     private fun accessTokenRequest(code: String) = POST(
         oauthUrl,
@@ -181,7 +185,6 @@ class BangumiApi(private val client: OkHttpClient, interceptor: BangumiIntercept
         private const val loginUrl = "https://bgm.tv/oauth/authorize"
 
         private const val redirectUrl = "tachiyomi://bangumi-auth"
-        private const val baseMangaUrl = "$apiUrl/mangas"
 
         fun authUrl(): Uri =
             loginUrl.toUri().buildUpon()

app/src/main/java/eu/kanade/tachiyomi/data/track/kavita/KavitaApi.kt

@@ -6,6 +6,7 @@ import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.parseAs
+import kotlinx.serialization.json.Json
 import logcat.LogPriority
 import okhttp3.Dns
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
@@ -13,11 +14,14 @@ import okhttp3.OkHttpClient
 import okhttp3.RequestBody.Companion.toRequestBody
 import tachiyomi.core.util.lang.withIOContext
 import tachiyomi.core.util.system.logcat
+import uy.kohesive.injekt.injectLazy
 import java.io.IOException
 import java.net.SocketTimeoutException
 
 class KavitaApi(private val client: OkHttpClient, interceptor: KavitaInterceptor) {
 
+    private val json: Json by injectLazy()
+
     private val authClient = client.newBuilder()
         .dns(Dns.SYSTEM)
         .addInterceptor(interceptor)
@@ -39,6 +43,7 @@ class KavitaApi(private val client: OkHttpClient, interceptor: KavitaInterceptor
             body = "{}".toRequestBody("application/json; charset=utf-8".toMediaTypeOrNull()),
         )
         try {
+            with(json) {
                 client.newCall(request).execute().use {
                     when (it.code) {
                         200 -> return it.parseAs<AuthenticationDto>().token
@@ -53,6 +58,7 @@ class KavitaApi(private val client: OkHttpClient, interceptor: KavitaInterceptor
                         else -> {}
                     }
                 }
+            }
             // Not sure which one to catch
         } catch (e: SocketTimeoutException) {
             logcat(LogPriority.WARN) {
@@ -86,9 +92,11 @@ class KavitaApi(private val client: OkHttpClient, interceptor: KavitaInterceptor
     private fun getTotalChapters(url: String): Int {
         val requestUrl = getApiVolumesUrl(url)
         try {
-            val listVolumeDto = authClient.newCall(GET(requestUrl))
+            val listVolumeDto = with(json) {
+                authClient.newCall(GET(requestUrl))
                     .execute()
                     .parseAs<List<VolumeDto>>()
+            }
             var volumeNumber = 0
             var maxChapterNumber = 0
             for (volume in listVolumeDto) {
@@ -110,6 +118,7 @@ class KavitaApi(private val client: OkHttpClient, interceptor: KavitaInterceptor
         val serieId = getIdFromUrl(url)
         val requestUrl = "${getApiFromUrl(url)}/Tachiyomi/latest-chapter?seriesId=$serieId"
         try {
+            with(json) {
                 authClient.newCall(GET(requestUrl)).execute().use {
                     if (it.code == 200) {
                         return it.parseAs<ChapterDto>().number!!.replace(",", ".").toFloat()
@@ -118,6 +127,7 @@ class KavitaApi(private val client: OkHttpClient, interceptor: KavitaInterceptor
                         return 0F
                     }
                 }
+            }
         } catch (e: Exception) {
             logcat(LogPriority.WARN, e) { "Exception getting latest chapter read. Could not get itemRequest: $requestUrl" }
             throw e
@@ -127,9 +137,11 @@ class KavitaApi(private val client: OkHttpClient, interceptor: KavitaInterceptor
 
     suspend fun getTrackSearch(url: String): TrackSearch = withIOContext {
         try {
-            val serieDto: SeriesDto = authClient.newCall(GET(url))
+            val serieDto: SeriesDto = with(json) {
+                authClient.newCall(GET(url))
                     .awaitSuccess()
                     .parseAs()
+            }
 
             val track = serieDto.toTrack()
             track.apply {

app/src/main/java/eu/kanade/tachiyomi/data/track/kitsu/KitsuApi.kt

@@ -8,6 +8,7 @@ import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.jsonMime
 import eu.kanade.tachiyomi.network.parseAs
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.buildJsonObject
 import kotlinx.serialization.json.jsonArray
@@ -24,11 +25,14 @@ import okhttp3.Request
 import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import tachiyomi.core.util.lang.withIOContext
+import uy.kohesive.injekt.injectLazy
 import java.net.URLEncoder
 import java.nio.charset.StandardCharsets
 
 class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor) {
 
+    private val json: Json by injectLazy()
+
     private val authClient = client.newBuilder().addInterceptor(interceptor).build()
 
     suspend fun addLibManga(track: Track, userId: String): Track {
@@ -57,6 +61,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                 }
             }
 
+            with(json) {
                 authClient.newCall(
                     POST(
                         "${baseUrl}library-entries",
@@ -64,7 +69,8 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                             "Content-Type",
                             "application/vnd.api+json",
                         ),
-                    body = data.toString().toRequestBody("application/vnd.api+json".toMediaType()),
+                        body = data.toString()
+                            .toRequestBody("application/vnd.api+json".toMediaType()),
                     ),
                 )
                     .awaitSuccess()
@@ -75,6 +81,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                     }
             }
         }
+    }
 
     suspend fun updateLibManga(track: Track): Track {
         return withIOContext {
@@ -92,6 +99,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                 }
             }
 
+            with(json) {
                 authClient.newCall(
                     Request.Builder()
                         .url("${baseUrl}library-entries/${track.media_id}")
@@ -101,7 +109,9 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                                 "application/vnd.api+json",
                             ),
                         )
-                    .patch(data.toString().toRequestBody("application/vnd.api+json".toMediaType()))
+                        .patch(
+                            data.toString().toRequestBody("application/vnd.api+json".toMediaType()),
+                        )
                         .build(),
                 )
                     .awaitSuccess()
@@ -111,9 +121,11 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                     }
             }
         }
+    }
 
     suspend fun search(query: String): List<TrackSearch> {
         return withIOContext {
+            with(json) {
                 authClient.newCall(GET(algoliaKeyUrl))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
@@ -123,6 +135,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                     }
             }
         }
+    }
 
     private suspend fun algoliaSearch(key: String, query: String): List<TrackSearch> {
         return withIOContext {
@@ -130,6 +143,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                 put("params", "query=${URLEncoder.encode(query, StandardCharsets.UTF_8.name())}$algoliaFilter")
             }
 
+            with(json) {
                 client.newCall(
                     POST(
                         algoliaUrl,
@@ -152,6 +166,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                     }
             }
         }
+    }
 
     suspend fun findLibManga(track: Track, userId: String): Track? {
         return withIOContext {
@@ -159,6 +174,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                 .encodedQuery("filter[manga_id]=${track.media_id}&filter[user_id]=$userId")
                 .appendQueryParameter("include", "manga")
                 .build()
+            with(json) {
                 authClient.newCall(GET(url.toString()))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
@@ -173,6 +189,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                     }
             }
         }
+    }
 
     suspend fun getLibManga(track: Track): Track {
         return withIOContext {
@@ -180,6 +197,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                 .encodedQuery("filter[id]=${track.media_id}")
                 .appendQueryParameter("include", "manga")
                 .build()
+            with(json) {
                 authClient.newCall(GET(url.toString()))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
@@ -194,6 +212,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                     }
             }
         }
+    }
 
     suspend fun login(username: String, password: String): OAuth {
         return withIOContext {
@@ -204,17 +223,20 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                 .add("client_id", clientId)
                 .add("client_secret", clientSecret)
                 .build()
+            with(json) {
                 client.newCall(POST(loginUrl, body = formBody))
                     .awaitSuccess()
                     .parseAs()
             }
         }
+    }
 
     suspend fun getCurrentUser(): String {
         return withIOContext {
             val url = "${baseUrl}users".toUri().buildUpon()
                 .encodedQuery("filter[self]=true")
                 .build()
+            with(json) {
                 authClient.newCall(GET(url.toString()))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
@@ -223,6 +245,7 @@ class KitsuApi(private val client: OkHttpClient, interceptor: KitsuInterceptor)
                     }
             }
         }
+    }
 
     companion object {
         private const val clientId =

app/src/main/java/eu/kanade/tachiyomi/data/track/komga/KomgaApi.kt

@@ -26,7 +26,8 @@ class KomgaApi(private val client: OkHttpClient) {
     suspend fun getTrackSearch(url: String): TrackSearch =
         withIOContext {
             try {
-                val track = if (url.contains(READLIST_API)) {
+                val track = with(json) {
+                    if (url.contains(READLIST_API)) {
                         client.newCall(GET(url))
                             .awaitSuccess()
                             .parseAs<ReadListDto>()
@@ -37,16 +38,19 @@ class KomgaApi(private val client: OkHttpClient) {
                             .parseAs<SeriesDto>()
                             .toTrack()
                     }
+                }
 
                 val progress = client
                     .newCall(GET("${url.replace("/api/v1/series/", "/api/v2/series/")}/read-progress/tachiyomi"))
                     .awaitSuccess().let {
+                        with(json) {
                             if (url.contains("/api/v1/series/")) {
                                 it.parseAs<ReadProgressV2Dto>()
                             } else {
                                 it.parseAs<ReadProgressDto>().toV2()
                             }
                         }
+                    }
 
                 track.apply {
                     cover_url = "$url/thumbnail"

app/src/main/java/eu/kanade/tachiyomi/data/track/mangaupdates/MangaUpdatesApi.kt

@@ -47,7 +47,7 @@ class MangaUpdatesApi(
     }
 
     suspend fun getSeriesListItem(track: Track): Pair<ListItem, Rating?> {
-        val listItem =
+        val listItem = with(json) {
             authClient.newCall(
                 GET(
                     url = "$baseUrl/v1/lists/series/${track.media_id}",
@@ -55,6 +55,7 @@ class MangaUpdatesApi(
             )
                 .awaitSuccess()
                 .parseAs<ListItem>()
+        }
 
         val rating = getSeriesRating(track)
 
@@ -111,6 +112,7 @@ class MangaUpdatesApi(
 
     suspend fun getSeriesRating(track: Track): Rating? {
         return try {
+            with(json) {
                 authClient.newCall(
                     GET(
                         url = "$baseUrl/v1/series/${track.media_id}/rating",
@@ -118,6 +120,7 @@ class MangaUpdatesApi(
                 )
                     .awaitSuccess()
                     .parseAs<Rating>()
+            }
         } catch (e: Exception) {
             null
         }
@@ -156,7 +159,8 @@ class MangaUpdatesApi(
                 },
             )
         }
-        return client.newCall(
+        return with(json) {
+            client.newCall(
                 POST(
                     url = "$baseUrl/v1/series/search",
                     body = body.toString().toRequestBody(contentType),
@@ -171,13 +175,15 @@ class MangaUpdatesApi(
                 }
                 .orEmpty()
         }
+    }
 
     suspend fun authenticate(username: String, password: String): Context? {
         val body = buildJsonObject {
             put("username", username)
             put("password", password)
         }
-        return client.newCall(
+        return with(json) {
+            client.newCall(
                 PUT(
                     url = "$baseUrl/v1/account/login",
                     body = body.toString().toRequestBody(contentType),
@@ -194,4 +200,5 @@ class MangaUpdatesApi(
                     }
                 }
         }
+    }
 }

app/src/main/java/eu/kanade/tachiyomi/data/track/myanimelist/MyAnimeListApi.kt

@@ -12,6 +12,7 @@ import eu.kanade.tachiyomi.network.parseAs
 import eu.kanade.tachiyomi.util.PkceUtil
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.boolean
 import kotlinx.serialization.json.contentOrNull
@@ -27,11 +28,14 @@ import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.RequestBody
 import tachiyomi.core.util.lang.withIOContext
+import uy.kohesive.injekt.injectLazy
 import java.text.SimpleDateFormat
 import java.util.Locale
 
 class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListInterceptor) {
 
+    private val json: Json by injectLazy()
+
     private val authClient = client.newBuilder().addInterceptor(interceptor).build()
 
     suspend fun getAccessToken(authCode: String): OAuth {
@@ -42,11 +46,13 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                 .add("code_verifier", codeVerifier)
                 .add("grant_type", "authorization_code")
                 .build()
+            with(json) {
                 client.newCall(POST("$baseOAuthUrl/token", body = formBody))
                     .awaitSuccess()
                     .parseAs()
             }
         }
+    }
 
     suspend fun getCurrentUser(): String {
         return withIOContext {
@@ -54,12 +60,14 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                 .url("$baseApiUrl/users/@me")
                 .get()
                 .build()
+            with(json) {
                 authClient.newCall(request)
                     .awaitSuccess()
                     .parseAs<JsonObject>()
                     .let { it["name"]!!.jsonPrimitive.content }
             }
         }
+    }
 
     suspend fun search(query: String): List<TrackSearch> {
         return withIOContext {
@@ -68,6 +76,7 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                 .appendQueryParameter("q", query.take(64))
                 .appendQueryParameter("nsfw", "true")
                 .build()
+            with(json) {
                 authClient.newCall(GET(url.toString()))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
@@ -83,6 +92,7 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                     }
             }
         }
+    }
 
     suspend fun getMangaDetails(id: Int): TrackSearch {
         return withIOContext {
@@ -90,6 +100,7 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                 .appendPath(id.toString())
                 .appendQueryParameter("fields", "id,title,synopsis,num_chapters,main_picture,status,media_type,start_date")
                 .build()
+            with(json) {
                 authClient.newCall(GET(url.toString()))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
@@ -100,10 +111,14 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                             title = obj["title"]!!.jsonPrimitive.content
                             summary = obj["synopsis"]?.jsonPrimitive?.content ?: ""
                             total_chapters = obj["num_chapters"]!!.jsonPrimitive.int
-                        cover_url = obj["main_picture"]?.jsonObject?.get("large")?.jsonPrimitive?.content ?: ""
+                            cover_url =
+                                obj["main_picture"]?.jsonObject?.get("large")?.jsonPrimitive?.content
+                                    ?: ""
                             tracking_url = "https://myanimelist.net/manga/$media_id"
-                        publishing_status = obj["status"]!!.jsonPrimitive.content.replace("_", " ")
+                            publishing_status =
-                        publishing_type = obj["media_type"]!!.jsonPrimitive.content.replace("_", " ")
+                                obj["status"]!!.jsonPrimitive.content.replace("_", " ")
+                            publishing_type =
+                                obj["media_type"]!!.jsonPrimitive.content.replace("_", " ")
                             start_date = try {
                                 val outputDf = SimpleDateFormat("yyyy-MM-dd", Locale.US)
                                 outputDf.format(obj["start_date"]!!)
@@ -114,6 +129,7 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                     }
             }
         }
+    }
 
     suspend fun updateItem(track: Track): Track {
         return withIOContext {
@@ -133,12 +149,14 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                 .url(mangaUrl(track.media_id).toString())
                 .put(formBodyBuilder.build())
                 .build()
+            with(json) {
                 authClient.newCall(request)
                     .awaitSuccess()
                     .parseAs<JsonObject>()
                     .let { parseMangaItem(it, track) }
             }
         }
+    }
 
     suspend fun findListItem(track: Track): Track? {
         return withIOContext {
@@ -146,6 +164,7 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                 .appendPath(track.media_id.toString())
                 .appendQueryParameter("fields", "num_chapters,my_list_status{start_date,finish_date}")
                 .build()
+            with(json) {
                 authClient.newCall(GET(uri.toString()))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
@@ -157,6 +176,7 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                     }
             }
         }
+    }
 
     suspend fun findListItems(query: String, offset: Int = 0): List<TrackSearch> {
         return withIOContext {
@@ -198,11 +218,13 @@ class MyAnimeListApi(private val client: OkHttpClient, interceptor: MyAnimeListI
                 .url(urlBuilder.build().toString())
                 .get()
                 .build()
+            with(json) {
                 authClient.newCall(request)
                     .awaitSuccess()
                     .parseAs()
             }
         }
+    }
 
     private fun parseMangaItem(response: JsonObject, track: Track): Track {
         val obj = response.jsonObject

app/src/main/java/eu/kanade/tachiyomi/data/track/myanimelist/MyAnimeListInterceptor.kt

@@ -1,12 +1,16 @@
 package eu.kanade.tachiyomi.data.track.myanimelist
 
 import eu.kanade.tachiyomi.network.parseAs
+import kotlinx.serialization.json.Json
 import okhttp3.Interceptor
 import okhttp3.Response
+import uy.kohesive.injekt.injectLazy
 import java.io.IOException
 
 class MyAnimeListInterceptor(private val myanimelist: MyAnimeList, private var token: String?) : Interceptor {
 
+    private val json: Json by injectLazy()
+
     private var oauth: OAuth? = null
 
     override fun intercept(chain: Interceptor.Chain): Response {
@@ -69,7 +73,7 @@ class MyAnimeListInterceptor(private val myanimelist: MyAnimeList, private var t
             val oauthResponse = chain.proceed(MyAnimeListApi.refreshTokenRequest(oauth!!))
 
             if (oauthResponse.isSuccessful) {
-                oauthResponse.parseAs<OAuth>()
+                with(json) { oauthResponse.parseAs<OAuth>() }
             } else {
                 oauthResponse.close()
                 null

app/src/main/java/eu/kanade/tachiyomi/data/track/shikimori/ShikimoriApi.kt

@@ -9,6 +9,7 @@ import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.jsonMime
 import eu.kanade.tachiyomi.network.parseAs
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.buildJsonObject
@@ -24,9 +25,12 @@ import okhttp3.FormBody
 import okhttp3.OkHttpClient
 import okhttp3.RequestBody.Companion.toRequestBody
 import tachiyomi.core.util.lang.withIOContext
+import uy.kohesive.injekt.injectLazy
 
 class ShikimoriApi(private val client: OkHttpClient, interceptor: ShikimoriInterceptor) {
 
+    private val json: Json by injectLazy()
+
     private val authClient = client.newBuilder().addInterceptor(interceptor).build()
 
     suspend fun addLibManga(track: Track, user_id: String): Track {
@@ -60,6 +64,7 @@ class ShikimoriApi(private val client: OkHttpClient, interceptor: ShikimoriInter
                 .appendQueryParameter("search", search)
                 .appendQueryParameter("limit", "20")
                 .build()
+            with(json) {
                 authClient.newCall(GET(url.toString()))
                     .awaitSuccess()
                     .parseAs<JsonArray>()
@@ -70,6 +75,7 @@ class ShikimoriApi(private val client: OkHttpClient, interceptor: ShikimoriInter
                     }
             }
         }
+    }
 
     private fun jsonToSearch(obj: JsonObject): TrackSearch {
         return TrackSearch.create(TrackManager.SHIKIMORI).apply {
@@ -81,7 +87,7 @@ class ShikimoriApi(private val client: OkHttpClient, interceptor: ShikimoriInter
             tracking_url = baseUrl + obj["url"]!!.jsonPrimitive.content
             publishing_status = obj["status"]!!.jsonPrimitive.content
             publishing_type = obj["kind"]!!.jsonPrimitive.content
-            start_date = obj.get("aired_on")!!.jsonPrimitive.contentOrNull ?: ""
+            start_date = obj["aired_on"]!!.jsonPrimitive.contentOrNull ?: ""
         }
     }
 
@@ -102,15 +108,18 @@ class ShikimoriApi(private val client: OkHttpClient, interceptor: ShikimoriInter
             val urlMangas = "$apiUrl/mangas".toUri().buildUpon()
                 .appendPath(track.media_id.toString())
                 .build()
-            val mangas = authClient.newCall(GET(urlMangas.toString()))
+            val mangas = with(json) {
+                authClient.newCall(GET(urlMangas.toString()))
                     .awaitSuccess()
                     .parseAs<JsonObject>()
+            }
 
             val url = "$apiUrl/v2/user_rates".toUri().buildUpon()
                 .appendQueryParameter("user_id", user_id)
                 .appendQueryParameter("target_id", track.media_id.toString())
                 .appendQueryParameter("target_type", "Manga")
                 .build()
+            with(json) {
                 authClient.newCall(GET(url.toString()))
                     .awaitSuccess()
                     .parseAs<JsonArray>()
@@ -125,23 +134,28 @@ class ShikimoriApi(private val client: OkHttpClient, interceptor: ShikimoriInter
                     }
             }
         }
+    }
 
     suspend fun getCurrentUser(): Int {
-        return authClient.newCall(GET("$apiUrl/users/whoami"))
+        return with(json) {
+            authClient.newCall(GET("$apiUrl/users/whoami"))
                 .awaitSuccess()
                 .parseAs<JsonObject>()
                 .let {
                     it["id"]!!.jsonPrimitive.int
                 }
         }
+    }
 
     suspend fun accessToken(code: String): OAuth {
         return withIOContext {
+            with(json) {
                 client.newCall(accessTokenRequest(code))
                     .awaitSuccess()
                     .parseAs()
             }
         }
+    }
 
     private fun accessTokenRequest(code: String) = POST(
         oauthUrl,
@@ -164,14 +178,8 @@ class ShikimoriApi(private val client: OkHttpClient, interceptor: ShikimoriInter
         private const val loginUrl = "$baseUrl/oauth/authorize"
 
         private const val redirectUrl = "tachiyomi://shikimori-auth"
-        private const val baseMangaUrl = "$apiUrl/mangas"
 
-        fun mangaUrl(remoteId: Int): String {
+        fun authUrl() = loginUrl.toUri().buildUpon()
-            return "$baseMangaUrl/$remoteId"
-        }
-
-        fun authUrl() =
-            loginUrl.toUri().buildUpon()
             .appendQueryParameter("client_id", clientId)
             .appendQueryParameter("redirect_uri", redirectUrl)
             .appendQueryParameter("response_type", "code")

app/src/main/java/eu/kanade/tachiyomi/data/track/suwayomi/TachideskApi.kt

@@ -10,6 +10,7 @@ import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.network.PUT
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.parseAs
+import kotlinx.serialization.json.Json
 import okhttp3.Credentials
 import okhttp3.Dns
 import okhttp3.FormBody
@@ -23,11 +24,15 @@ import java.nio.charset.Charset
 import java.security.MessageDigest
 
 class TachideskApi {
-    private val network by injectLazy<NetworkHelper>()
+
+    private val network: NetworkHelper by injectLazy()
+    private val json: Json by injectLazy()
+
     val client: OkHttpClient =
         network.client.newBuilder()
             .dns(Dns.SYSTEM) // don't use DNS over HTTPS as it breaks IP addressing
             .build()
+
     fun headersBuilder(): Headers.Builder = Headers.Builder().apply {
         if (basePassword.isNotEmpty() && baseLogin.isNotEmpty()) {
             val credentials = Credentials.basic(baseLogin, basePassword)
@@ -50,7 +55,11 @@ class TachideskApi {
             trackUrl
         }
 
-        val manga = client.newCall(GET("$url/full", headers)).awaitSuccess().parseAs<MangaDataClass>()
+        val manga = with(json) {
+            client.newCall(GET("$url/full", headers))
+                .awaitSuccess()
+                .parseAs<MangaDataClass>()
+        }
 
         TrackSearch.create(TrackManager.SUWAYOMI).apply {
             title = manga.title
@@ -70,7 +79,11 @@ class TachideskApi {
 
     suspend fun updateProgress(track: Track): Track {
         val url = track.tracking_url
-        val chapters = client.newCall(GET("$url/chapters", headers)).awaitSuccess().parseAs<List<ChapterDataClass>>()
+        val chapters = with(json) {
+            client.newCall(GET("$url/chapters", headers))
+                .awaitSuccess()
+                .parseAs<List<ChapterDataClass>>()
+        }
         val lastChapterIndex = chapters.first { it.chapterNumber == track.last_chapter_read }.index
 
         client.newCall(

app/src/main/java/eu/kanade/tachiyomi/data/updater/AppUpdateChecker.kt

@@ -7,6 +7,7 @@ import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.parseAs
 import eu.kanade.tachiyomi.util.system.isInstalledFromFDroid
+import kotlinx.serialization.json.Json
 import tachiyomi.core.preference.Preference
 import tachiyomi.core.preference.PreferenceStore
 import tachiyomi.core.util.lang.withIOContext
@@ -18,6 +19,8 @@ class AppUpdateChecker {
 
     private val networkService: NetworkHelper by injectLazy()
     private val preferenceStore: PreferenceStore by injectLazy()
+    private val json: Json by injectLazy()
+
     private val lastAppCheck: Preference<Long> by lazy {
         preferenceStore.getLong("last_app_check", 0)
     }
@@ -29,7 +32,8 @@ class AppUpdateChecker {
         }
 
         return withIOContext {
-            val result = networkService.client
+            val result = with(json) {
+                networkService.client
                     .newCall(GET("https://api.github.com/repos/$GITHUB_REPO/releases/latest"))
                     .awaitSuccess()
                     .parseAs<GithubRelease>()
@@ -47,6 +51,7 @@ class AppUpdateChecker {
                             AppUpdateResult.NoNewUpdate
                         }
                     }
+            }
 
             when (result) {
                 is AppUpdateResult.NewUpdate -> AppUpdateNotifier(context).promptUpdate(result.release)

app/src/main/java/eu/kanade/tachiyomi/extension/api/ExtensionGithubApi.kt

@@ -11,6 +11,7 @@ import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.parseAs
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
 import logcat.LogPriority
 import tachiyomi.core.preference.Preference
 import tachiyomi.core.preference.PreferenceStore
@@ -24,10 +25,12 @@ internal class ExtensionGithubApi {
 
     private val networkService: NetworkHelper by injectLazy()
     private val preferenceStore: PreferenceStore by injectLazy()
+    private val extensionManager: ExtensionManager by injectLazy()
+    private val json: Json by injectLazy()
+
     private val lastExtCheck: Preference<Long> by lazy {
         preferenceStore.getLong("last_ext_check", 0)
     }
-    private val extensionManager: ExtensionManager by injectLazy()
 
     private var requiresFallbackSource = false
 
@@ -53,9 +56,11 @@ internal class ExtensionGithubApi {
                     .awaitSuccess()
             }
 
-            val extensions = response
+            val extensions = with(json) {
+                response
                     .parseAs<List<ExtensionJsonObject>>()
                     .toExtensions()
+            }
 
             // Sanity check - a small number of extensions probably means something broke
             // with the repo generator

app/src/main/java/eu/kanade/tachiyomi/ui/browse/extension/details/ExtensionDetailsScreenModel.kt

@@ -120,7 +120,7 @@ class ExtensionDetailsScreenModel(
 
         val cleared = urls.sumOf {
             try {
-                network.cookieManager.remove(it.toHttpUrl())
+                network.cookieJar.remove(it.toHttpUrl())
             } catch (e: Exception) {
                 logcat(LogPriority.ERROR, e) { "Failed to clear cookies for $it" }
                 0

app/src/main/java/eu/kanade/tachiyomi/ui/webview/WebViewActivity.kt

@@ -92,7 +92,7 @@ class WebViewActivity : BaseActivity() {
     }
 
     private fun clearCookies(url: String) {
-        val cleared = network.cookieManager.remove(url.toHttpUrl())
+        val cleared = network.cookieJar.remove(url.toHttpUrl())
         logcat { "Cleared $cleared cookies for: $url" }
     }
 

app/src/main/java/eu/kanade/tachiyomi/ui/webview/WebViewScreenModel.kt

@@ -47,7 +47,7 @@ class WebViewScreenModel(
     }
 
     fun clearCookies(url: String) {
-        val cleared = network.cookieManager.remove(url.toHttpUrl())
+        val cleared = network.cookieJar.remove(url.toHttpUrl())
         logcat { "Cleared $cleared cookies for: $url" }
     }
 }

core/build.gradle.kts

@@ -6,6 +6,13 @@ plugins {
 
 android {
     namespace = "eu.kanade.tachiyomi.core"
+
+    kotlinOptions {
+        freeCompilerArgs += listOf(
+            "-Xcontext-receivers",
+            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
+        )
+    }
 }
 
 dependencies {
@@ -24,12 +31,8 @@ dependencies {
     api(kotlinx.serialization.json)
     api(kotlinx.serialization.json.okio)
 
-    api(libs.injekt.core)
-
     api(libs.preferencektx)
 
-    implementation(androidx.corektx)
-
     // JavaScript engine
     implementation(libs.bundles.js.engine)
 }

core/src/main/java/eu/kanade/tachiyomi/network/NetworkHelper.kt

@@ -6,26 +6,30 @@ import eu.kanade.tachiyomi.network.interceptor.UserAgentInterceptor
 import okhttp3.Cache
 import okhttp3.OkHttpClient
 import okhttp3.logging.HttpLoggingInterceptor
-import uy.kohesive.injekt.injectLazy
 import java.io.File
 import java.util.concurrent.TimeUnit
 
-class NetworkHelper(context: Context) {
+class NetworkHelper(
-
+    context: Context,
-    private val preferences: NetworkPreferences by injectLazy()
+    private val preferences: NetworkPreferences,
+) {
 
     private val cacheDir = File(context.cacheDir, "network_cache")
     private val cacheSize = 5L * 1024 * 1024 // 5 MiB
 
-    val cookieManager = AndroidCookieJar()
+    val cookieJar = AndroidCookieJar()
 
-    private val userAgentInterceptor by lazy { UserAgentInterceptor() }
+    private val userAgentInterceptor by lazy {
-    private val cloudflareInterceptor by lazy { CloudflareInterceptor(context) }
+        UserAgentInterceptor(::defaultUserAgentProvider)
+    }
+    private val cloudflareInterceptor by lazy {
+        CloudflareInterceptor(context, cookieJar, ::defaultUserAgentProvider)
+    }
 
     private val baseClientBuilder: OkHttpClient.Builder
         get() {
             val builder = OkHttpClient.Builder()
-                .cookieJar(cookieManager)
+                .cookieJar(cookieJar)
                 .connectTimeout(30, TimeUnit.SECONDS)
                 .readTimeout(30, TimeUnit.SECONDS)
                 .callTimeout(2, TimeUnit.MINUTES)
@@ -65,7 +69,5 @@ class NetworkHelper(context: Context) {
             .build()
     }
 
-    val defaultUserAgent by lazy {
+    fun defaultUserAgentProvider() = preferences.defaultUserAgent().get().trim()
-        preferences.defaultUserAgent().get().trim()
-    }
 }

core/src/main/java/eu/kanade/tachiyomi/network/OkHttpExtensions.kt

@@ -3,7 +3,6 @@ package eu.kanade.tachiyomi.network
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.okio.decodeFromBufferedSource
 import kotlinx.serialization.serializer
@@ -16,8 +15,6 @@ import okhttp3.Response
 import rx.Observable
 import rx.Producer
 import rx.Subscription
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
 import java.io.IOException
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.coroutines.resumeWithException
@@ -131,14 +128,18 @@ fun OkHttpClient.newCachelessCallWithProgress(request: Request, listener: Progre
     return progressClient.newCall(request)
 }
 
+context(Json)
 inline fun <reified T> Response.parseAs(): T {
     return decodeFromJsonResponse(serializer(), this)
 }
 
-@OptIn(ExperimentalSerializationApi::class)
+context(Json)
-fun <T> decodeFromJsonResponse(deserializer: DeserializationStrategy<T>, response: Response): T {
+fun <T> decodeFromJsonResponse(
+    deserializer: DeserializationStrategy<T>,
+    response: Response,
+): T {
     return response.body.source().use {
-        Injekt.get<Json>().decodeFromBufferedSource(deserializer, it)
+        decodeFromBufferedSource(deserializer, it)
     }
 }
 

core/src/main/java/eu/kanade/tachiyomi/network/interceptor/CloudflareInterceptor.kt

@@ -6,7 +6,7 @@ import android.webkit.WebView
 import android.widget.Toast
 import androidx.core.content.ContextCompat
 import eu.kanade.tachiyomi.core.R
-import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.network.AndroidCookieJar
 import eu.kanade.tachiyomi.util.system.WebViewClientCompat
 import eu.kanade.tachiyomi.util.system.isOutdated
 import eu.kanade.tachiyomi.util.system.toast
@@ -15,16 +15,17 @@ import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Interceptor
 import okhttp3.Request
 import okhttp3.Response
-import uy.kohesive.injekt.injectLazy
 import java.io.IOException
 import java.util.concurrent.CountDownLatch
 
-class CloudflareInterceptor(private val context: Context) : WebViewInterceptor(context) {
+class CloudflareInterceptor(
+    private val context: Context,
+    private val cookieManager: AndroidCookieJar,
+    defaultUserAgentProvider: () -> String,
+) : WebViewInterceptor(context, defaultUserAgentProvider) {
 
     private val executor = ContextCompat.getMainExecutor(context)
 
-    private val networkHelper: NetworkHelper by injectLazy()
-
     override fun shouldIntercept(response: Response): Boolean {
         // Check if Cloudflare anti-bot is on
         return response.code in ERROR_CODES && response.header("Server") in SERVER_CHECK
@@ -33,8 +34,8 @@ class CloudflareInterceptor(private val context: Context) : WebViewInterceptor(c
     override fun intercept(chain: Interceptor.Chain, request: Request, response: Response): Response {
         try {
             response.close()
-            networkHelper.cookieManager.remove(request.url, COOKIE_NAMES, 0)
+            cookieManager.remove(request.url, COOKIE_NAMES, 0)
-            val oldCookie = networkHelper.cookieManager.get(request.url)
+            val oldCookie = cookieManager.get(request.url)
                 .firstOrNull { it.name == "cf_clearance" }
             resolveWithWebView(request, oldCookie)
 
@@ -70,7 +71,7 @@ class CloudflareInterceptor(private val context: Context) : WebViewInterceptor(c
             webview?.webViewClient = object : WebViewClientCompat() {
                 override fun onPageFinished(view: WebView, url: String) {
                     fun isCloudFlareBypassed(): Boolean {
-                        return networkHelper.cookieManager.get(origRequestUrl.toHttpUrl())
+                        return cookieManager.get(origRequestUrl.toHttpUrl())
                             .firstOrNull { it.name == "cf_clearance" }
                             .let { it != null && it != oldCookie }
                     }

core/src/main/java/eu/kanade/tachiyomi/network/interceptor/UserAgentInterceptor.kt

@@ -1,13 +1,11 @@
 package eu.kanade.tachiyomi.network.interceptor
 
-import eu.kanade.tachiyomi.network.NetworkHelper
 import okhttp3.Interceptor
 import okhttp3.Response
-import uy.kohesive.injekt.injectLazy
 
-class UserAgentInterceptor : Interceptor {
+class UserAgentInterceptor(
-
+    private val defaultUserAgentProvider: () -> String,
-    private val networkHelper: NetworkHelper by injectLazy()
+) : Interceptor {
 
     override fun intercept(chain: Interceptor.Chain): Response {
         val originalRequest = chain.request()
@@ -16,7 +14,7 @@ class UserAgentInterceptor : Interceptor {
             val newRequest = originalRequest
                 .newBuilder()
                 .removeHeader("User-Agent")
-                .addHeader("User-Agent", networkHelper.defaultUserAgent)
+                .addHeader("User-Agent", defaultUserAgentProvider())
                 .build()
             chain.proceed(newRequest)
         } else {

core/src/main/java/eu/kanade/tachiyomi/network/interceptor/WebViewInterceptor.kt

@@ -6,7 +6,6 @@ import android.webkit.WebSettings
 import android.webkit.WebView
 import android.widget.Toast
 import eu.kanade.tachiyomi.core.R
-import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.util.system.DeviceUtil
 import eu.kanade.tachiyomi.util.system.WebViewUtil
 import eu.kanade.tachiyomi.util.system.setDefaultSettings
@@ -16,14 +15,14 @@ import okhttp3.Interceptor
 import okhttp3.Request
 import okhttp3.Response
 import tachiyomi.core.util.lang.launchUI
-import uy.kohesive.injekt.injectLazy
 import java.util.Locale
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 
-abstract class WebViewInterceptor(private val context: Context) : Interceptor {
+abstract class WebViewInterceptor(
-
+    private val context: Context,
-    private val networkHelper: NetworkHelper by injectLazy()
+    private val defaultUserAgentProvider: () -> String,
+) : Interceptor {
 
     /**
      * When this is called, it initializes the WebView if it wasn't already. We use this to avoid
@@ -85,7 +84,7 @@ abstract class WebViewInterceptor(private val context: Context) : Interceptor {
         return WebView(context).apply {
             setDefaultSettings()
             // Avoid sending empty User-Agent, Chromium WebView will reset to default if empty
-            settings.userAgentString = request.header("User-Agent") ?: networkHelper.defaultUserAgent
+            settings.userAgentString = request.header("User-Agent") ?: defaultUserAgentProvider()
         }
     }
 }

data/build.gradle.kts

@@ -23,6 +23,7 @@ dependencies {
     implementation(project(":source-api"))
     implementation(project(":domain"))
     implementation(project(":core"))
+
     api(libs.sqldelight.android.driver)
     api(libs.sqldelight.coroutines)
     api(libs.sqldelight.android.paging)

data/src/main/java/tachiyomi/data/updates/UpdatesRepositoryImpl.kt

@@ -6,12 +6,32 @@ import tachiyomi.domain.updates.model.UpdatesWithRelations
 import tachiyomi.domain.updates.repository.UpdatesRepository
 
 class UpdatesRepositoryImpl(
-    val databaseHandler: DatabaseHandler,
+    private val databaseHandler: DatabaseHandler,
 ) : UpdatesRepository {
 
+    override suspend fun awaitWithRead(read: Boolean, after: Long): List<UpdatesWithRelations> {
+        return databaseHandler.awaitList {
+            updatesViewQueries.getUpdatesByReadStatus(
+                read = read,
+                after = after,
+                mapper = updateWithRelationMapper,
+            )
+        }
+    }
+
     override fun subscribeAll(after: Long): Flow<List<UpdatesWithRelations>> {
         return databaseHandler.subscribeToList {
             updatesViewQueries.updates(after, updateWithRelationMapper)
         }
     }
+
+    override fun subscribeWithRead(read: Boolean, after: Long): Flow<List<UpdatesWithRelations>> {
+        return databaseHandler.subscribeToList {
+            updatesViewQueries.getUpdatesByReadStatus(
+                read = read,
+                after = after,
+                mapper = updateWithRelationMapper,
+            )
+        }
+    }
 }

domain/build.gradle.kts

@@ -13,11 +13,11 @@ android {
 }
 
 dependencies {
-    implementation(platform(kotlinx.coroutines.bom))
-    implementation(kotlinx.bundles.coroutines)
-
     implementation(project(":source-api"))
     implementation(project(":core"))
 
+    implementation(platform(kotlinx.coroutines.bom))
+    implementation(kotlinx.bundles.coroutines)
+
     testImplementation(libs.junit)
 }

domain/src/main/java/tachiyomi/domain/updates/interactor/GetUpdates.kt

@@ -9,9 +9,17 @@ class GetUpdates(
     private val repository: UpdatesRepository,
 ) {
 
+    suspend fun await(read: Boolean, after: Long): List<UpdatesWithRelations> {
+        return repository.awaitWithRead(read, after)
+    }
+
     fun subscribe(calendar: Calendar): Flow<List<UpdatesWithRelations>> = subscribe(calendar.time.time)
 
     fun subscribe(after: Long): Flow<List<UpdatesWithRelations>> {
         return repository.subscribeAll(after)
     }
+
+    fun subscribe(read: Boolean, after: Long): Flow<List<UpdatesWithRelations>> {
+        return repository.subscribeWithRead(read, after)
+    }
 }

domain/src/main/java/tachiyomi/domain/updates/repository/UpdatesRepository.kt

@@ -5,5 +5,9 @@ import tachiyomi.domain.updates.model.UpdatesWithRelations
 
 interface UpdatesRepository {
 
+    suspend fun awaitWithRead(read: Boolean, after: Long): List<UpdatesWithRelations>
+
     fun subscribeAll(after: Long): Flow<List<UpdatesWithRelations>>
+
+    fun subscribeWithRead(read: Boolean, after: Long): Flow<List<UpdatesWithRelations>>
 }

presentation-widget/build.gradle.kts

@@ -22,11 +22,11 @@ android {
 
 dependencies {
     implementation(project(":core"))
-    implementation(project(":data"))
     implementation(project(":domain"))
     implementation(project(":presentation-core"))
 
     implementation(androidx.glance)
 
     implementation(libs.coil.core)
+    api(libs.injekt.core)
 }

presentation-widget/src/main/java/tachiyomi/presentation/widget/TachiyomiWidgetManager.kt

@@ -7,21 +7,17 @@ import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
-import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.updates.interactor.GetUpdates
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
 
 class TachiyomiWidgetManager(
-    private val database: DatabaseHandler = Injekt.get(),
+    private val getUpdates: GetUpdates,
 ) {
 
     fun Context.init(scope: LifecycleCoroutineScope) {
-        database.subscribeToList {
+        getUpdates.subscribe(
-            updatesViewQueries.getUpdatesByReadStatus(
             read = false,
             after = UpdatesGridGlanceWidget.DateLimit.timeInMillis,
         )
-        }
             .drop(1)
             .distinctUntilChanged()
             .onEach {

presentation-widget/src/main/java/tachiyomi/presentation/widget/UpdatesGridGlanceWidget.kt

@@ -25,13 +25,13 @@ import eu.kanade.tachiyomi.core.security.SecurityPreferences
 import eu.kanade.tachiyomi.util.system.dpToPx
 import kotlinx.coroutines.MainScope
 import tachiyomi.core.util.lang.launchIO
-import tachiyomi.data.DatabaseHandler
 import tachiyomi.domain.manga.model.MangaCover
+import tachiyomi.domain.updates.interactor.GetUpdates
+import tachiyomi.domain.updates.model.UpdatesWithRelations
 import tachiyomi.presentation.widget.components.CoverHeight
 import tachiyomi.presentation.widget.components.CoverWidth
 import tachiyomi.presentation.widget.components.LockedWidget
 import tachiyomi.presentation.widget.components.UpdatesWidget
-import tachiyomi.view.UpdatesView
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import uy.kohesive.injekt.injectLazy
@@ -39,6 +39,7 @@ import java.util.Calendar
 import java.util.Date
 
 class UpdatesGridGlanceWidget : GlanceAppWidget() {
+
     private val app: Application by injectLazy()
     private val preferences: SecurityPreferences by injectLazy()
 
@@ -58,7 +59,7 @@ class UpdatesGridGlanceWidget : GlanceAppWidget() {
         UpdatesWidget(data)
     }
 
-    fun loadData(list: List<UpdatesView>? = null) {
+    fun loadData(list: List<UpdatesWithRelations>? = null) {
         coroutineScope.launchIO {
             // Don't show anything when lock is active
             if (preferences.useAuthenticator().get()) {
@@ -71,13 +72,10 @@ class UpdatesGridGlanceWidget : GlanceAppWidget() {
             if (ids.isEmpty()) return@launchIO
 
             val processList = list
-                ?: Injekt.get<DatabaseHandler>()
+                ?: Injekt.get<GetUpdates>().await(
-                    .awaitList {
-                        updatesViewQueries.getUpdatesByReadStatus(
                     read = false,
                     after = DateLimit.timeInMillis,
                 )
-                    }
             val (rowCount, columnCount) = ids
                 .flatMap { manager.getAppWidgetSizes(it) }
                 .maxBy { it.height.value * it.width.value }
@@ -88,7 +86,7 @@ class UpdatesGridGlanceWidget : GlanceAppWidget() {
         }
     }
 
-    private fun prepareList(processList: List<UpdatesView>, take: Int): List<Pair<Long, Bitmap?>> {
+    private fun prepareList(processList: List<UpdatesWithRelations>, take: Int): List<Pair<Long, Bitmap?>> {
         // Resize to cover size
         val widthPx = CoverWidth.value.toInt().dpToPx
         val heightPx = CoverHeight.value.toInt().dpToPx
@@ -101,10 +99,10 @@ class UpdatesGridGlanceWidget : GlanceAppWidget() {
                     .data(
                         MangaCover(
                             mangaId = updatesView.mangaId,
-                            sourceId = updatesView.source,
+                            sourceId = updatesView.sourceId,
-                            isMangaFavorite = updatesView.favorite,
+                            isMangaFavorite = true,
-                            url = updatesView.thumbnailUrl,
+                            url = updatesView.coverData.url,
-                            lastModified = updatesView.coverLastModified,
+                            lastModified = updatesView.coverData.lastModified,
                         ),
                     )
                     .memoryCachePolicy(CachePolicy.DISABLED)

source-api/build.gradle.kts

@@ -10,20 +10,14 @@ android {
     defaultConfig {
         consumerProguardFile("consumer-proguard.pro")
     }
-
 }
 
 dependencies {
-
     implementation(project(":core"))
 
     api(kotlinx.serialization.json)
-
+    api(libs.injekt.core)
     api(libs.rxjava)
-
     api(libs.preferencektx)
-
     api(libs.jsoup)
-
-    implementation(androidx.corektx)
 }

source-api/src/main/java/eu/kanade/tachiyomi/source/online/HttpSource.kt

@@ -68,7 +68,7 @@ abstract class HttpSource : CatalogueSource {
      * Headers builder for requests. Implementations can override this method for custom headers.
      */
     protected open fun headersBuilder() = Headers.Builder().apply {
-        add("User-Agent", network.defaultUserAgent)
+        add("User-Agent", network.defaultUserAgentProvider())
     }
 
     /**