|
|
|
|
@ -1,540 +1,393 @@
|
|
|
|
|
package org.koitharu.kotatsu.filter.ui
|
|
|
|
|
|
|
|
|
|
import android.view.View
|
|
|
|
|
import androidx.lifecycle.SavedStateHandle
|
|
|
|
|
import dagger.hilt.android.ViewModelLifecycle
|
|
|
|
|
import dagger.hilt.android.scopes.ViewModelScoped
|
|
|
|
|
import kotlinx.coroutines.CoroutineStart
|
|
|
|
|
import kotlinx.coroutines.Dispatchers
|
|
|
|
|
import kotlinx.coroutines.Job
|
|
|
|
|
import kotlinx.coroutines.async
|
|
|
|
|
import kotlinx.coroutines.cancelAndJoin
|
|
|
|
|
import kotlinx.coroutines.flow.Flow
|
|
|
|
|
import kotlinx.coroutines.flow.MutableStateFlow
|
|
|
|
|
import kotlinx.coroutines.flow.SharingStarted
|
|
|
|
|
import kotlinx.coroutines.flow.StateFlow
|
|
|
|
|
import kotlinx.coroutines.flow.asStateFlow
|
|
|
|
|
import kotlinx.coroutines.flow.combine
|
|
|
|
|
import kotlinx.coroutines.flow.distinctUntilChanged
|
|
|
|
|
import kotlinx.coroutines.flow.distinctUntilChangedBy
|
|
|
|
|
import kotlinx.coroutines.flow.flow
|
|
|
|
|
import kotlinx.coroutines.flow.flowOf
|
|
|
|
|
import kotlinx.coroutines.flow.map
|
|
|
|
|
import kotlinx.coroutines.flow.stateIn
|
|
|
|
|
import kotlinx.coroutines.flow.update
|
|
|
|
|
import kotlinx.coroutines.launch
|
|
|
|
|
import kotlinx.coroutines.plus
|
|
|
|
|
import org.koitharu.kotatsu.R
|
|
|
|
|
import org.koitharu.kotatsu.core.model.GenericSortOrder
|
|
|
|
|
import org.koitharu.kotatsu.core.model.MangaSource
|
|
|
|
|
import org.koitharu.kotatsu.core.model.SortDirection
|
|
|
|
|
import org.koitharu.kotatsu.core.parser.MangaDataRepository
|
|
|
|
|
import org.koitharu.kotatsu.core.parser.MangaRepository
|
|
|
|
|
import org.koitharu.kotatsu.core.ui.model.direction
|
|
|
|
|
import org.koitharu.kotatsu.core.ui.widgets.ChipsView
|
|
|
|
|
import org.koitharu.kotatsu.core.util.LocaleComparator
|
|
|
|
|
import org.koitharu.kotatsu.core.util.ext.asArrayList
|
|
|
|
|
import org.koitharu.kotatsu.core.util.ext.asFlow
|
|
|
|
|
import org.koitharu.kotatsu.core.util.ext.lifecycleScope
|
|
|
|
|
import org.koitharu.kotatsu.core.util.ext.printStackTraceDebug
|
|
|
|
|
import org.koitharu.kotatsu.core.util.ext.sortedByOrdinal
|
|
|
|
|
import org.koitharu.kotatsu.filter.ui.model.FilterHeaderModel
|
|
|
|
|
import org.koitharu.kotatsu.core.util.ext.sortedWithSafe
|
|
|
|
|
import org.koitharu.kotatsu.filter.ui.model.FilterProperty
|
|
|
|
|
import org.koitharu.kotatsu.filter.ui.model.TagCatalogItem
|
|
|
|
|
import org.koitharu.kotatsu.list.ui.model.ErrorFooter
|
|
|
|
|
import org.koitharu.kotatsu.list.ui.model.ListHeader
|
|
|
|
|
import org.koitharu.kotatsu.list.ui.model.ListModel
|
|
|
|
|
import org.koitharu.kotatsu.list.ui.model.LoadingFooter
|
|
|
|
|
import org.koitharu.kotatsu.list.ui.model.LoadingState
|
|
|
|
|
import org.koitharu.kotatsu.list.ui.model.toErrorFooter
|
|
|
|
|
import org.koitharu.kotatsu.filter.ui.tags.TagTitleComparator
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.ContentRating
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.ContentType
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.Demographic
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.MangaListFilter
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.MangaParserSource
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.MangaSource
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.MangaState
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.MangaTag
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.SortOrder
|
|
|
|
|
import org.koitharu.kotatsu.parsers.model.YEAR_MIN
|
|
|
|
|
import org.koitharu.kotatsu.parsers.util.SuspendLazy
|
|
|
|
|
import org.koitharu.kotatsu.parsers.util.runCatchingCancellable
|
|
|
|
|
import org.koitharu.kotatsu.remotelist.ui.RemoteListFragment
|
|
|
|
|
import org.koitharu.kotatsu.search.domain.MangaSearchRepository
|
|
|
|
|
import java.text.Collator
|
|
|
|
|
import java.util.EnumSet
|
|
|
|
|
import java.util.LinkedList
|
|
|
|
|
import java.util.Calendar
|
|
|
|
|
import java.util.Locale
|
|
|
|
|
import java.util.TreeSet
|
|
|
|
|
import javax.inject.Inject
|
|
|
|
|
|
|
|
|
|
@ViewModelScoped
|
|
|
|
|
class FilterCoordinator @Inject constructor(
|
|
|
|
|
savedStateHandle: SavedStateHandle,
|
|
|
|
|
mangaRepositoryFactory: MangaRepository.Factory,
|
|
|
|
|
dataRepository: MangaDataRepository,
|
|
|
|
|
private val searchRepository: MangaSearchRepository,
|
|
|
|
|
lifecycle: ViewModelLifecycle,
|
|
|
|
|
) : MangaFilter {
|
|
|
|
|
) {
|
|
|
|
|
|
|
|
|
|
private val coroutineScope = lifecycle.lifecycleScope
|
|
|
|
|
private val coroutineScope = lifecycle.lifecycleScope + Dispatchers.Default
|
|
|
|
|
private val repository = mangaRepositoryFactory.create(MangaSource(savedStateHandle[RemoteListFragment.ARG_SOURCE]))
|
|
|
|
|
private val currentState = MutableStateFlow(
|
|
|
|
|
MangaListFilter.Advanced(
|
|
|
|
|
sortOrder = repository.defaultSortOrder,
|
|
|
|
|
tags = emptySet(),
|
|
|
|
|
tagsExclude = emptySet(),
|
|
|
|
|
locale = null,
|
|
|
|
|
states = emptySet(),
|
|
|
|
|
contentRating = emptySet(),
|
|
|
|
|
),
|
|
|
|
|
)
|
|
|
|
|
private val localTags = SuspendLazy {
|
|
|
|
|
dataRepository.findTags(repository.source)
|
|
|
|
|
}
|
|
|
|
|
private val tagsFlow = flow {
|
|
|
|
|
val localTags = localTags.get()
|
|
|
|
|
emit(PendingData(localTags, isLoading = true, error = null))
|
|
|
|
|
tryLoadTags()
|
|
|
|
|
.onSuccess { remoteTags ->
|
|
|
|
|
emit(PendingData(mergeTags(remoteTags, localTags), isLoading = false, error = null))
|
|
|
|
|
}.onFailure {
|
|
|
|
|
emit(PendingData(localTags, isLoading = false, error = it))
|
|
|
|
|
}
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.WhileSubscribed(5000), PendingData(emptySet(), true, null))
|
|
|
|
|
private var availableTagsDeferred = loadTagsAsync()
|
|
|
|
|
private var availableLocalesDeferred = loadLocalesAsync()
|
|
|
|
|
private var allTagsLoadJob: Job? = null
|
|
|
|
|
|
|
|
|
|
override val allTags = MutableStateFlow<List<ListModel>>(listOf(LoadingState))
|
|
|
|
|
get() {
|
|
|
|
|
if (allTagsLoadJob == null || field.value.any { it is ErrorFooter }) {
|
|
|
|
|
loadAllTags()
|
|
|
|
|
}
|
|
|
|
|
return field
|
|
|
|
|
}
|
|
|
|
|
private val sourceLocale = (repository.source as? MangaParserSource)?.locale
|
|
|
|
|
|
|
|
|
|
private val currentListFilter = MutableStateFlow(MangaListFilter.EMPTY)
|
|
|
|
|
private val currentSortOrder = MutableStateFlow(repository.defaultSortOrder)
|
|
|
|
|
|
|
|
|
|
private val availableSortOrders = repository.sortOrders
|
|
|
|
|
private val capabilities = repository.filterCapabilities
|
|
|
|
|
private val filterOptions = SuspendLazy { repository.getFilterOptions() }
|
|
|
|
|
|
|
|
|
|
override val filterTags: StateFlow<FilterProperty<MangaTag>> = combine(
|
|
|
|
|
currentState.distinctUntilChangedBy { it.tags },
|
|
|
|
|
getTopTagsAsFlow(currentState.map { it.tags }, 16),
|
|
|
|
|
) { state, tags ->
|
|
|
|
|
val mangaSource: MangaSource
|
|
|
|
|
get() = repository.source
|
|
|
|
|
|
|
|
|
|
val isFilterApplied: Boolean
|
|
|
|
|
get() = !currentListFilter.value.isEmpty()
|
|
|
|
|
|
|
|
|
|
val sortOrder: StateFlow<FilterProperty<SortOrder>> = currentSortOrder.map { selected ->
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = tags.items.asArrayList(),
|
|
|
|
|
selectedItems = state.tags,
|
|
|
|
|
isLoading = tags.isLoading,
|
|
|
|
|
error = tags.error,
|
|
|
|
|
availableItems = availableSortOrders.sortedByOrdinal(),
|
|
|
|
|
selectedItem = selected,
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope + Dispatchers.Default, SharingStarted.Lazily, loadingProperty())
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
|
|
|
|
|
val tags: StateFlow<FilterProperty<MangaTag>> = combine(
|
|
|
|
|
getTopTags(TAGS_LIMIT),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.tags },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.addFirstDistinct(selected.tags),
|
|
|
|
|
selectedItems = selected.tags,
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
|
|
|
|
|
override val filterTagsExcluded: StateFlow<FilterProperty<MangaTag>> = if (repository.isTagsExclusionSupported) {
|
|
|
|
|
val tagsExcluded: StateFlow<FilterProperty<MangaTag>> = if (capabilities.isTagsExclusionSupported) {
|
|
|
|
|
combine(
|
|
|
|
|
currentState.distinctUntilChangedBy { it.tagsExclude },
|
|
|
|
|
getBottomTagsAsFlow(4),
|
|
|
|
|
) { state, tags ->
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = tags.items.asArrayList(),
|
|
|
|
|
selectedItems = state.tagsExclude,
|
|
|
|
|
isLoading = tags.isLoading,
|
|
|
|
|
error = tags.error,
|
|
|
|
|
getBottomTags(TAGS_LIMIT),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.tagsExclude },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.addFirstDistinct(selected.tagsExclude),
|
|
|
|
|
selectedItems = selected.tagsExclude,
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
} else {
|
|
|
|
|
MutableStateFlow(FilterProperty.EMPTY)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
val states: StateFlow<FilterProperty<MangaState>> = combine(
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.states },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.availableStates.sortedByOrdinal(),
|
|
|
|
|
selectedItems = selected.states,
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
|
|
|
|
|
val contentRating: StateFlow<FilterProperty<ContentRating>> = combine(
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.contentRating },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.availableContentRating.sortedByOrdinal(),
|
|
|
|
|
selectedItems = selected.contentRating,
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
|
|
|
|
|
val contentTypes: StateFlow<FilterProperty<ContentType>> = combine(
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.types },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.availableContentTypes.sortedByOrdinal(),
|
|
|
|
|
selectedItems = selected.types,
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
|
|
|
|
|
val demographics: StateFlow<FilterProperty<Demographic>> = combine(
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.demographics },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.availableDemographics.sortedByOrdinal(),
|
|
|
|
|
selectedItems = selected.demographics,
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
|
|
|
|
|
val locale: StateFlow<FilterProperty<Locale?>> = combine(
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.locale },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
|
|
|
|
|
selectedItems = setOfNotNull(selected.locale),
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
|
|
|
|
|
val originalLocale: StateFlow<FilterProperty<Locale?>> = if (capabilities.isOriginalLocaleSupported) {
|
|
|
|
|
combine(
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.originalLocale },
|
|
|
|
|
) { available, selected ->
|
|
|
|
|
available.fold(
|
|
|
|
|
onSuccess = {
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = it.availableLocales.sortedWithSafe(LocaleComparator()).addFirstDistinct(null),
|
|
|
|
|
selectedItems = setOfNotNull(selected.originalLocale),
|
|
|
|
|
)
|
|
|
|
|
},
|
|
|
|
|
onFailure = {
|
|
|
|
|
FilterProperty.error(it)
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope + Dispatchers.Default, SharingStarted.Lazily, loadingProperty())
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
} else {
|
|
|
|
|
MutableStateFlow(emptyProperty())
|
|
|
|
|
MutableStateFlow(FilterProperty.EMPTY)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override val filterSortOrder: StateFlow<FilterProperty<GenericSortOrder>> =
|
|
|
|
|
currentState.distinctUntilChangedBy { it.sortOrder }.map { state ->
|
|
|
|
|
val orders = repository.sortOrders
|
|
|
|
|
val year: StateFlow<FilterProperty<Int>> = if (capabilities.isYearSupported) {
|
|
|
|
|
currentListFilter.distinctUntilChangedBy { it.year }.map { selected ->
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = orders.mapTo(EnumSet.noneOf(GenericSortOrder::class.java)) {
|
|
|
|
|
GenericSortOrder.of(it)
|
|
|
|
|
}.sortedByOrdinal(),
|
|
|
|
|
selectedItems = setOf(GenericSortOrder.of(state.sortOrder)),
|
|
|
|
|
isLoading = false,
|
|
|
|
|
error = null,
|
|
|
|
|
availableItems = listOf(YEAR_MIN, MAX_YEAR),
|
|
|
|
|
selectedItems = setOf(selected.year),
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope + Dispatchers.Default, SharingStarted.Lazily, loadingProperty())
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
} else {
|
|
|
|
|
MutableStateFlow(FilterProperty.EMPTY)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override val filterSortDirection: StateFlow<FilterProperty<SortDirection>> =
|
|
|
|
|
currentState.distinctUntilChangedBy { it.sortOrder }.map { state ->
|
|
|
|
|
val orders = repository.sortOrders
|
|
|
|
|
val yearRange: StateFlow<FilterProperty<Int>> = if (capabilities.isYearRangeSupported) {
|
|
|
|
|
currentListFilter.distinctUntilChanged { old, new ->
|
|
|
|
|
old.yearTo == new.yearTo && old.yearFrom == new.yearFrom
|
|
|
|
|
}.map { selected ->
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = state.sortOrder.let {
|
|
|
|
|
val genericOrder = GenericSortOrder.of(it)
|
|
|
|
|
val result = EnumSet.noneOf(SortDirection::class.java)
|
|
|
|
|
if (genericOrder.ascending in orders) result.add(SortDirection.ASC)
|
|
|
|
|
if (genericOrder.descending in orders) result.add(SortDirection.DESC)
|
|
|
|
|
result
|
|
|
|
|
}?.sortedByOrdinal().orEmpty(),
|
|
|
|
|
selectedItems = setOf(state.sortOrder.direction),
|
|
|
|
|
isLoading = false,
|
|
|
|
|
error = null,
|
|
|
|
|
availableItems = listOf(YEAR_MIN, MAX_YEAR),
|
|
|
|
|
selectedItems = setOf(selected.yearFrom, selected.yearTo),
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope + Dispatchers.Default, SharingStarted.Lazily, loadingProperty())
|
|
|
|
|
}.stateIn(coroutineScope, SharingStarted.Lazily, FilterProperty.LOADING)
|
|
|
|
|
} else {
|
|
|
|
|
MutableStateFlow(FilterProperty.EMPTY)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override val filterState: StateFlow<FilterProperty<MangaState>> = combine(
|
|
|
|
|
currentState.distinctUntilChangedBy { it.states },
|
|
|
|
|
flowOf(repository.states),
|
|
|
|
|
) { state, states ->
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = states.sortedByOrdinal(),
|
|
|
|
|
selectedItems = state.states,
|
|
|
|
|
isLoading = false,
|
|
|
|
|
error = null,
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope + Dispatchers.Default, SharingStarted.Lazily, loadingProperty())
|
|
|
|
|
fun reset() {
|
|
|
|
|
currentListFilter.value = MangaListFilter.EMPTY
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override val filterContentRating: StateFlow<FilterProperty<ContentRating>> = combine(
|
|
|
|
|
currentState.distinctUntilChangedBy { it.contentRating },
|
|
|
|
|
flowOf(repository.contentRatings),
|
|
|
|
|
) { rating, ratings ->
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = ratings.sortedByOrdinal(),
|
|
|
|
|
selectedItems = rating.contentRating,
|
|
|
|
|
isLoading = false,
|
|
|
|
|
error = null,
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope + Dispatchers.Default, SharingStarted.Lazily, loadingProperty())
|
|
|
|
|
|
|
|
|
|
override val filterLocale: StateFlow<FilterProperty<Locale?>> = combine(
|
|
|
|
|
currentState.distinctUntilChangedBy { it.locale },
|
|
|
|
|
getLocalesAsFlow(),
|
|
|
|
|
) { state, locales ->
|
|
|
|
|
val list = if (locales.items.isNotEmpty()) {
|
|
|
|
|
val l = ArrayList<Locale?>(locales.items.size + 1)
|
|
|
|
|
l.add(null)
|
|
|
|
|
l.addAll(locales.items)
|
|
|
|
|
try {
|
|
|
|
|
l.sortWith(nullsFirst(LocaleComparator()))
|
|
|
|
|
} catch (e: IllegalArgumentException) {
|
|
|
|
|
e.printStackTraceDebug()
|
|
|
|
|
}
|
|
|
|
|
l
|
|
|
|
|
} else {
|
|
|
|
|
emptyList()
|
|
|
|
|
}
|
|
|
|
|
FilterProperty(
|
|
|
|
|
availableItems = list,
|
|
|
|
|
selectedItems = setOf(state.locale),
|
|
|
|
|
isLoading = locales.isLoading,
|
|
|
|
|
error = locales.error,
|
|
|
|
|
)
|
|
|
|
|
}.stateIn(coroutineScope + Dispatchers.Default, SharingStarted.Lazily, loadingProperty())
|
|
|
|
|
|
|
|
|
|
override val header: StateFlow<FilterHeaderModel> = getHeaderFlow().stateIn(
|
|
|
|
|
scope = coroutineScope + Dispatchers.Default,
|
|
|
|
|
started = SharingStarted.Lazily,
|
|
|
|
|
initialValue = FilterHeaderModel(
|
|
|
|
|
chips = emptyList(),
|
|
|
|
|
sortOrder = repository.defaultSortOrder,
|
|
|
|
|
isFilterApplied = false,
|
|
|
|
|
),
|
|
|
|
|
fun snapshot() = Snapshot(
|
|
|
|
|
sortOrder = currentSortOrder.value,
|
|
|
|
|
listFilter = currentListFilter.value,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
override fun applyFilter(tags: Set<MangaTag>) {
|
|
|
|
|
setTags(tags)
|
|
|
|
|
fun observe(): Flow<Snapshot> = combine(currentSortOrder, currentListFilter, ::Snapshot)
|
|
|
|
|
|
|
|
|
|
fun setSortOrder(newSortOrder: SortOrder) {
|
|
|
|
|
currentSortOrder.value = newSortOrder
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun setSortOrder(value: SortOrder) {
|
|
|
|
|
val available = repository.sortOrders
|
|
|
|
|
val sortOrder = if (value !in available) {
|
|
|
|
|
val generic = GenericSortOrder.of(value)
|
|
|
|
|
when {
|
|
|
|
|
generic.ascending in available -> generic.ascending
|
|
|
|
|
generic.descending in available -> generic.descending
|
|
|
|
|
else -> return
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
value
|
|
|
|
|
}
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
oldValue.copy(sortOrder = sortOrder)
|
|
|
|
|
}
|
|
|
|
|
repository.defaultSortOrder = sortOrder
|
|
|
|
|
fun set(value: MangaListFilter) {
|
|
|
|
|
currentListFilter.value = value
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun setLanguage(value: Locale?) {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
fun setLocale(value: Locale?) {
|
|
|
|
|
currentListFilter.update { oldValue ->
|
|
|
|
|
oldValue.copy(locale = value)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun setTag(value: MangaTag, addOrRemove: Boolean) {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
val newTags = if (repository.isMultipleTagsSupported) {
|
|
|
|
|
if (addOrRemove) {
|
|
|
|
|
oldValue.tags + value
|
|
|
|
|
} else {
|
|
|
|
|
oldValue.tags - value
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (addOrRemove) {
|
|
|
|
|
setOf(value)
|
|
|
|
|
} else {
|
|
|
|
|
emptySet()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
oldValue.copy(
|
|
|
|
|
tags = newTags,
|
|
|
|
|
tagsExclude = oldValue.tagsExclude - newTags,
|
|
|
|
|
)
|
|
|
|
|
fun setYear(value: Int) {
|
|
|
|
|
currentListFilter.update { oldValue ->
|
|
|
|
|
oldValue.copy(year = value)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun setTagExcluded(value: MangaTag, addOrRemove: Boolean) {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
val newTags = if (repository.isMultipleTagsSupported) {
|
|
|
|
|
if (addOrRemove) {
|
|
|
|
|
oldValue.tagsExclude + value
|
|
|
|
|
} else {
|
|
|
|
|
oldValue.tagsExclude - value
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (addOrRemove) {
|
|
|
|
|
setOf(value)
|
|
|
|
|
} else {
|
|
|
|
|
emptySet()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
fun toggleState(value: MangaState, isSelected: Boolean) {
|
|
|
|
|
currentListFilter.update { oldValue ->
|
|
|
|
|
oldValue.copy(
|
|
|
|
|
tagsExclude = newTags,
|
|
|
|
|
tags = oldValue.tags - newTags,
|
|
|
|
|
states = if (isSelected) oldValue.states + value else oldValue.states - value,
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun setState(value: MangaState, addOrRemove: Boolean) {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
val newStates = if (addOrRemove) {
|
|
|
|
|
oldValue.states + value
|
|
|
|
|
} else {
|
|
|
|
|
oldValue.states - value
|
|
|
|
|
}
|
|
|
|
|
oldValue.copy(states = newStates)
|
|
|
|
|
fun toggleContentRating(value: ContentRating, isSelected: Boolean) {
|
|
|
|
|
currentListFilter.update { oldValue ->
|
|
|
|
|
oldValue.copy(
|
|
|
|
|
contentRating = if (isSelected) oldValue.contentRating + value else oldValue.contentRating - value,
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun setContentRating(value: ContentRating, addOrRemove: Boolean) {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
val newRating = if (addOrRemove) {
|
|
|
|
|
oldValue.contentRating + value
|
|
|
|
|
fun toggleTag(value: MangaTag, isSelected: Boolean) {
|
|
|
|
|
currentListFilter.update { oldValue ->
|
|
|
|
|
val newTags = if (capabilities.isMultipleTagsSupported) {
|
|
|
|
|
if (isSelected) oldValue.tags + value else oldValue.tags - value
|
|
|
|
|
} else {
|
|
|
|
|
oldValue.contentRating - value
|
|
|
|
|
if (isSelected) setOf(value) else emptySet()
|
|
|
|
|
}
|
|
|
|
|
oldValue.copy(contentRating = newRating)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun onListHeaderClick(item: ListHeader, view: View) {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
oldValue.copy(
|
|
|
|
|
sortOrder = oldValue.sortOrder,
|
|
|
|
|
tags = if (item.payload == R.string.genres) emptySet() else oldValue.tags,
|
|
|
|
|
locale = if (item.payload == R.string.language) null else oldValue.locale,
|
|
|
|
|
states = if (item.payload == R.string.state) emptySet() else oldValue.states,
|
|
|
|
|
tags = newTags,
|
|
|
|
|
tagsExclude = oldValue.tagsExclude - newTags,
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fun observeAvailableTags(): Flow<Set<MangaTag>?> = flow {
|
|
|
|
|
if (!availableTagsDeferred.isCompleted) {
|
|
|
|
|
emit(emptySet())
|
|
|
|
|
}
|
|
|
|
|
emit(availableTagsDeferred.await().getOrNull())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fun observeState() = currentState.asStateFlow()
|
|
|
|
|
|
|
|
|
|
fun setTags(tags: Set<MangaTag>) {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
fun toggleTagExclude(value: MangaTag, isSelected: Boolean) {
|
|
|
|
|
currentListFilter.update { oldValue ->
|
|
|
|
|
val newTagsExclude = if (capabilities.isMultipleTagsSupported) {
|
|
|
|
|
if (isSelected) oldValue.tagsExclude + value else oldValue.tagsExclude - value
|
|
|
|
|
} else {
|
|
|
|
|
if (isSelected) setOf(value) else emptySet()
|
|
|
|
|
}
|
|
|
|
|
oldValue.copy(
|
|
|
|
|
tags = tags,
|
|
|
|
|
tagsExclude = oldValue.tagsExclude - tags,
|
|
|
|
|
tags = oldValue.tags - newTagsExclude,
|
|
|
|
|
tagsExclude = newTagsExclude,
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fun reset() {
|
|
|
|
|
currentState.update { oldValue ->
|
|
|
|
|
MangaListFilter.Advanced.Builder(oldValue.sortOrder).build()
|
|
|
|
|
}
|
|
|
|
|
fun getAllTags(): Flow<Result<List<MangaTag>>> = filterOptions.asFlow().map {
|
|
|
|
|
it.map { x -> x.availableTags.sortedWithSafe(TagTitleComparator(sourceLocale)) }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fun snapshot() = currentState.value
|
|
|
|
|
|
|
|
|
|
private fun getHeaderFlow() = combine(
|
|
|
|
|
observeState(),
|
|
|
|
|
observeAvailableTags(),
|
|
|
|
|
) { state, available ->
|
|
|
|
|
val chips = createChipsList(state, available.orEmpty(), 8)
|
|
|
|
|
FilterHeaderModel(
|
|
|
|
|
chips = chips,
|
|
|
|
|
sortOrder = state.sortOrder,
|
|
|
|
|
isFilterApplied = !state.isEmpty(),
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun getLocalesAsFlow(): Flow<PendingData<Locale>> = flow {
|
|
|
|
|
emit(PendingData(emptySet(), isLoading = true, error = null))
|
|
|
|
|
tryLoadLocales()
|
|
|
|
|
.onSuccess { locales ->
|
|
|
|
|
emit(PendingData(locales, isLoading = false, error = null))
|
|
|
|
|
}.onFailure {
|
|
|
|
|
emit(PendingData(emptySet(), isLoading = false, error = it))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun getTopTagsAsFlow(selectedTags: Flow<Set<MangaTag>>, limit: Int): Flow<PendingData<MangaTag>> = combine(
|
|
|
|
|
selectedTags.map {
|
|
|
|
|
if (it.isEmpty()) {
|
|
|
|
|
searchRepository.getTagsSuggestion("", limit, repository.source)
|
|
|
|
|
} else {
|
|
|
|
|
searchRepository.getTagsSuggestion(it).take(limit)
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
tagsFlow,
|
|
|
|
|
) { suggested, all ->
|
|
|
|
|
val res = suggested.toMutableList()
|
|
|
|
|
if (res.size < limit) {
|
|
|
|
|
res.addAll(all.items.shuffled().take(limit - res.size))
|
|
|
|
|
private fun getTopTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
|
|
|
|
|
flow { emit(searchRepository.getTopTags(repository.source, limit)) },
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
) { suggested, options ->
|
|
|
|
|
val all = options.getOrNull()?.availableTags.orEmpty()
|
|
|
|
|
val result = ArrayList<MangaTag>(limit)
|
|
|
|
|
result.addAll(suggested.take(limit))
|
|
|
|
|
if (result.size < limit) {
|
|
|
|
|
result.addAll(all.shuffled().take(limit - result.size))
|
|
|
|
|
}
|
|
|
|
|
if (result.isNotEmpty()) {
|
|
|
|
|
Result.success(result)
|
|
|
|
|
} else {
|
|
|
|
|
options.map { result }
|
|
|
|
|
}
|
|
|
|
|
PendingData(res, all.isLoading, all.error.takeIf { res.size < limit })
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun getBottomTagsAsFlow(limit: Int): Flow<PendingData<MangaTag>> = combine(
|
|
|
|
|
private fun getBottomTags(limit: Int): Flow<Result<List<MangaTag>>> = combine(
|
|
|
|
|
flow { emit(searchRepository.getRareTags(repository.source, limit)) },
|
|
|
|
|
tagsFlow,
|
|
|
|
|
) { suggested, all ->
|
|
|
|
|
val res = suggested.toMutableList()
|
|
|
|
|
if (res.size < limit) {
|
|
|
|
|
res.addAll(all.items.shuffled().take(limit - res.size))
|
|
|
|
|
filterOptions.asFlow(),
|
|
|
|
|
) { suggested, options ->
|
|
|
|
|
val all = options.getOrNull()?.availableTags.orEmpty()
|
|
|
|
|
val result = ArrayList<MangaTag>(limit)
|
|
|
|
|
result.addAll(suggested.take(limit))
|
|
|
|
|
if (result.size < limit) {
|
|
|
|
|
result.addAll(all.shuffled().take(limit - result.size))
|
|
|
|
|
}
|
|
|
|
|
PendingData(res, all.isLoading, all.error.takeIf { res.size < limit })
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private suspend fun createChipsList(
|
|
|
|
|
filterState: MangaListFilter.Advanced,
|
|
|
|
|
availableTags: Set<MangaTag>,
|
|
|
|
|
limit: Int,
|
|
|
|
|
): List<ChipsView.ChipModel> {
|
|
|
|
|
val selectedTags = filterState.tags.toMutableSet()
|
|
|
|
|
var tags = if (selectedTags.isEmpty()) {
|
|
|
|
|
searchRepository.getTagsSuggestion("", limit, repository.source)
|
|
|
|
|
if (result.isNotEmpty()) {
|
|
|
|
|
Result.success(result)
|
|
|
|
|
} else {
|
|
|
|
|
searchRepository.getTagsSuggestion(selectedTags).take(limit)
|
|
|
|
|
}
|
|
|
|
|
if (tags.size < limit) {
|
|
|
|
|
tags = tags + availableTags.take(limit - tags.size)
|
|
|
|
|
}
|
|
|
|
|
if (tags.isEmpty() && selectedTags.isEmpty()) {
|
|
|
|
|
return emptyList()
|
|
|
|
|
}
|
|
|
|
|
val result = LinkedList<ChipsView.ChipModel>()
|
|
|
|
|
for (tag in tags) {
|
|
|
|
|
val model = ChipsView.ChipModel(
|
|
|
|
|
title = tag.title,
|
|
|
|
|
isChecked = selectedTags.remove(tag),
|
|
|
|
|
data = tag,
|
|
|
|
|
)
|
|
|
|
|
if (model.isChecked) {
|
|
|
|
|
result.addFirst(model)
|
|
|
|
|
} else {
|
|
|
|
|
result.addLast(model)
|
|
|
|
|
}
|
|
|
|
|
options.map { result }
|
|
|
|
|
}
|
|
|
|
|
for (tag in selectedTags) {
|
|
|
|
|
val model = ChipsView.ChipModel(
|
|
|
|
|
title = tag.title,
|
|
|
|
|
isChecked = true,
|
|
|
|
|
data = tag,
|
|
|
|
|
)
|
|
|
|
|
result.addFirst(model)
|
|
|
|
|
}
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private suspend fun tryLoadTags(): Result<Set<MangaTag>> {
|
|
|
|
|
val shouldRetryOnError = availableTagsDeferred.isCompleted
|
|
|
|
|
val result = availableTagsDeferred.await()
|
|
|
|
|
if (result.isFailure && shouldRetryOnError) {
|
|
|
|
|
availableTagsDeferred = loadTagsAsync()
|
|
|
|
|
return availableTagsDeferred.await()
|
|
|
|
|
private fun <T> List<T>.addFirstDistinct(other: Collection<T>): List<T> {
|
|
|
|
|
val result = ArrayDeque<T>(this.size + other.size)
|
|
|
|
|
result.addAll(this)
|
|
|
|
|
for (item in other) {
|
|
|
|
|
if (item !in result) {
|
|
|
|
|
result.addFirst(item)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private suspend fun tryLoadLocales(): Result<Set<Locale>> {
|
|
|
|
|
val shouldRetryOnError = availableLocalesDeferred.isCompleted
|
|
|
|
|
val result = availableLocalesDeferred.await()
|
|
|
|
|
if (result.isFailure && shouldRetryOnError) {
|
|
|
|
|
availableLocalesDeferred = loadLocalesAsync()
|
|
|
|
|
return availableLocalesDeferred.await()
|
|
|
|
|
private fun <T> List<T>.addFirstDistinct(item: T): List<T> {
|
|
|
|
|
val result = ArrayDeque<T>(this.size + 1)
|
|
|
|
|
result.addAll(this)
|
|
|
|
|
if (item !in result) {
|
|
|
|
|
result.addFirst(item)
|
|
|
|
|
}
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun loadTagsAsync() = coroutineScope.async(Dispatchers.Default, CoroutineStart.LAZY) {
|
|
|
|
|
runCatchingCancellable {
|
|
|
|
|
repository.getTags()
|
|
|
|
|
}.onFailure { error ->
|
|
|
|
|
error.printStackTraceDebug()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun loadLocalesAsync() = coroutineScope.async(Dispatchers.Default, CoroutineStart.LAZY) {
|
|
|
|
|
runCatchingCancellable {
|
|
|
|
|
repository.getLocales()
|
|
|
|
|
}.onFailure { error ->
|
|
|
|
|
error.printStackTraceDebug()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun mergeTags(primary: Set<MangaTag>, secondary: Set<MangaTag>): Set<MangaTag> {
|
|
|
|
|
val result = TreeSet(TagTitleComparator((repository.source as? MangaParserSource)?.locale))
|
|
|
|
|
result.addAll(secondary)
|
|
|
|
|
result.addAll(primary)
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun loadAllTags() {
|
|
|
|
|
val prevJob = allTagsLoadJob
|
|
|
|
|
allTagsLoadJob = coroutineScope.launch(Dispatchers.Default) {
|
|
|
|
|
runCatchingCancellable {
|
|
|
|
|
prevJob?.cancelAndJoin()
|
|
|
|
|
appendTagsList(localTags.get(), isLoading = true)
|
|
|
|
|
appendTagsList(availableTagsDeferred.await().getOrThrow(), isLoading = false)
|
|
|
|
|
}.onFailure { e ->
|
|
|
|
|
allTags.value = allTags.value.filterIsInstance<TagCatalogItem>() + e.toErrorFooter()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun appendTagsList(newTags: Collection<MangaTag>, isLoading: Boolean) = allTags.update { oldList ->
|
|
|
|
|
val oldTags = oldList.filterIsInstance<TagCatalogItem>()
|
|
|
|
|
buildList(oldTags.size + newTags.size + if (isLoading) 1 else 0) {
|
|
|
|
|
addAll(oldTags)
|
|
|
|
|
newTags.mapTo(this) { TagCatalogItem(it, isChecked = false) }
|
|
|
|
|
val tempSet = HashSet<MangaTag>(size)
|
|
|
|
|
removeAll { x -> x is TagCatalogItem && !tempSet.add(x.tag) }
|
|
|
|
|
sortBy { (it as TagCatalogItem).tag.title }
|
|
|
|
|
if (isLoading) {
|
|
|
|
|
add(LoadingFooter())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private data class PendingData<T>(
|
|
|
|
|
val items: Collection<T>,
|
|
|
|
|
val isLoading: Boolean,
|
|
|
|
|
val error: Throwable?,
|
|
|
|
|
data class Snapshot(
|
|
|
|
|
val sortOrder: SortOrder,
|
|
|
|
|
val listFilter: MangaListFilter,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
private fun <T> loadingProperty() = FilterProperty<T>(emptyList(), emptySet(), true, null)
|
|
|
|
|
interface Owner {
|
|
|
|
|
|
|
|
|
|
private fun <T> emptyProperty() = FilterProperty<T>(emptyList(), emptySet(), false, null)
|
|
|
|
|
|
|
|
|
|
private class TagTitleComparator(lc: String?) : Comparator<MangaTag> {
|
|
|
|
|
val filterCoordinator: FilterCoordinator
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private val collator = lc?.let { Collator.getInstance(Locale(it)) }
|
|
|
|
|
private companion object {
|
|
|
|
|
|
|
|
|
|
override fun compare(o1: MangaTag, o2: MangaTag): Int {
|
|
|
|
|
val t1 = o1.title.lowercase()
|
|
|
|
|
val t2 = o2.title.lowercase()
|
|
|
|
|
return collator?.compare(t1, t2) ?: compareValues(t1, t2)
|
|
|
|
|
}
|
|
|
|
|
const val TAGS_LIMIT = 12
|
|
|
|
|
val MAX_YEAR = Calendar.getInstance()[Calendar.YEAR] + 1
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
