Use Voyager for a few screens

app/src/main/java/exh/pagepreview/PagePreviewController.kt

@@ -2,13 +2,11 @@ package exh.pagepreview
 
 import android.os.Bundle
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.core.os.bundleOf
-import eu.kanade.tachiyomi.ui.base.controller.FullComposeController
-import eu.kanade.tachiyomi.ui.reader.ReaderActivity
-import exh.pagepreview.components.PagePreviewScreen
+import cafe.adriel.voyager.navigator.Navigator
+import eu.kanade.tachiyomi.ui.base.controller.BasicFullComposeController
 
-class PagePreviewController : FullComposeController<PagePreviewPresenter> {
+class PagePreviewController : BasicFullComposeController {
 
     @Suppress("unused")
     constructor(bundle: Bundle? = null) : super(bundle)
@@ -17,26 +15,9 @@ class PagePreviewController : FullComposeController<PagePreviewPresenter> {
         bundleOf(MANGA_ID to mangaId),
     )
 
-    override fun createPresenter() = PagePreviewPresenter(args.getLong(MANGA_ID, -1))
-
     @Composable
     override fun ComposeContent() {
-        PagePreviewScreen(
-            state = presenter.state.collectAsState().value,
-            pageDialogOpen = presenter.pageDialogOpen,
-            onPageSelected = presenter::moveToPage,
-            onOpenPage = this::openPage,
-            onOpenPageDialog = { presenter.pageDialogOpen = true },
-            onDismissPageDialog = { presenter.pageDialogOpen = false },
-            navigateUp = router::popCurrentController,
-        )
-    }
-
-    fun openPage(page: Int) {
-        val state = presenter.state.value as? PagePreviewState.Success ?: return
-        activity?.run {
-            startActivity(ReaderActivity.newIntent(this, state.manga.id, state.chapter.id, page))
-        }
+        Navigator(screen = PagePreviewScreen(args.getLong(MANGA_ID, -1)))
     }
 
     companion object {

app/src/main/java/exh/pagepreview/PagePreviewScreen.kt

@@ -0,0 +1,40 @@
+package exh.pagepreview
+
+import android.content.Context
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.platform.LocalContext
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.core.screen.Screen
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.util.LocalRouter
+import eu.kanade.tachiyomi.ui.reader.ReaderActivity
+import exh.pagepreview.components.PagePreviewScreen
+
+class PagePreviewScreen(private val mangaId: Long) : Screen {
+
+    @Composable
+    override fun Content() {
+        val screenModel = rememberScreenModel { PagePreviewScreenModel(mangaId) }
+        val context = LocalContext.current
+        val state by screenModel.state.collectAsState()
+        val router = LocalRouter.currentOrThrow
+        PagePreviewScreen(
+            state = state,
+            pageDialogOpen = screenModel.pageDialogOpen,
+            onPageSelected = screenModel::moveToPage,
+            onOpenPage = { openPage(context, state, it) },
+            onOpenPageDialog = { screenModel.pageDialogOpen = true },
+            onDismissPageDialog = { screenModel.pageDialogOpen = false },
+            navigateUp = router::popCurrentController,
+        )
+    }
+
+    fun openPage(context: Context, state: PagePreviewState, page: Int) {
+        if (state !is PagePreviewState.Success) return
+        context.run {
+            startActivity(ReaderActivity.newIntent(this, state.manga.id, state.chapter.id, page))
+        }
+    }
+}

app/src/main/java/exh/pagepreview/PagePreviewScreenModel.kt

@@ -1,9 +1,10 @@
 package exh.pagepreview
 
-import android.os.Bundle
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.coroutineScope
 import eu.kanade.domain.chapter.model.Chapter
 import eu.kanade.domain.history.interactor.GetNextChapters
 import eu.kanade.domain.manga.interactor.GetManga
@@ -12,10 +13,8 @@ import eu.kanade.domain.manga.model.Manga
 import eu.kanade.domain.manga.model.PagePreview
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.SourceManager
-import eu.kanade.tachiyomi.ui.base.presenter.BasePresenter
 import eu.kanade.tachiyomi.util.lang.launchIO
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.onEach
@@ -23,29 +22,24 @@ import kotlinx.coroutines.flow.update
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 
-class PagePreviewPresenter(
+class PagePreviewScreenModel(
     private val mangaId: Long,
     private val getPagePreviews: GetPagePreviews = Injekt.get(),
     private val getManga: GetManga = Injekt.get(),
     private val getNextChapters: GetNextChapters = Injekt.get(),
     private val sourceManager: SourceManager = Injekt.get(),
-) : BasePresenter<PagePreviewController>() {
-
-    private val _state = MutableStateFlow<PagePreviewState>(PagePreviewState.Loading)
-    val state = _state.asStateFlow()
+) : StateScreenModel<PagePreviewState>(PagePreviewState.Loading) {
 
     private val page = MutableStateFlow(1)
 
     var pageDialogOpen by mutableStateOf(false)
 
-    override fun onCreate(savedState: Bundle?) {
-        super.onCreate(savedState)
-
-        presenterScope.launchIO {
+    init {
+        coroutineScope.launchIO {
             val manga = getManga.await(mangaId)!!
             val chapter = getNextChapters.await(mangaId, onlyUnread = false).lastOrNull()
             if (chapter == null) {
-                _state.update {
+                mutableState.update {
                     PagePreviewState.Error(Exception("No chapters found"))
                 }
                 return@launchIO
@@ -56,10 +50,10 @@ class PagePreviewPresenter(
                     when (
                         val previews = getPagePreviews.await(manga, source, page)
                     ) {
-                        is GetPagePreviews.Result.Error -> _state.update {
+                        is GetPagePreviews.Result.Error -> mutableState.update {
                             PagePreviewState.Error(previews.error)
                         }
-                        is GetPagePreviews.Result.Success -> _state.update {
+                        is GetPagePreviews.Result.Success -> mutableState.update {
                             when (it) {
                                 PagePreviewState.Loading, is PagePreviewState.Error -> {
                                     PagePreviewState.Success(
@@ -84,7 +78,7 @@ class PagePreviewPresenter(
                     }
                 }
                 .catch { e ->
-                    _state.update {
+                    mutableState.update {
                         PagePreviewState.Error(e)
                     }
                 }