Refactor Kanade architecture and playback flows

app/build.gradle.kts

@@ -51,6 +51,7 @@ dependencies {
     implementation(libs.androidx.palette.ktx)
     implementation(libs.androidx.datastore.preferences)
     implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.lifecycle.runtime.compose)
     implementation(libs.androidx.lifecycle.process)
     implementation(libs.androidx.lifecycle.viewmodel.compose)
     implementation(libs.androidx.activity.compose)

app/src/main/AndroidManifest.xml

@@ -12,6 +12,7 @@
     <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
 
     <application
+        android:name=".KanadeApplication"
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"

app/src/main/java/org/parallel_sekai/kanade/KanadeAppContainer.kt

@@ -0,0 +1,31 @@
+package org.parallel_sekai.kanade
+
+import org.parallel_sekai.kanade.ui.screens.player.PlayerViewModel
+import org.parallel_sekai.kanade.ui.screens.search.SearchViewModel
+import org.parallel_sekai.kanade.ui.screens.settings.SettingsViewModel
+
+class KanadeAppContainer(
+    services: KanadeAppServices,
+) {
+    val settingsRepository = services.settingsRepository
+    val lyricGetterManager = services.lyricGetterManager
+    val playbackRepository = services.playbackRepository
+    val imageLoader = services.imageLoader
+
+    val playerViewModel =
+        PlayerViewModel(
+            playbackRepository = playbackRepository,
+            settingsRepository = settingsRepository,
+            applicationContext = playbackRepository.applicationContext,
+            imageLoader = imageLoader,
+            lyricGetterManager = lyricGetterManager,
+        )
+
+    val settingsViewModel =
+        SettingsViewModel(
+            repository = settingsRepository,
+            lyricGetterManager = lyricGetterManager,
+            applicationContext = playbackRepository.applicationContext,
+        )
+    val searchViewModel = SearchViewModel(playbackRepository, settingsRepository)
+}

app/src/main/java/org/parallel_sekai/kanade/KanadeAppServices.kt

@@ -0,0 +1,66 @@
+package org.parallel_sekai.kanade
+
+import android.content.Context
+import coil.ImageLoader
+import coil.disk.DiskCache
+import coil.memory.MemoryCache
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.stateIn
+import org.parallel_sekai.kanade.data.repository.PlaybackRepository
+import org.parallel_sekai.kanade.data.repository.SettingsRepository
+import org.parallel_sekai.kanade.data.source.SourceManager
+import org.parallel_sekai.kanade.data.utils.CacheManager
+import org.parallel_sekai.kanade.data.utils.LyricGetterManager
+
+class KanadeAppServices(
+    context: Context,
+) {
+    private val applicationContext = context.applicationContext
+
+    val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    val settingsRepository = SettingsRepository(applicationContext)
+    val lyricGetterManager = LyricGetterManager(applicationContext)
+
+    val maxCacheSize =
+        settingsRepository.maxCacheSizeFlow.stateIn(
+            scope = applicationScope,
+            started = SharingStarted.Eagerly,
+            initialValue = CacheManager.DEFAULT_MAX_CACHE_SIZE,
+        )
+
+    val sourceManager =
+        SourceManager(
+            context = applicationContext,
+            settingsRepository = settingsRepository,
+            scope = applicationScope,
+        )
+
+    val playbackRepository =
+        PlaybackRepository(
+            applicationContext = applicationContext,
+            settingsRepository = settingsRepository,
+            scope = applicationScope,
+            sourceManager = sourceManager,
+        )
+
+    val imageLoader =
+        ImageLoader
+            .Builder(applicationContext)
+            .memoryCache {
+                MemoryCache
+                    .Builder(applicationContext)
+                    .maxSizePercent(0.25)
+                    .build()
+            }.diskCache {
+                DiskCache
+                    .Builder()
+                    .directory(CacheManager.getImageCacheDir(applicationContext))
+                    .maxSizePercent(0.02)
+                    .build()
+            }.respectCacheHeaders(false)
+            .build()
+}

app/src/main/java/org/parallel_sekai/kanade/KanadeApplication.kt

@@ -0,0 +1,18 @@
+package org.parallel_sekai.kanade
+
+import android.app.Application
+import android.content.Context
+
+class KanadeApplication : Application() {
+    lateinit var services: KanadeAppServices
+        private set
+
+    override fun onCreate() {
+        super.onCreate()
+        services = KanadeAppServices(this)
+    }
+
+    companion object {
+        fun services(context: Context): KanadeAppServices = (context.applicationContext as KanadeApplication).services
+    }
+}