Desktop app (#308)
* Implement build profiles and feature policy for offline desktop builds * Introduce unified cross-platform Settings Hub * Refactor main settings into a hierarchical page-based navigation model * Refactor library projection to use shared multiplatform logic * Refactor UI state consumption by removing intermediate screen models * Introduce AndroidSharedStateBridge to centralize state mapping and reduction logic * Refactor state management for tabs, selection, and pinning to use shared bridge logic * Refactor file type management and validation into a centralized shared module * Centralize file type resolution and improve handling of unknown types * Centralize book import logic with SharedImportPlanner * Refactor magnifier geometry logic and coordinate mapping * Properly handle orientation changes in scroll-locked PDF reader * Add screen orientation controls to EPUB and PDF readers * Implement right-to-left (RTL) pagination support and refactor reader menus * Separate right-to-left pagination settings for PDF and EPUB * Ensure PDF page data is scoped by document key for multi tab support * Implement theme-aware link styling for the epub reader * Implement jump history for back and forward navigation in the epub reader * Improve locator handling and navigation logic in paginated reader mode * Implement stable pagination navigation and location tracking * Centralize banner message management and auto-dismiss logic in MainViewModel * Implement zoom and pan state preservation for PDF pan lock mode * Enhance reader navigation UI and workspace layout management in desktop app * Refactor reader navigation sidebar and relocate search controls in desktop app * Enhance reader UI with redesigned selection menus and bottom sheet overlays * Implement custom highlight palettes and reader theme customization in desktop app * Implement cross-platform modal layer and refine reader UI styling * Improve highlight accuracy and implement metadata enrichment on book open in desktop app * Implement two-page spread layout for paginated reader on desktop * Implement persistent caching for book loading and pagination in desktop app * Implement persistent caching for book loading and pagination in desktop app * Optimize reader settings updates by separating layout and appearance changes in desktop app * Improve desktop window branding and native Windows styling * Enhance reader selection interactions and UI across EPUB and PDF viewers in desktop app * Refine selection handle positioning and interaction logic * Implement EPUB selection debug logging and improve handle targeting * Optimize desktop book loading performance and UI responsiveness * Implement anchored zoom gestures and rendering optimizations for the Desktop PDF viewer. * Implement smooth zoom preview for the PDF reader in desktop app * Optimize PDF rendering performance and responsiveness in the desktop reader * Implement conditional diagnostic logging and update desktop build configuration * Implemented hierarchical TOC, custom scrollbars, and improved desktop modal handling * Added management options for annotations and highlights in the sidebar in desktop app * Implemented `SharedStableOutlinedTextField` and updated text input fields to use `TextFieldValue` for improved cursor and selection stability. * Refined library filters and enhanced OPDS functionality in desktop app * Improved EPUB pagination measurement and implemented layout diagnostic logging for desktop app * Added PPTX support including document parsing, rendering, and indexing * Improved PPTX rendering and layout accuracy * Implemented text autofit support for PPTX rendering * Enhanced PPTX rendering with support for custom geometry, automatic numbering, table styles, and image opacity * Improved EPUB pagination accuracy and added layout telemetry in desktop app * Improved folder synchronization with metadata-only mode and hashed sidecar management in desktop app * Implemented rich text font scaling and migrated desktop ink tools to custom pointer input handling * Implemented billing account obfuscation * Implemented hierarchical folder navigation and improved library selection functionality in desktop app * Implemented platform-aware directory resolution and multi-platform native library support for desktop * Added full-screen mode for the reader workspace * Added PDF zoom indicator and interactive vertical scrollbar with page tooltips * Refactored speech bubble prefetching to use a limited radius and improved ML detector initialization and lifecycle management * Updated PDF indexing to replace existing page text and removed search result item keys * Implemented "preparing" foreground notification for TTS service * Optimized PDF rendering performance by pre-calculating page-specific annotations * Refactored desktop packaging tasks and improved distribution configuration * Optimized EPUB parser memory usage and added path traversal protection * Refactored WorkManager monitoring logic and added work pruning * Implemented comprehensive resource cleanup and memory management for WebView-based components to prevent memory leaks * Implemented bitmap size limits and scaling to prevent canvas rendering errors * Split long text paragraphs into multiple semantic blocks during HTML parsing * Implemented local ActionMode for text selection to prevent platform crashes * Refactored PPTX text layout, optimized HtmlParser block detection, and improved banner dismissal logic * Added desktop startup splash screen and deferred WebView initialization * Reorganized settings hub and added separate PDF reader defaults * Implemented embedded cover extraction and metadata support for MOBI and FB2 formats * Implemented batching for MetadataExtractionWorker and optimized EPUB metadata extraction performance. * Implemented procedurally generated book covers and replaced static placeholders * Redesigned search UI with a top bar and results overlay in desktop app * Added PDF page gap and overlay visibility options and implemented DesktopBookImporter * Refactored PDF reader UI with tabbed inspector and improved theme background handling in desktop * Implemented PDF viewport persistence for zoom and scroll positions in desktop app * Improved desktop fullscreen implementation and state restoration * Implemented desktop window state persistence * Implemented flavor-based branding and ProGuard configuration for desktop builds * Implemented precise reader positioning and improved highlight rendering logic in desktop app * Added support for user-editable book metadata * Enhanced book metadata support and integrated info/edit dialogs * Implemented embedded EPUB metadata editing * Improved highlight mapping and added custom scrollbar styling for the reader. * Reduced desktop WebView bundle size by excluding unused locales and runtime files * Added neutral pan mode as the default PDF interaction state. * Refactored library empty states and updated primary navigation tabs in desktop app * Implemented native paginated reader and unified content rendering architecture in desktop epub reader * Implemented native EPUB image rendering for desktop and improved block layout spacing with margin collapsing. * Improved pagination overflow detection in desktop * Implemented multi-block text selection with interactive handles and CFI support in desktop epub pagination
This commit is contained in:
Aryan
GitHub
parent
c0d0e57e79
commit
b20ade9946
247 changed files with 43321 additions and 7087 deletions
|
|
@ -5,7 +5,10 @@ import com.aryan.reader.data.BookTagCrossRef
|
|||
import com.aryan.reader.data.RecentFileItem
|
||||
import com.aryan.reader.data.ShelfEntity
|
||||
import com.aryan.reader.data.TagEntity
|
||||
import com.aryan.reader.shared.SmartCollectionEngine
|
||||
import com.aryan.reader.shared.SharedReaderScreenState
|
||||
import com.aryan.reader.shared.applyLibraryFilters as sharedApplyLibraryFilters
|
||||
import com.aryan.reader.shared.filterBySearch as sharedFilterBySearch
|
||||
import com.aryan.reader.shared.sortBooks as sharedSortBooks
|
||||
|
||||
fun interface FolderPathResolver {
|
||||
fun relativeFolderSegments(item: RecentFileItem): List<String>
|
||||
|
|
@ -32,17 +35,28 @@ class LibraryStateProjector(
|
|||
fun project(input: LibraryProjectionInput): ReaderScreenState {
|
||||
val start = ReaderPerfLog.nowNanos()
|
||||
val internalState = input.state
|
||||
val bridgeContext = AndroidSharedStateBridge.prepareLibraryProjection(input, folderPathResolver)
|
||||
val cacheKey = ProjectionCacheKey(
|
||||
recentFilesFromDb = input.recentFilesFromDb,
|
||||
dbShelves = input.dbShelves,
|
||||
shelfRefs = input.shelfRefs,
|
||||
dbTags = input.dbTags,
|
||||
tagRefs = input.tagRefs,
|
||||
folderKeys = internalState.syncedFolders.map { SyncedFolderProjectionKey(it.uriString, it.name) },
|
||||
folderKeys = bridgeContext.folderKeys,
|
||||
sortOrder = internalState.sortOrder,
|
||||
searchQuery = internalState.searchQuery,
|
||||
libraryFilters = internalState.libraryFilters,
|
||||
recentFilesLimit = internalState.recentFilesLimit
|
||||
recentFilesLimit = internalState.recentFilesLimit,
|
||||
openTabIds = internalState.openTabIds,
|
||||
activeTabBookId = internalState.activeTabBookId,
|
||||
selectedBookIds = internalState.contextualActionItems.mapTo(mutableSetOf()) { it.bookId },
|
||||
selectedShelfIds = internalState.contextualActionShelfIds,
|
||||
viewingShelfId = internalState.viewingShelfId,
|
||||
isAddingBooksToShelf = internalState.isAddingBooksToShelf,
|
||||
addBooksSource = internalState.addBooksSource,
|
||||
booksSelectedForAdding = internalState.booksSelectedForAdding,
|
||||
pinnedHomeBookIds = internalState.pinnedHomeBookIds,
|
||||
pinnedLibraryBookIds = internalState.pinnedLibraryBookIds
|
||||
)
|
||||
|
||||
cachedProjection?.takeIf { it.key == cacheKey }?.let { cache ->
|
||||
|
|
@ -50,71 +64,26 @@ class LibraryStateProjector(
|
|||
val elapsed = ReaderPerfLog.elapsedMs(start)
|
||||
if (elapsed >= 8L) {
|
||||
ReaderPerfLog.d(
|
||||
"LibraryProject cache-hit took ${elapsed}ms books=${cache.allLibraryFiles.size} shelves=${cache.shelfProjection.shelves.size}"
|
||||
"LibraryProject cache-hit took ${elapsed}ms books=${cache.androidBooksById.size} shelves=${cache.projected.shelves.size}"
|
||||
)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
val tagsById = input.dbTags.associateBy { it.id }
|
||||
val bookTagsMap = input.tagRefs.groupBy { it.bookId }.mapValues { entry ->
|
||||
entry.value.mapNotNull { tagsById[it.tagId] }
|
||||
}
|
||||
|
||||
val allLibraryFiles = input.recentFilesFromDb
|
||||
.filterNot { it.bookId.endsWith("_reflow") }
|
||||
.map { item ->
|
||||
item.copy(tags = bookTagsMap[item.bookId] ?: emptyList())
|
||||
}
|
||||
val allLibraryFilesById = allLibraryFiles.associateBy { it.bookId }
|
||||
|
||||
val rawFilteredByQuery = filterBySearch(allLibraryFiles, internalState.searchQuery)
|
||||
val libraryFiltered = applyLibraryFilters(rawFilteredByQuery, internalState.libraryFilters)
|
||||
val sortedLibraryFiles = if (internalState.sortOrder == SortOrder.RECENT) {
|
||||
libraryFiltered
|
||||
} else {
|
||||
sortFiles(libraryFiltered, internalState.sortOrder)
|
||||
}
|
||||
val recentLimit = if (internalState.recentFilesLimit > 0) internalState.recentFilesLimit else Int.MAX_VALUE
|
||||
val visibleRecentFiles = if (internalState.sortOrder == SortOrder.RECENT) {
|
||||
allLibraryFiles
|
||||
.asSequence()
|
||||
.filter { it.isRecent }
|
||||
.take(recentLimit)
|
||||
.toList()
|
||||
} else {
|
||||
sortFiles(
|
||||
allLibraryFiles.filter { it.isRecent },
|
||||
internalState.sortOrder
|
||||
).take(recentLimit)
|
||||
}
|
||||
|
||||
val shelfProjection = buildShelves(
|
||||
allLibraryFiles = allLibraryFiles,
|
||||
dbShelves = input.dbShelves,
|
||||
shelfRefs = input.shelfRefs,
|
||||
dbTags = input.dbTags,
|
||||
sortOrder = internalState.sortOrder,
|
||||
syncedFolders = internalState.syncedFolders
|
||||
)
|
||||
|
||||
val projected = AndroidSharedStateBridge.projectLibrary(bridgeContext)
|
||||
val cache = CachedProjection(
|
||||
key = cacheKey,
|
||||
allLibraryFiles = allLibraryFiles,
|
||||
allLibraryFilesById = allLibraryFilesById,
|
||||
sortedLibraryFiles = sortedLibraryFiles,
|
||||
visibleRecentFiles = visibleRecentFiles,
|
||||
shelfProjection = shelfProjection,
|
||||
validShelfIds = shelfProjection.shelves.mapTo(mutableSetOf()) { it.id },
|
||||
dbTags = input.dbTags
|
||||
projected = projected,
|
||||
androidBooksById = bridgeContext.androidBooksById,
|
||||
tagEntitiesById = bridgeContext.tagEntitiesById
|
||||
)
|
||||
cachedProjection = cache
|
||||
|
||||
val elapsed = ReaderPerfLog.elapsedMs(start)
|
||||
if (elapsed >= 16L || allLibraryFiles.size >= 500) {
|
||||
if (elapsed >= 16L || bridgeContext.androidBooksById.size >= 500) {
|
||||
ReaderPerfLog.d(
|
||||
"LibraryProject recompute took ${elapsed}ms books=${allLibraryFiles.size} " +
|
||||
"visible=${sortedLibraryFiles.size} shelves=${shelfProjection.shelves.size} " +
|
||||
"LibraryProject shared recompute took ${elapsed}ms books=${bridgeContext.androidBooksById.size} " +
|
||||
"visible=${projected.libraryBooks.size} shelves=${projected.shelves.size} " +
|
||||
"tags=${input.dbTags.size} shelfRefs=${input.shelfRefs.size} tagRefs=${input.tagRefs.size}"
|
||||
)
|
||||
}
|
||||
|
|
@ -126,310 +95,63 @@ class LibraryStateProjector(
|
|||
internalState: ReaderScreenState,
|
||||
cache: CachedProjection
|
||||
): ReaderScreenState {
|
||||
val viewingShelfId = internalState.viewingShelfId?.takeIf { it in cache.validShelfIds }
|
||||
val selectedShelfIds = internalState.contextualActionShelfIds.filterTo(mutableSetOf()) { it in cache.validShelfIds }
|
||||
val booksAvailableForAdding = if (internalState.isAddingBooksToShelf && viewingShelfId != null) {
|
||||
val currentShelfBookIds = cache.shelfProjection.shelves
|
||||
.find { it.id == viewingShelfId }
|
||||
?.books
|
||||
?.mapTo(mutableSetOf()) { it.bookId }
|
||||
?: emptySet()
|
||||
when (internalState.addBooksSource) {
|
||||
AddBooksSource.UNSHELVED -> cache.shelfProjection.unshelvedBooks
|
||||
AddBooksSource.ALL_BOOKS -> cache.allLibraryFiles.filter { it.bookId !in currentShelfBookIds }
|
||||
}
|
||||
} else {
|
||||
emptyList()
|
||||
}
|
||||
|
||||
return internalState.copy(
|
||||
recentFiles = cache.visibleRecentFiles,
|
||||
allRecentFiles = cache.sortedLibraryFiles,
|
||||
rawLibraryFiles = cache.allLibraryFiles,
|
||||
viewingShelfId = viewingShelfId,
|
||||
isAddingBooksToShelf = internalState.isAddingBooksToShelf && viewingShelfId != null,
|
||||
contextualActionShelfIds = selectedShelfIds,
|
||||
contextualActionItems = internalState.contextualActionItems
|
||||
.mapNotNull { ctx -> cache.allLibraryFilesById[ctx.bookId] }
|
||||
.toSet(),
|
||||
shelves = cache.shelfProjection.shelves,
|
||||
openTabs = internalState.openTabIds.mapNotNull { tabId -> cache.allLibraryFilesById[tabId] },
|
||||
booksAvailableForAdding = booksAvailableForAdding,
|
||||
allTags = cache.dbTags
|
||||
return AndroidSharedStateBridge.toAndroidState(
|
||||
base = internalState,
|
||||
sharedState = cache.projected,
|
||||
androidBooksById = cache.androidBooksById,
|
||||
tagEntitiesById = cache.tagEntitiesById
|
||||
)
|
||||
}
|
||||
|
||||
private fun buildShelves(
|
||||
allLibraryFiles: List<RecentFileItem>,
|
||||
dbShelves: List<ShelfEntity>,
|
||||
shelfRefs: List<BookShelfCrossRef>,
|
||||
dbTags: List<TagEntity>,
|
||||
sortOrder: SortOrder,
|
||||
syncedFolders: List<SyncedFolder>
|
||||
): ShelfProjection {
|
||||
val allShelves = mutableListOf<Shelf>()
|
||||
val shelvedBookIds = mutableSetOf<String>()
|
||||
val baseFilesMap = allLibraryFiles.associateBy { it.bookId }
|
||||
val shelfRefsByShelfId = shelfRefs.groupBy { it.shelfId }
|
||||
val taggedBookIdsByTagId = mutableMapOf<String, MutableList<String>>()
|
||||
|
||||
allLibraryFiles.forEach { item ->
|
||||
item.tags.forEach { tag ->
|
||||
taggedBookIdsByTagId.getOrPut(tag.id) { mutableListOf() }.add(item.bookId)
|
||||
}
|
||||
}
|
||||
|
||||
dbShelves.forEach { shelfEntity ->
|
||||
if (shelfEntity.isSmart && shelfEntity.smartRulesJson != null) {
|
||||
val rules = SmartCollectionEngine.fromJson(shelfEntity.smartRulesJson)
|
||||
if (rules != null) {
|
||||
val matchingBooks = allLibraryFiles.filter { SmartCollectionEngine.evaluate(it.toSharedBookItem(), rules) }
|
||||
allShelves.add(Shelf(shelfEntity.id, shelfEntity.name, ShelfType.SMART, sortFiles(matchingBooks, sortOrder)))
|
||||
shelvedBookIds.addAll(matchingBooks.map { it.bookId })
|
||||
}
|
||||
} else {
|
||||
val bookIdsInShelf = shelfRefsByShelfId[shelfEntity.id].orEmpty()
|
||||
.sortedBy { it.addedAt }
|
||||
.map { it.bookId }
|
||||
val booksInShelf = bookIdsInShelf.mapNotNull { baseFilesMap[it] }
|
||||
allShelves.add(Shelf(shelfEntity.id, shelfEntity.name, ShelfType.MANUAL, sortFiles(booksInShelf, sortOrder)))
|
||||
shelvedBookIds.addAll(bookIdsInShelf)
|
||||
}
|
||||
}
|
||||
|
||||
val tagShelves = dbTags.mapNotNull { tag ->
|
||||
val taggedBooks = taggedBookIdsByTagId[tag.id].orEmpty().mapNotNull { baseFilesMap[it] }
|
||||
if (taggedBooks.isEmpty()) {
|
||||
null
|
||||
} else {
|
||||
Shelf("tag_${tag.id}", tag.name, ShelfType.TAG, sortFiles(taggedBooks, sortOrder))
|
||||
}
|
||||
}
|
||||
allShelves.addAll(tagShelves)
|
||||
|
||||
val seriesShelves = allLibraryFiles
|
||||
.filter { !it.seriesName.isNullOrBlank() }
|
||||
.groupBy { it.seriesName!! }
|
||||
.filter { it.value.size >= 2 }
|
||||
.map { (series, books) ->
|
||||
val sortedSeries = books.sortedBy { it.seriesIndex ?: 999.0 }
|
||||
shelvedBookIds.addAll(books.map { it.bookId })
|
||||
Shelf("series_$series", series, ShelfType.SERIES, sortedSeries)
|
||||
}
|
||||
allShelves.addAll(seriesShelves)
|
||||
|
||||
val folderShelves = buildFolderShelves(
|
||||
allLibraryFiles = allLibraryFiles,
|
||||
syncedFolders = syncedFolders,
|
||||
sortOrder = sortOrder
|
||||
).also { shelves ->
|
||||
shelves.forEach { shelf ->
|
||||
shelvedBookIds.addAll(shelf.books.map { it.bookId })
|
||||
}
|
||||
}
|
||||
allShelves.addAll(folderShelves)
|
||||
|
||||
val unshelvedBooks = allLibraryFiles.filter { it.bookId !in shelvedBookIds }
|
||||
allShelves.add(Shelf("unshelved", "Unshelved", ShelfType.MANUAL, sortFiles(unshelvedBooks, sortOrder)))
|
||||
|
||||
allShelves.sortWith(compareBy({ it.type.ordinal }, { it.sortKey }))
|
||||
return ShelfProjection(shelves = allShelves, unshelvedBooks = unshelvedBooks)
|
||||
}
|
||||
|
||||
private fun buildFolderShelves(
|
||||
allLibraryFiles: List<RecentFileItem>,
|
||||
syncedFolders: List<SyncedFolder>,
|
||||
sortOrder: SortOrder
|
||||
): List<Shelf> {
|
||||
val folderNamesByUri = syncedFolders.associate { it.uriString to it.name }
|
||||
val folderSegmentsByBookId = allLibraryFiles
|
||||
.asSequence()
|
||||
.filter { it.sourceFolderUri != null }
|
||||
.associate { it.bookId to folderPathResolver.relativeFolderSegments(it) }
|
||||
|
||||
return allLibraryFiles
|
||||
.filter { it.sourceFolderUri != null }
|
||||
.groupBy { it.sourceFolderUri!! }
|
||||
.flatMap { (folderUri, books) ->
|
||||
val rootName = folderNamesByUri[folderUri] ?: "Local Folder"
|
||||
val rootShelfId = "folder_$folderUri"
|
||||
val rootAccumulator = FolderShelfAccumulator(
|
||||
id = rootShelfId,
|
||||
name = rootName,
|
||||
depth = 0,
|
||||
parentShelfId = null,
|
||||
sortPath = ""
|
||||
)
|
||||
val rootShelf = Shelf(
|
||||
id = rootShelfId,
|
||||
name = rootName,
|
||||
type = ShelfType.FOLDER,
|
||||
books = sortFiles(books, sortOrder),
|
||||
directBooks = emptyList(),
|
||||
childShelfIds = emptyList(),
|
||||
depth = 0,
|
||||
sortKey = "folder:${rootName.lowercase()}:"
|
||||
)
|
||||
|
||||
val nestedShelves = linkedMapOf<String, FolderShelfAccumulator>()
|
||||
val nestedShelvesById = mutableMapOf<String, FolderShelfAccumulator>()
|
||||
books.forEach { book ->
|
||||
rootAccumulator.books.add(book)
|
||||
val segments = folderSegmentsByBookId[book.bookId].orEmpty()
|
||||
if (segments.isEmpty()) {
|
||||
rootAccumulator.directBooks.add(book)
|
||||
}
|
||||
var currentPath = ""
|
||||
var parentShelfId = rootShelfId
|
||||
segments.forEachIndexed { index, segment ->
|
||||
currentPath = if (currentPath.isEmpty()) segment else "$currentPath/$segment"
|
||||
val shelfId = "folder_$folderUri::$currentPath"
|
||||
val accumulator = nestedShelves.getOrPut(currentPath) {
|
||||
val newShelf = FolderShelfAccumulator(
|
||||
id = shelfId,
|
||||
name = segment,
|
||||
depth = index + 1,
|
||||
parentShelfId = parentShelfId,
|
||||
sortPath = currentPath.lowercase()
|
||||
)
|
||||
if (parentShelfId == rootShelfId) {
|
||||
rootAccumulator.childShelfIds.add(shelfId)
|
||||
} else {
|
||||
nestedShelvesById[parentShelfId]?.childShelfIds?.add(shelfId)
|
||||
}
|
||||
nestedShelvesById[shelfId] = newShelf
|
||||
newShelf
|
||||
}
|
||||
accumulator.books.add(book)
|
||||
if (index == segments.lastIndex) {
|
||||
accumulator.directBooks.add(book)
|
||||
}
|
||||
parentShelfId = shelfId
|
||||
}
|
||||
}
|
||||
|
||||
val sortedNestedShelves = nestedShelves
|
||||
.values
|
||||
.sortedBy { it.sortPath }
|
||||
.map { shelf ->
|
||||
Shelf(
|
||||
id = shelf.id,
|
||||
name = shelf.name,
|
||||
type = ShelfType.FOLDER,
|
||||
books = sortFiles(shelf.books, sortOrder),
|
||||
directBooks = sortFiles(shelf.directBooks, sortOrder),
|
||||
parentShelfId = shelf.parentShelfId,
|
||||
childShelfIds = shelf.childShelfIds.sortedBy { it.substringAfterLast("::").lowercase() },
|
||||
depth = shelf.depth,
|
||||
sortKey = "folder:${rootName.lowercase()}:${shelf.sortPath}"
|
||||
)
|
||||
}
|
||||
|
||||
listOf(
|
||||
rootShelf.copy(
|
||||
directBooks = sortFiles(rootAccumulator.directBooks, sortOrder),
|
||||
childShelfIds = rootAccumulator.childShelfIds.sortedBy { it.substringAfterLast("::").lowercase() }
|
||||
)
|
||||
) + sortedNestedShelves
|
||||
}
|
||||
}
|
||||
|
||||
private data class FolderShelfAccumulator(
|
||||
val id: String,
|
||||
val name: String,
|
||||
val depth: Int,
|
||||
val parentShelfId: String?,
|
||||
val sortPath: String,
|
||||
val books: MutableList<RecentFileItem> = mutableListOf(),
|
||||
val directBooks: MutableList<RecentFileItem> = mutableListOf(),
|
||||
val childShelfIds: MutableList<String> = mutableListOf()
|
||||
)
|
||||
|
||||
private data class ShelfProjection(
|
||||
val shelves: List<Shelf>,
|
||||
val unshelvedBooks: List<RecentFileItem>
|
||||
)
|
||||
|
||||
private data class ProjectionCacheKey(
|
||||
val recentFilesFromDb: List<RecentFileItem>,
|
||||
val dbShelves: List<ShelfEntity>,
|
||||
val shelfRefs: List<BookShelfCrossRef>,
|
||||
val dbTags: List<TagEntity>,
|
||||
val tagRefs: List<BookTagCrossRef>,
|
||||
val folderKeys: List<SyncedFolderProjectionKey>,
|
||||
val folderKeys: List<AndroidSharedFolderProjectionKey>,
|
||||
val sortOrder: SortOrder,
|
||||
val searchQuery: String,
|
||||
val libraryFilters: LibraryFilters,
|
||||
val recentFilesLimit: Int
|
||||
)
|
||||
|
||||
private data class SyncedFolderProjectionKey(
|
||||
val uriString: String,
|
||||
val name: String
|
||||
val recentFilesLimit: Int,
|
||||
val openTabIds: List<String>,
|
||||
val activeTabBookId: String?,
|
||||
val selectedBookIds: Set<String>,
|
||||
val selectedShelfIds: Set<String>,
|
||||
val viewingShelfId: String?,
|
||||
val isAddingBooksToShelf: Boolean,
|
||||
val addBooksSource: AddBooksSource,
|
||||
val booksSelectedForAdding: Set<String>,
|
||||
val pinnedHomeBookIds: Set<String>,
|
||||
val pinnedLibraryBookIds: Set<String>
|
||||
)
|
||||
|
||||
private data class CachedProjection(
|
||||
val key: ProjectionCacheKey,
|
||||
val allLibraryFiles: List<RecentFileItem>,
|
||||
val allLibraryFilesById: Map<String, RecentFileItem>,
|
||||
val sortedLibraryFiles: List<RecentFileItem>,
|
||||
val visibleRecentFiles: List<RecentFileItem>,
|
||||
val shelfProjection: ShelfProjection,
|
||||
val validShelfIds: Set<String>,
|
||||
val dbTags: List<TagEntity>
|
||||
val projected: SharedReaderScreenState,
|
||||
val androidBooksById: Map<String, RecentFileItem>,
|
||||
val tagEntitiesById: Map<String, TagEntity>
|
||||
)
|
||||
}
|
||||
|
||||
fun filterBySearch(files: List<RecentFileItem>, searchQuery: String): List<RecentFileItem> {
|
||||
val query = searchQuery.trim()
|
||||
return if (query.isBlank()) {
|
||||
files
|
||||
} else {
|
||||
files.filter { item ->
|
||||
item.displayName.contains(query, ignoreCase = true) ||
|
||||
item.title?.contains(query, ignoreCase = true) == true ||
|
||||
item.author?.contains(query, ignoreCase = true) == true ||
|
||||
item.tags.any { tag -> tag.name.contains(query, ignoreCase = true) }
|
||||
}
|
||||
}
|
||||
return files.mapSharedResults(sharedFilterBySearch(files.map { it.toSharedProjectionBookItem() }, searchQuery))
|
||||
}
|
||||
|
||||
fun applyLibraryFilters(files: List<RecentFileItem>, filters: LibraryFilters): List<RecentFileItem> {
|
||||
return files.filter { item ->
|
||||
val matchType = if (filters.fileTypes.isNotEmpty()) item.type in filters.fileTypes else true
|
||||
val matchFolder = if (filters.sourceFolders.isNotEmpty()) {
|
||||
val matchesInApp = filters.sourceFolders.contains("IN_APP_STORAGE") &&
|
||||
item.sourceFolderUri == null &&
|
||||
item.uriString?.startsWith("opds-pse") != true
|
||||
val matchesSynced = item.sourceFolderUri in filters.sourceFolders
|
||||
matchesInApp || matchesSynced
|
||||
} else {
|
||||
true
|
||||
}
|
||||
val progress = item.progressPercentage ?: 0f
|
||||
val matchStatus = when (filters.readStatus) {
|
||||
ReadStatusFilter.ALL -> true
|
||||
ReadStatusFilter.UNREAD -> progress == 0f
|
||||
ReadStatusFilter.IN_PROGRESS -> progress > 0f && progress < 100f
|
||||
ReadStatusFilter.COMPLETED -> progress >= 100f
|
||||
}
|
||||
val matchTags = if (filters.tagIds.isNotEmpty()) {
|
||||
item.tags.any { it.id in filters.tagIds }
|
||||
} else {
|
||||
true
|
||||
}
|
||||
matchType && matchFolder && matchStatus && matchTags
|
||||
}
|
||||
return files.mapSharedResults(
|
||||
sharedApplyLibraryFilters(
|
||||
books = files.map { it.toSharedProjectionBookItem() },
|
||||
filters = filters.toSharedLibraryFilters()
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
fun sortFiles(files: List<RecentFileItem>, sortOrder: SortOrder): List<RecentFileItem> {
|
||||
return when (sortOrder) {
|
||||
SortOrder.RECENT -> files.sortedByDescending { it.timestamp }
|
||||
SortOrder.TITLE_ASC -> files.sortedBy { it.title?.lowercase() ?: it.displayName.lowercase() }
|
||||
SortOrder.AUTHOR_ASC -> files.sortedWith(compareBy(nullsLast()) { it.author?.lowercase() })
|
||||
SortOrder.PERCENT_ASC -> files.sortedBy { it.progressPercentage ?: 0f }
|
||||
SortOrder.PERCENT_DESC -> files.sortedByDescending { it.progressPercentage ?: 0f }
|
||||
SortOrder.SIZE_ASC -> files.sortedBy { it.fileSize }
|
||||
SortOrder.SIZE_DESC -> files.sortedByDescending { it.fileSize }
|
||||
}
|
||||
return files.mapSharedResults(sharedSortBooks(files.map { it.toSharedProjectionBookItem() }, sortOrder.toSharedSortOrder()))
|
||||
}
|
||||
|
||||
private fun List<RecentFileItem>.mapSharedResults(sharedBooks: List<com.aryan.reader.shared.BookItem>): List<RecentFileItem> {
|
||||
val byId = associateBy { it.bookId }
|
||||
return sharedBooks.mapNotNull { byId[it.id] }
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue