Update filter header ui

app/src/main/kotlin/org/koitharu/kotatsu/local/data/LocalMangaRepository.kt

@@ -13,6 +13,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.runInterruptible
 import org.koitharu.kotatsu.core.model.isLocal
 import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.util.CompositeMutex
 import org.koitharu.kotatsu.core.util.ext.deleteAwait
 import org.koitharu.kotatsu.local.data.input.LocalMangaInput
@@ -28,6 +29,7 @@ import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
 import org.koitharu.kotatsu.util.ext.printStackTraceDebug
 import java.io.File
+import java.util.EnumSet
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -37,11 +39,20 @@ private const val MAX_PARALLELISM = 4
 class LocalMangaRepository @Inject constructor(
 	private val storageManager: LocalStorageManager,
 	@LocalStorageChanges private val localStorageChanges: MutableSharedFlow<LocalManga?>,
+	private val settings: AppSettings,
 ) : MangaRepository {
 
 	override val source = MangaSource.LOCAL
 	private val locks = CompositeMutex<Long>()
 
+	override val sortOrders: Set<SortOrder> = EnumSet.of(SortOrder.ALPHABETICAL, SortOrder.RATING, SortOrder.NEWEST)
+
+	override var defaultSortOrder: SortOrder
+		get() = settings.localListOrder
+		set(value) {
+			settings.localListOrder = value
+		}
+
 	override suspend fun getList(offset: Int, query: String): List<Manga> {
 		if (offset > 0) {
 			return emptyList()
@@ -137,8 +148,6 @@ class LocalMangaRepository @Inject constructor(
 		}.firstOrNull()?.getManga()
 	}
 
-	override val sortOrders = setOf(SortOrder.ALPHABETICAL, SortOrder.RATING)
-
 	override suspend fun getPageUrl(page: MangaPage) = page.url
 
 	override suspend fun getTags() = emptySet<MangaTag>()

app/src/main/kotlin/org/koitharu/kotatsu/local/ui/LocalListFragment.kt

@@ -5,7 +5,6 @@ import android.view.Menu
 import android.view.MenuItem
 import android.view.View
 import androidx.appcompat.view.ActionMode
-import androidx.appcompat.widget.PopupMenu
 import androidx.core.net.toFile
 import androidx.core.net.toUri
 import androidx.fragment.app.viewModels
@@ -16,11 +15,14 @@ import org.koitharu.kotatsu.core.ui.list.ListSelectionController
 import org.koitharu.kotatsu.core.util.ShareHelper
 import org.koitharu.kotatsu.core.util.ext.addMenuProvider
 import org.koitharu.kotatsu.core.util.ext.observeEvent
+import org.koitharu.kotatsu.core.util.ext.withArgs
 import org.koitharu.kotatsu.databinding.FragmentListBinding
+import org.koitharu.kotatsu.filter.ui.FilterSheetFragment
 import org.koitharu.kotatsu.list.ui.MangaListFragment
-import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.remotelist.ui.RemoteListFragment
 
-class LocalListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener {
+class LocalListFragment : MangaListFragment() {
 
 	override val viewModel by viewModels<LocalListViewModel>()
 
@@ -35,11 +37,7 @@ class LocalListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener
 	}
 
 	override fun onFilterClick(view: View?) {
-		super.onFilterClick(view)
-		val menu = PopupMenu(requireContext(), view ?: requireViewBinding().recyclerView)
-		menu.inflate(R.menu.popup_order)
-		menu.setOnMenuItemClickListener(this)
-		menu.show()
+		FilterSheetFragment.show(childFragmentManager)
 	}
 
 	override fun onScrolledToEnd() = Unit
@@ -67,17 +65,6 @@ class LocalListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener
 		}
 	}
 
-	override fun onMenuItemClick(item: MenuItem): Boolean {
-		val order = when (item.itemId) {
-			R.id.action_order_new -> SortOrder.NEWEST
-			R.id.action_order_abs -> SortOrder.ALPHABETICAL
-			R.id.action_order_rating -> SortOrder.RATING
-			else -> return false
-		}
-		viewModel.setSortOrder(order)
-		return true
-	}
-
 	private fun showDeletionConfirm(ids: Set<Long>, mode: ActionMode) {
 		MaterialAlertDialogBuilder(context ?: return)
 			.setTitle(R.string.delete_manga)
@@ -96,6 +83,8 @@ class LocalListFragment : MangaListFragment(), PopupMenu.OnMenuItemClickListener
 
 	companion object {
 
-		fun newInstance() = LocalListFragment()
+		fun newInstance() = LocalListFragment().withArgs(1) {
+			putSerializable(RemoteListFragment.ARG_SOURCE, MangaSource.LOCAL) // required by FilterCoordinator
+		}
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/local/ui/LocalListViewModel.kt

@@ -1,123 +1,57 @@
 package org.koitharu.kotatsu.local.ui
 
-import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.SavedStateHandle
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancelAndJoin
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.parser.MangaTagHighlighter
 import org.koitharu.kotatsu.core.prefs.AppSettings
-import org.koitharu.kotatsu.core.ui.widgets.ChipsView
 import org.koitharu.kotatsu.core.util.ext.MutableEventFlow
 import org.koitharu.kotatsu.core.util.ext.call
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
-import org.koitharu.kotatsu.history.data.HistoryRepository
-import org.koitharu.kotatsu.history.data.PROGRESS_NONE
+import org.koitharu.kotatsu.filter.ui.FilterCoordinator
 import org.koitharu.kotatsu.list.domain.ListExtraProvider
-import org.koitharu.kotatsu.list.ui.MangaListViewModel
 import org.koitharu.kotatsu.list.ui.model.EmptyState
-import org.koitharu.kotatsu.list.ui.model.ListHeader2
-import org.koitharu.kotatsu.list.ui.model.LoadingState
-import org.koitharu.kotatsu.list.ui.model.toErrorState
-import org.koitharu.kotatsu.list.ui.model.toUi
-import org.koitharu.kotatsu.local.data.LocalMangaRepository
 import org.koitharu.kotatsu.local.data.LocalStorageChanges
 import org.koitharu.kotatsu.local.domain.DeleteLocalMangaUseCase
 import org.koitharu.kotatsu.local.domain.model.LocalManga
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.parsers.model.SortOrder
-import org.koitharu.kotatsu.tracker.domain.TrackingRepository
-import java.util.LinkedList
+import org.koitharu.kotatsu.remotelist.ui.RemoteListViewModel
 import javax.inject.Inject
 
 @HiltViewModel
 class LocalListViewModel @Inject constructor(
-	private val repository: LocalMangaRepository,
-	private val historyRepository: HistoryRepository,
-	private val trackingRepository: TrackingRepository,
-	private val settings: AppSettings,
-	private val tagHighlighter: MangaTagHighlighter,
-	@LocalStorageChanges private val localStorageChanges: SharedFlow<LocalManga?>,
-	private val deleteLocalMangaUseCase: DeleteLocalMangaUseCase,
+	savedStateHandle: SavedStateHandle,
+	mangaRepositoryFactory: MangaRepository.Factory,
+	filter: FilterCoordinator,
+	tagHighlighter: MangaTagHighlighter,
+	settings: AppSettings,
 	downloadScheduler: DownloadWorker.Scheduler,
-) : MangaListViewModel(settings, downloadScheduler), ListExtraProvider {
+	listExtraProvider: ListExtraProvider,
+	private val deleteLocalMangaUseCase: DeleteLocalMangaUseCase,
+	@LocalStorageChanges private val localStorageChanges: SharedFlow<LocalManga?>,
+) : RemoteListViewModel(
+	savedStateHandle,
+	mangaRepositoryFactory,
+	filter,
+	tagHighlighter,
+	settings,
+	listExtraProvider,
+	downloadScheduler,
+) {
 
 	val onMangaRemoved = MutableEventFlow<Unit>()
-	val sortOrder = MutableStateFlow(settings.localListOrder)
-	private val listError = MutableStateFlow<Throwable?>(null)
-	private val mangaList = MutableStateFlow<List<Manga>?>(null)
-	private val selectedTags = MutableStateFlow<Set<MangaTag>>(emptySet())
-	private var refreshJob: Job? = null
-
-	override val content = combine(
-		mangaList,
-		listMode,
-		sortOrder,
-		selectedTags,
-		listError,
-	) { list, mode, order, tags, error ->
-		when {
-			error != null -> listOf(error.toErrorState(canRetry = true))
-			list == null -> listOf(LoadingState)
-			list.isEmpty() -> listOf(
-				EmptyState(
-					icon = R.drawable.ic_empty_local,
-					textPrimary = R.string.text_local_holder_primary,
-					textSecondary = R.string.text_local_holder_secondary,
-					actionStringRes = R.string._import,
-				),
-			)
-
-			else -> buildList(list.size + 1) {
-				add(createHeader(list, tags, order))
-				list.toUi(this, mode, this@LocalListViewModel, tagHighlighter)
-			}
-		}
-	}.stateIn(viewModelScope + Dispatchers.Default, SharingStarted.Eagerly, listOf(LoadingState))
 
 	init {
-		onRefresh()
 		launchJob(Dispatchers.Default) {
 			localStorageChanges
-				.collectLatest {
-					if (refreshJob?.isActive != true) {
-						doRefresh()
-					}
+				.collect {
+					loadList(filter.snapshot(), append = false).join()
 				}
 		}
 	}
 
-	override fun onUpdateFilter(tags: Set<MangaTag>) {
-		selectedTags.value = tags
-		onRefresh()
-	}
-
-	override fun onRefresh() {
-		val prevJob = refreshJob
-		refreshJob = launchLoadingJob(Dispatchers.Default) {
-			prevJob?.cancelAndJoin()
-			doRefresh()
-		}
-	}
-
-	override fun onRetry() = onRefresh()
-
-	fun setSortOrder(value: SortOrder) {
-		sortOrder.value = value
-		settings.localListOrder = value
-		onRefresh()
-	}
-
 	fun delete(ids: Set<Long>) {
 		launchLoadingJob(Dispatchers.Default) {
 			deleteLocalMangaUseCase(ids)
@@ -125,60 +59,12 @@ class LocalListViewModel @Inject constructor(
 		}
 	}
 
-	private suspend fun doRefresh() {
-		try {
-			listError.value = null
-			mangaList.value = repository.getList(0, selectedTags.value, sortOrder.value)
-		} catch (e: CancellationException) {
-			throw e
-		} catch (e: Throwable) {
-			listError.value = e
-		}
-	}
-
-	private fun createHeader(mangaList: List<Manga>, selectedTags: Set<MangaTag>, order: SortOrder): ListHeader2 {
-		val tags = HashMap<MangaTag, Int>()
-		for (item in mangaList) {
-			for (tag in item.tags) {
-				tags[tag] = tags[tag]?.plus(1) ?: 1
-			}
-		}
-		val topTags = tags.entries.sortedByDescending { it.value }.take(6)
-		val chips = LinkedList<ChipsView.ChipModel>()
-		for ((tag, _) in topTags) {
-			val model = ChipsView.ChipModel(
-				tint = 0,
-				title = tag.title,
-				isCheckable = true,
-				isChecked = tag in selectedTags,
-				data = tag,
-			)
-			if (model.isChecked) {
-				chips.addFirst(model)
-			} else {
-				chips.addLast(model)
-			}
-		}
-		return ListHeader2(
-			chips = chips,
-			sortOrder = order,
-			hasSelectedTags = selectedTags.isNotEmpty(),
+	override fun createEmptyState(canResetFilter: Boolean): EmptyState {
+		return EmptyState(
+			icon = R.drawable.ic_empty_local,
+			textPrimary = R.string.text_local_holder_primary,
+			textSecondary = R.string.text_local_holder_secondary,
+			actionStringRes = R.string._import,
 		)
 	}
-
-	override suspend fun getCounter(mangaId: Long): Int {
-		return if (settings.isTrackerEnabled) {
-			trackingRepository.getNewChaptersCount(mangaId)
-		} else {
-			0
-		}
-	}
-
-	override suspend fun getProgress(mangaId: Long): Float {
-		return if (settings.isReadingIndicatorsEnabled) {
-			historyRepository.getProgress(mangaId)
-		} else {
-			PROGRESS_NONE
-		}
-	}
 }