Atte149/book-reader
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Desktop app (#308)

Browse source 
* 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 2026-05-15 22:36:51 +05:30 • committed by GitHub
parent c0d0e57e79
commit b20ade9946
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
247 changed files with 43321 additions and 7087 deletions
Download patch file Download diff file Expand all files Collapse all files

155
app/src/test/java/com/aryan/reader/SharedModelMappersTest.kt Normal file
View file

@ -0,0 +1,155 @@
package com.aryan.reader
import com.aryan.reader.data.BookTagCrossRef
import com.aryan.reader.data.RecentFileItem
import com.aryan.reader.data.TagEntity
import com.aryan.reader.shared.FileType as SharedFileType
import com.aryan.reader.shared.SharedReaderScreenState
import com.aryan.reader.shared.Shelf as SharedShelf
import com.aryan.reader.shared.ShelfType as SharedShelfType
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertSame
import org.junit.Test
class SharedModelMappersTest {
@Test
fun `book mapper preserves android-only fields when shared projection maps back by id`() {
val tag = TagEntity(id = "tag", name = "Favorite", color = 0xFFAA00AA.toInt(), createdAt = 10L)
val original = recentFile(
id = "book",
type = FileType.PDF,
displayName = "Original.pdf",
customName = "Custom name",
isAvailable = false,
bookmarksJson = """[{"page":2}]""",
sourceFolderUri = "content://folder",
tags = listOf(tag)
)
val shared = original.toSharedBookItem()
val mapped = shared.toRecentFileItem(
androidBooksById = mapOf(original.bookId to original),
tagEntitiesById = mapOf(tag.id to tag)
)
assertEquals("Custom name", shared.displayName)
assertEquals(original.uriString, mapped.uriString)
assertEquals(original.displayName, mapped.displayName)
assertEquals(original.customName, mapped.customName)
assertEquals(original.bookmarksJson, mapped.bookmarksJson)
assertEquals(original.sourceFolderUri, mapped.sourceFolderUri)
assertFalse(mapped.isAvailable)
assertEquals(listOf(tag), mapped.tags)
}
@Test
fun `shared projection state maps shelves tabs selections and tags back to android state`() {
val tag = TagEntity(id = "tag", name = "Queued", createdAt = 1L)
val book = recentFile("book", tags = listOf(tag))
val sharedBook = book.toSharedBookItem()
val sharedShelf = SharedShelf(
id = "manual",
name = "Manual",
type = SharedShelfType.MANUAL,
books = listOf(sharedBook),
directBooks = listOf(sharedBook)
)
val projected = SharedReaderScreenState(
recentBooks = listOf(sharedBook),
libraryBooks = listOf(sharedBook),
rawLibraryBooks = listOf(sharedBook),
selectedBookIds = setOf("book", "missing"),
selectedShelfIds = setOf("manual"),
shelves = listOf(sharedShelf),
openTabs = listOf(sharedBook),
openTabIds = listOf("book"),
activeTabBookId = "book",
booksAvailableForAdding = listOf(sharedBook),
allTags = listOf(tag.toSharedTag())
)
val android = projected.toAndroidReaderScreenState(
base = ReaderScreenState(contextualActionItems = setOf(recentFile("missing"))),
androidBooksById = mapOf(book.bookId to book),
tagEntitiesById = mapOf(tag.id to tag)
)
assertEquals(listOf("book"), android.recentFiles.ids())
assertEquals(listOf("book"), android.allRecentFiles.ids())
assertEquals(listOf("book"), android.rawLibraryFiles.ids())
assertEquals(setOf("book"), android.contextualActionItems.mapTo(mutableSetOf()) { it.bookId })
assertEquals(setOf("manual"), android.contextualActionShelfIds)
assertEquals(listOf("manual"), android.shelves.map { it.id })
assertEquals(listOf("book"), android.shelves.single().books.ids())
assertEquals(listOf("book"), android.openTabs.ids())
assertEquals(listOf("book"), android.openTabIds)
assertEquals("book", android.activeTabBookId)
assertEquals(listOf("book"), android.booksAvailableForAdding.ids())
assertEquals(listOf(tag), android.allTags)
}
@Test
fun `enum filter and folder mappers round trip between android and shared`() {
val filters = LibraryFilters(
fileTypes = setOf(FileType.PDF, FileType.EPUB),
sourceFolders = setOf("IN_APP_STORAGE", "content://folder"),
readStatus = ReadStatusFilter.IN_PROGRESS,
tagIds = setOf("tag")
)
val folder = SyncedFolder(
uriString = "content://folder",
name = "Folder",
lastScanTime = 42L,
allowedFileTypes = setOf(FileType.PDF, FileType.CBZ)
)
assertEquals(FileType.PDF, SharedFileType.PDF.toAndroidFileType())
assertEquals(SharedFileType.CBZ, FileType.CBZ.toSharedFileType())
assertSame(FileType.UNKNOWN, SharedFileType.UNKNOWN.toAndroidFileType())
assertSame(filters, filters.toSharedLibraryFilters())
assertSame(folder, folder.toSharedSyncedFolder())
assertEquals(filters, filters.toSharedLibraryFilters().toAndroidLibraryFilters())
assertEquals(folder, folder.toSharedSyncedFolder().toAndroidSyncedFolder())
assertFalse(FileType.UNKNOWN in ANDROID_READABLE_FILE_TYPES)
assertFalse(FileType.UNKNOWN in ANDROID_SYNCABLE_FILE_TYPES)
}
@Test
fun `tag resolver attaches database tags before shared projection`() {
val tag = TagEntity(id = "tag", name = "Reference", createdAt = 1L)
val files = listOf(recentFile("book"))
val tagged = files.withResolvedTags(
dbTags = listOf(tag),
tagRefs = listOf(BookTagCrossRef(bookId = "book", tagId = "tag"))
)
assertEquals(listOf(tag), tagged.single().tags)
}
private fun recentFile(
id: String,
type: FileType = FileType.EPUB,
displayName: String = "$id.${type.name.lowercase()}",
customName: String? = null,
isAvailable: Boolean = true,
bookmarksJson: String? = null,
sourceFolderUri: String? = null,
tags: List<TagEntity> = emptyList()
) = RecentFileItem(
bookId = id,
uriString = "content://$id",
type = type,
displayName = displayName,
timestamp = 1L,
isAvailable = isAvailable,
bookmarksJson = bookmarksJson,
sourceFolderUri = sourceFolderUri,
customName = customName,
tags = tags
)
private fun List<RecentFileItem>.ids() = map { it.bookId }
}