From 13656959ae0606736f6ca9eb62699dc23e467c2f Mon Sep 17 00:00:00 2001 From: AntsyLich <59261191+AntsyLich@users.noreply.github.com> Date: Mon, 8 Apr 2024 15:45:38 +0600 Subject: [PATCH] MangaCoverFetcher: Small cleanups Co-authored-by: Ivan Iskandar <12537387+ivaniskandar@users.noreply.github.com> --- app/src/main/java/eu/kanade/tachiyomi/App.kt | 29 ++----------------- .../tachiyomi/data/coil/MangaCoverFetcher.kt | 22 +++++++------- 2 files changed, 13 insertions(+), 38 deletions(-) diff --git a/app/src/main/java/eu/kanade/tachiyomi/App.kt b/app/src/main/java/eu/kanade/tachiyomi/App.kt index 3ffc83ebd0..12170d8a56 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/App.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/App.kt @@ -17,8 +17,6 @@ import androidx.lifecycle.ProcessLifecycleOwner import androidx.lifecycle.lifecycleScope import coil3.ImageLoader import coil3.SingletonImageLoader -import coil3.disk.DiskCache -import coil3.disk.directory import coil3.network.okhttp.OkHttpNetworkFetcherFactory import coil3.request.allowRgb565 import coil3.request.crossfade @@ -157,16 +155,14 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor override fun newImageLoader(context: Context): ImageLoader { return ImageLoader.Builder(this).apply { val callFactoryLazy = lazy { Injekt.get().client } - val diskCacheLazy = lazy { CoilDiskCache.get(this@App) } components { add(OkHttpNetworkFetcherFactory(callFactoryLazy::value)) add(TachiyomiImageDecoder.Factory()) - add(MangaCoverFetcher.MangaFactory(callFactoryLazy, diskCacheLazy)) - add(MangaCoverFetcher.MangaCoverFactory(callFactoryLazy, diskCacheLazy)) + add(MangaCoverFetcher.MangaFactory(callFactoryLazy)) + add(MangaCoverFetcher.MangaCoverFactory(callFactoryLazy)) add(MangaKeyer()) add(MangaCoverKeyer()) } - diskCache(diskCacheLazy::value) crossfade((300 * this@App.animatorDurationScale).toInt()) allowRgb565(DeviceUtil.isLowRamDevice(this@App)) if (networkPreferences.verboseLogging().get()) logger(DebugLogger()) @@ -240,24 +236,3 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor } private const val ACTION_DISABLE_INCOGNITO_MODE = "tachi.action.DISABLE_INCOGNITO_MODE" - -/** - * Direct copy of Coil's internal SingletonDiskCache so that [MangaCoverFetcher] can access it. - */ -private object CoilDiskCache { - - private const val FOLDER_NAME = "image_cache" - private var instance: DiskCache? = null - - @Synchronized - fun get(context: Context): DiskCache { - return instance ?: run { - val safeCacheDir = context.cacheDir.apply { mkdirs() } - // Create the singleton disk cache instance. - DiskCache.Builder() - .directory(safeCacheDir.resolve(FOLDER_NAME)) - .build() - .also { instance = it } - } - } -} diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/coil/MangaCoverFetcher.kt b/app/src/main/java/eu/kanade/tachiyomi/data/coil/MangaCoverFetcher.kt index 0556d9d1f1..11ff6a277d 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/coil/MangaCoverFetcher.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/coil/MangaCoverFetcher.kt @@ -46,6 +46,7 @@ import java.io.IOException * Available request parameter: * - [USE_CUSTOM_COVER_KEY]: Use custom cover if set by user, default is true */ +@Suppress("LongParameterList") class MangaCoverFetcher( private val url: String?, private val isLibraryManga: Boolean, @@ -55,7 +56,7 @@ class MangaCoverFetcher( private val diskCacheKeyLazy: Lazy, private val sourceLazy: Lazy, private val callFactoryLazy: Lazy, - private val diskCacheLazy: Lazy, + private val imageLoader: ImageLoader, ) : Fetcher { private val diskCacheKey: String @@ -207,7 +208,7 @@ class MangaCoverFetcher( private fun moveSnapshotToCoverCache(snapshot: DiskCache.Snapshot, cacheFile: File?): File? { if (cacheFile == null) return null return try { - diskCacheLazy.value.run { + imageLoader.diskCache?.run { fileSystem.source(snapshot.data).use { input -> writeSourceToCoverCache(input, cacheFile) } @@ -248,7 +249,7 @@ class MangaCoverFetcher( private fun readFromDiskCache(): DiskCache.Snapshot? { return if (options.diskCachePolicy.readEnabled) { - diskCacheLazy.value.openSnapshot(diskCacheKey) + imageLoader.diskCache?.openSnapshot(diskCacheKey) } else { null } @@ -257,9 +258,10 @@ class MangaCoverFetcher( private fun writeToDiskCache( response: Response, ): DiskCache.Snapshot? { - val editor = diskCacheLazy.value.openEditor(diskCacheKey) ?: return null + val diskCache = imageLoader.diskCache + val editor = diskCache?.openEditor(diskCacheKey) ?: return null try { - diskCacheLazy.value.fileSystem.write(editor.data) { + diskCache.fileSystem.write(editor.data) { response.body.source().readAll(this) } return editor.commitAndOpenSnapshot() @@ -299,7 +301,6 @@ class MangaCoverFetcher( class MangaFactory( private val callFactoryLazy: Lazy, - private val diskCacheLazy: Lazy, ) : Fetcher.Factory { private val coverCache: CoverCache by injectLazy() @@ -312,17 +313,16 @@ class MangaCoverFetcher( options = options, coverFileLazy = lazy { coverCache.getCoverFile(data.thumbnailUrl) }, customCoverFileLazy = lazy { coverCache.getCustomCoverFile(data.id) }, - diskCacheKeyLazy = lazy { MangaKeyer().key(data, options) }, + diskCacheKeyLazy = lazy { imageLoader.components.key(data, options)!! }, sourceLazy = lazy { sourceManager.get(data.source) as? HttpSource }, callFactoryLazy = callFactoryLazy, - diskCacheLazy = diskCacheLazy, + imageLoader = imageLoader, ) } } class MangaCoverFactory( private val callFactoryLazy: Lazy, - private val diskCacheLazy: Lazy, ) : Fetcher.Factory { private val coverCache: CoverCache by injectLazy() @@ -335,10 +335,10 @@ class MangaCoverFetcher( options = options, coverFileLazy = lazy { coverCache.getCoverFile(data.url) }, customCoverFileLazy = lazy { coverCache.getCustomCoverFile(data.mangaId) }, - diskCacheKeyLazy = lazy { MangaCoverKeyer().key(data, options) }, + diskCacheKeyLazy = lazy { imageLoader.components.key(data, options)!! }, sourceLazy = lazy { sourceManager.get(data.sourceId) as? HttpSource }, callFactoryLazy = callFactoryLazy, - diskCacheLazy = diskCacheLazy, + imageLoader = imageLoader, ) } }