Convert metadata view to compose

app/src/main/java/exh/ui/metadata/MetadataViewAdapter.kt

@@ -1,48 +0,0 @@
-package exh.ui.metadata
-
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.recyclerview.widget.RecyclerView
-import eu.kanade.tachiyomi.databinding.MetadataViewItemBinding
-import eu.kanade.tachiyomi.util.system.copyToClipboard
-
-class MetadataViewAdapter :
-    RecyclerView.Adapter<MetadataViewAdapter.ViewHolder>() {
-
-    private lateinit var binding: MetadataViewItemBinding
-
-    var items: List<Pair<String, String>> = emptyList()
-        set(value) {
-            if (field !== value) {
-                field = value
-                notifyDataSetChanged()
-            }
-        }
-
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MetadataViewAdapter.ViewHolder {
-        binding = MetadataViewItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
-        return ViewHolder(binding.root)
-    }
-
-    // binds the data to the TextView in each cell
-    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        holder.bind(items[position].first, items[position].second)
-    }
-
-    // total number of cells
-    override fun getItemCount(): Int {
-        return items.size
-    }
-
-    // stores and recycles views as they are scrolled off screen
-    inner class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
-        fun bind(title: String, text: String) {
-            binding.infoTitle.text = title
-            binding.infoText.text = text
-            binding.infoText.setOnClickListener {
-                itemView.context.copyToClipboard(title, text)
-            }
-        }
-    }
-}

app/src/main/java/exh/ui/metadata/MetadataViewController.kt

@@ -1,24 +1,46 @@
 package exh.ui.metadata
 
 import android.os.Bundle
-import android.view.LayoutInflater
+import androidx.compose.foundation.layout.Row
-import android.view.View
+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.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
 import androidx.core.os.bundleOf
-import androidx.recyclerview.widget.LinearLayoutManager
-import dev.chrisbanes.insetter.applyInsetter
 import eu.kanade.domain.manga.interactor.GetManga
 import eu.kanade.domain.manga.model.Manga
-import eu.kanade.tachiyomi.databinding.MetadataViewControllerBinding
+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.topPaddingValues
+import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.SourceManager
-import eu.kanade.tachiyomi.ui.base.controller.NucleusController
+import eu.kanade.tachiyomi.ui.base.controller.FullComposeController
 import eu.kanade.tachiyomi.ui.manga.MangaController
-import exh.metadata.metadata.base.RaisedSearchMetadata
+import eu.kanade.tachiyomi.util.system.copyToClipboard
 import kotlinx.coroutines.runBlocking
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 
-class MetadataViewController : NucleusController<MetadataViewControllerBinding, MetadataViewPresenter> {
+class MetadataViewController : FullComposeController<MetadataViewPresenter> {
     constructor(manga: Manga) : super(
         bundleOf(
             MangaController.MANGA_EXTRA to manga.id,
@@ -35,45 +57,59 @@ class MetadataViewController : NucleusController<MetadataViewControllerBinding,
     @Suppress("unused")
     constructor(bundle: Bundle) : this(bundle.getLong(MangaController.MANGA_EXTRA))
 
-    var adapter: MetadataViewAdapter? = null
-
     var manga: Manga? = null
         private set
     var source: Source? = null
         private set
 
-    override fun getTitle(): String? {
-        return manga?.title
-    }
-
     override fun createPresenter(): MetadataViewPresenter {
-        return MetadataViewPresenter(
+        return MetadataViewPresenter(manga!!, source!!)
-            manga!!,
-            source!!,
-        )
     }
 
-    override fun createBinding(inflater: LayoutInflater) = MetadataViewControllerBinding.inflate(inflater)
+    @Composable
-
+    override fun ComposeContent() {
-    override fun onViewCreated(view: View) {
+        val state by presenter.state.collectAsState()
-        super.onViewCreated(view)
+        Scaffold(
-
+            topBar = { scrollBehavior ->
-        binding.recycler.applyInsetter {
+                AppBar(
-            type(navigationBars = true) {
+                    title = manga?.title,
-                padding()
+                    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 by derivedStateOf { state.meta.getExtraInfoPairs(context) }
+                    ScrollbarLazyColumn(
+                        contentPadding = paddingValues + WindowInsets.navigationBars.asPaddingValues() + topPaddingValues,
+                    ) {
+                        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),
+                                )
+                            }
+                        }
+                    }
+                }
             }
         }
-
-        if (manga == null || source == null) return
-        binding.recycler.layoutManager = LinearLayoutManager(view.context, LinearLayoutManager.VERTICAL, false)
-        adapter = MetadataViewAdapter()
-        binding.recycler.adapter = adapter
-        binding.recycler.setHasFixedSize(true)
-    }
-
-    fun onNextMangaInfo(meta: RaisedSearchMetadata?) {
-        val adapter = adapter ?: return
-        val context = view?.context ?: return
-        adapter.items = meta?.getExtraInfoPairs(context).orEmpty()
     }
 }

app/src/main/java/exh/ui/metadata/MetadataViewPresenter.kt

@@ -3,41 +3,46 @@ 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.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.online.MetadataSource
-import eu.kanade.tachiyomi.util.lang.launchIO
+import eu.kanade.tachiyomi.ui.base.presenter.BasePresenter
+import eu.kanade.tachiyomi.util.lang.launchNonCancellableIO
 import exh.metadata.metadata.base.RaisedSearchMetadata
 import exh.source.getMainSource
-import exh.ui.base.CoroutinePresenter
 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,
-    val preferences: PreferencesHelper = Injekt.get(),
     private val getFlatMetadataById: GetFlatMetadataById = Injekt.get(),
-) : CoroutinePresenter<MetadataViewController>() {
+) : BasePresenter<MetadataViewController>() {
-
+    private val _state = MutableStateFlow<MetadataViewState>(MetadataViewState.Loading)
-    val meta = MutableStateFlow<RaisedSearchMetadata?>(null)
+    val state = _state.asStateFlow()
 
     override fun onCreate(savedState: Bundle?) {
         super.onCreate(savedState)
 
-        launchIO {
+        presenterScope.launchNonCancellableIO {
-            val flatMetadata = getFlatMetadataById.await(manga.id) ?: return@launchIO
+            val metadataSource = source.getMainSource<MetadataSource<*, *>>()
-            val mainSource = source.getMainSource<MetadataSource<*, *>>()
+            if (metadataSource == null) {
-            if (mainSource != null) {
+                _state.value = MetadataViewState.SourceNotFound
-                meta.value = flatMetadata.raise(mainSource.metaClass)
+                return@launchNonCancellableIO
+            }
+
+            _state.value = when (val flatMetadata = getFlatMetadataById.await(manga.id)) {
+                null -> MetadataViewState.MetadataNotFound
+                else -> MetadataViewState.Success(flatMetadata.raise(metadataSource.metaClass))
             }
         }
-
-        meta
-            .inView { view, metadata ->
-                view.onNextMangaInfo(metadata)
-            }
-            .launch()
     }
 }
+
+sealed class MetadataViewState {
+    object Loading : MetadataViewState()
+    data class Success(val meta: RaisedSearchMetadata) : MetadataViewState()
+    object MetadataNotFound : MetadataViewState()
+    object SourceNotFound : MetadataViewState()
+}