Use Voyager for a few screens

2022-11-26 13:36:06 -05:00
parent bf9b2ca2ff
commit 7df12c68fd
13 changed files with 333 additions and 371 deletions
@@ -1,128 +1,30 @@
 package exh.ui.metadata

 import android.os.Bundle
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.navigationBars
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.items
-import androidx.compose.material3.LocalContentColor
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.unit.dp
 import androidx.core.os.bundleOf
-import eu.kanade.domain.manga.interactor.GetManga
+import cafe.adriel.voyager.navigator.Navigator
 import eu.kanade.domain.manga.model.Manga
-import eu.kanade.presentation.components.AppBar
-import eu.kanade.presentation.components.EmptyScreen
-import eu.kanade.presentation.components.LoadingScreen
-import eu.kanade.presentation.components.Scaffold
-import eu.kanade.presentation.components.ScrollbarLazyColumn
-import eu.kanade.presentation.util.clickableNoIndication
-import eu.kanade.presentation.util.plus
-import eu.kanade.presentation.util.topSmallPaddingValues
-import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.source.Source
-import eu.kanade.tachiyomi.source.SourceManager
-import eu.kanade.tachiyomi.ui.base.controller.FullComposeController
-import eu.kanade.tachiyomi.ui.manga.MangaController
-import eu.kanade.tachiyomi.util.system.copyToClipboard
-import kotlinx.coroutines.runBlocking
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
+import eu.kanade.tachiyomi.ui.base.controller.BasicFullComposeController

-class MetadataViewController : FullComposeController<MetadataViewPresenter> {
+class MetadataViewController : BasicFullComposeController {
    constructor(manga: Manga) : super(
        bundleOf(
-            MangaController.MANGA_EXTRA to manga.id,
+            MANGA_EXTRA to manga.id,
+            SOURCE_EXTRA to manga.source,
        ),
-    ) {
-        this.manga = manga
-        source = Injekt.get<SourceManager>().getOrStub(manga.source)
-    }
-
-    constructor(mangaId: Long) : this(
-        runBlocking { Injekt.get<GetManga>().await(mangaId)!! },
    )

    @Suppress("unused")
-    constructor(bundle: Bundle) : this(bundle.getLong(MangaController.MANGA_EXTRA))
-
-    var manga: Manga? = null
-        private set
-    var source: Source? = null
-        private set
-
-    override fun createPresenter(): MetadataViewPresenter {
-        return MetadataViewPresenter(manga!!, source!!)
-    }
+    constructor(bundle: Bundle) : super(bundle)

    @Composable
    override fun ComposeContent() {
-        val state by presenter.state.collectAsState()
-        Scaffold(
-            topBar = { scrollBehavior ->
-                AppBar(
-                    title = manga?.title,
-                    navigateUp = router::popCurrentController,
-                    scrollBehavior = scrollBehavior,
-                )
-            },
-        ) { paddingValues ->
-            when (val state = state) {
-                MetadataViewState.Loading -> LoadingScreen()
-                MetadataViewState.MetadataNotFound -> EmptyScreen(R.string.no_results_found)
-                MetadataViewState.SourceNotFound -> EmptyScreen(R.string.source_empty_screen)
-                is MetadataViewState.Success -> {
-                    val context = LocalContext.current
-                    val items = remember(state.meta) { state.meta.getExtraInfoPairs(context) }
-                    ScrollbarLazyColumn(
-                        contentPadding = paddingValues + WindowInsets.navigationBars.asPaddingValues() + topSmallPaddingValues,
-                    ) {
-                        items(items) { (title, text) ->
-                            Row(
-                                Modifier
-                                    .fillMaxWidth()
-                                    .clickableNoIndication(
-                                        onLongClick = {
-                                            context.copyToClipboard(
-                                                title,
-                                                text,
-                                            )
-                                        },
-                                        onClick = {},
-                                    )
-                                    .padding(vertical = 8.dp),
-                            ) {
-                                Text(
-                                    title,
-                                    modifier = Modifier
-                                        .width(140.dp)
-                                        .padding(start = 16.dp),
-                                    style = MaterialTheme.typography.bodyMedium,
-                                )
-                                Text(
-                                    text,
-                                    modifier = Modifier
-                                        .fillMaxWidth()
-                                        .padding(start = 8.dp, end = 8.dp),
-                                    style = MaterialTheme.typography.bodyMedium,
-                                    color = LocalContentColor.current.copy(alpha = 0.7F),
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        Navigator(screen = MetadataViewScreen(args.getLong(MANGA_EXTRA), args.getLong(SOURCE_EXTRA)))
+    }
+
+    companion object {
+        const val MANGA_EXTRA = "manga"
+        const val SOURCE_EXTRA = "source"
    }
 }
@@ -1,48 +0,0 @@
-package exh.ui.metadata
-
-import android.os.Bundle
-import eu.kanade.domain.manga.interactor.GetFlatMetadataById
-import eu.kanade.domain.manga.model.Manga
-import eu.kanade.tachiyomi.source.Source
-import eu.kanade.tachiyomi.source.online.MetadataSource
-import eu.kanade.tachiyomi.ui.base.presenter.BasePresenter
-import eu.kanade.tachiyomi.util.lang.launchNonCancellable
-import exh.metadata.metadata.base.RaisedSearchMetadata
-import exh.source.getMainSource
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
-
-class MetadataViewPresenter(
-    val manga: Manga,
-    val source: Source,
-    private val getFlatMetadataById: GetFlatMetadataById = Injekt.get(),
-) : BasePresenter<MetadataViewController>() {
-    private val _state = MutableStateFlow<MetadataViewState>(MetadataViewState.Loading)
-    val state = _state.asStateFlow()
-
-    override fun onCreate(savedState: Bundle?) {
-        super.onCreate(savedState)
-
-        presenterScope.launchNonCancellable {
-            val metadataSource = source.getMainSource<MetadataSource<*, *>>()
-            if (metadataSource == null) {
-                _state.value = MetadataViewState.SourceNotFound
-                return@launchNonCancellable
-            }
-
-            _state.value = when (val flatMetadata = getFlatMetadataById.await(manga.id)) {
-                null -> MetadataViewState.MetadataNotFound
-                else -> MetadataViewState.Success(flatMetadata.raise(metadataSource.metaClass))
-            }
-        }
-    }
-}
-
-sealed class MetadataViewState {
-    object Loading : MetadataViewState()
-    data class Success(val meta: RaisedSearchMetadata) : MetadataViewState()
-    object MetadataNotFound : MetadataViewState()
-    object SourceNotFound : MetadataViewState()
-}
@@ -0,0 +1,100 @@
+package exh.ui.metadata
+
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.navigationBars
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.core.screen.Screen
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.components.EmptyScreen
+import eu.kanade.presentation.components.LoadingScreen
+import eu.kanade.presentation.components.Scaffold
+import eu.kanade.presentation.components.ScrollbarLazyColumn
+import eu.kanade.presentation.util.clickableNoIndication
+import eu.kanade.presentation.util.plus
+import eu.kanade.presentation.util.topSmallPaddingValues
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.util.system.copyToClipboard
+
+class MetadataViewScreen(private val mangaId: Long, private val sourceId: Long) : Screen {
+
+    @Composable
+    override fun Content() {
+        val screenModel = rememberScreenModel { MetadataViewScreenModel(mangaId, sourceId) }
+        val navigator = LocalNavigator.currentOrThrow
+
+        val state by screenModel.state.collectAsState()
+        Scaffold(
+            topBar = { scrollBehavior ->
+                AppBar(
+                    title = screenModel.manga.collectAsState().value?.title,
+                    navigateUp = navigator::pop,
+                    scrollBehavior = scrollBehavior,
+                )
+            },
+        ) { paddingValues ->
+            when (val state = state) {
+                MetadataViewState.Loading -> LoadingScreen()
+                MetadataViewState.MetadataNotFound -> EmptyScreen(R.string.no_results_found)
+                MetadataViewState.SourceNotFound -> EmptyScreen(R.string.source_empty_screen)
+                is MetadataViewState.Success -> {
+                    val context = LocalContext.current
+                    val items = remember(state.meta) { state.meta.getExtraInfoPairs(context) }
+                    ScrollbarLazyColumn(
+                        contentPadding = paddingValues + WindowInsets.navigationBars.asPaddingValues() + topSmallPaddingValues,
+                    ) {
+                        items(items) { (title, text) ->
+                            Row(
+                                Modifier
+                                    .fillMaxWidth()
+                                    .clickableNoIndication(
+                                        onLongClick = {
+                                            context.copyToClipboard(
+                                                title,
+                                                text,
+                                            )
+                                        },
+                                        onClick = {},
+                                    )
+                                    .padding(vertical = 8.dp),
+                            ) {
+                                Text(
+                                    title,
+                                    modifier = Modifier
+                                        .width(140.dp)
+                                        .padding(start = 16.dp),
+                                    style = MaterialTheme.typography.bodyMedium,
+                                )
+                                Text(
+                                    text,
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .padding(start = 8.dp, end = 8.dp),
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    color = LocalContentColor.current.copy(alpha = 0.7F),
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,55 @@
+package exh.ui.metadata
+
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.coroutineScope
+import eu.kanade.domain.manga.interactor.GetFlatMetadataById
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.tachiyomi.source.SourceManager
+import eu.kanade.tachiyomi.source.online.MetadataSource
+import eu.kanade.tachiyomi.util.lang.launchIO
+import exh.metadata.metadata.base.RaisedSearchMetadata
+import exh.source.getMainSource
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class MetadataViewScreenModel(
+    val mangaId: Long,
+    val sourceId: Long,
+    private val getFlatMetadataById: GetFlatMetadataById = Injekt.get(),
+    private val sourceManager: SourceManager = Injekt.get(),
+    private val getManga: GetManga = Injekt.get(),
+) : StateScreenModel<MetadataViewState>(MetadataViewState.Loading) {
+    private val _manga = MutableStateFlow<Manga?>(null)
+    val manga = _manga.asStateFlow()
+
+    init {
+        coroutineScope.launchIO {
+            _manga.value = getManga.await(mangaId)
+        }
+    }
+
+    init {
+        coroutineScope.launchIO {
+            val metadataSource = sourceManager.get(sourceId)?.getMainSource<MetadataSource<*, *>>()
+            if (metadataSource == null) {
+                mutableState.value = MetadataViewState.SourceNotFound
+                return@launchIO
+            }
+
+            mutableState.value = when (val flatMetadata = getFlatMetadataById.await(mangaId)) {
+                null -> MetadataViewState.MetadataNotFound
+                else -> MetadataViewState.Success(flatMetadata.raise(metadataSource.metaClass))
+            }
+        }
+    }
+}
+
+sealed class MetadataViewState {
+    object Loading : MetadataViewState()
+    data class Success(val meta: RaisedSearchMetadata) : MetadataViewState()
+    object MetadataNotFound : MetadataViewState()
+    object SourceNotFound : MetadataViewState()
+}