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 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

View file

@ -0,0 +1,230 @@
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.AppAction as SharedAppAction
import com.aryan.reader.shared.AppThemeMode as SharedAppThemeMode
import com.aryan.reader.shared.LibraryAction as SharedLibraryAction
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
class AndroidSharedStateBridgeTest {
@Test
fun `prepareLibraryProjection builds shared input and Android lookup context`() {
val tag = tag("tag", "Favorite")
val book = recentFile("book", sourceFolderUri = "content://folder")
val reflowCopy = recentFile("book_reflow", sourceFolderUri = "content://folder")
val context = AndroidSharedStateBridge.prepareLibraryProjection(
input = LibraryProjectionInput(
state = ReaderScreenState(),
recentFilesFromDb = listOf(book, reflowCopy),
dbShelves = emptyList(),
shelfRefs = emptyList(),
dbTags = listOf(tag),
tagRefs = listOf(BookTagCrossRef(bookId = book.bookId, tagId = tag.id))
),
folderPathResolver = EmptyFolderPathResolver
)
assertEquals(listOf("book"), context.androidBooksById.keys.toList())
assertEquals(listOf("book"), context.sharedInput.booksFromStore.map { it.id })
assertEquals(listOf("tag"), context.sharedInput.booksFromStore.single().tags.map { it.id })
assertEquals(listOf(AndroidSharedFolderProjectionKey("content://folder", "Local Folder")), context.folderKeys)
}
@Test
fun `reduceLibraryAction applies shared library state back to Android fields`() {
val book = recentFile("book")
val filters = LibraryFilters(readStatus = ReadStatusFilter.COMPLETED)
val selected = AndroidSharedStateBridge.reduceLibraryAction(
current = ReaderScreenState(),
projectedState = ReaderScreenState(rawLibraryFiles = listOf(book)),
action = SharedLibraryAction.BookSelectionToggled(book.bookId)
)
val filtered = AndroidSharedStateBridge.reduceLibraryAction(
current = selected,
projectedState = ReaderScreenState(rawLibraryFiles = listOf(book)),
action = SharedLibraryAction.FiltersChanged(filters.toSharedLibraryFilters())
)
assertEquals(setOf(book), selected.contextualActionItems)
assertEquals(filters, filtered.libraryFilters)
}
@Test
fun `reduceLibraryAction drops selection ids that are not in projected Android books`() {
val result = AndroidSharedStateBridge.reduceLibraryAction(
current = ReaderScreenState(),
projectedState = ReaderScreenState(rawLibraryFiles = listOf(recentFile("book"))),
action = SharedLibraryAction.BookSelectionToggled("missing")
)
assertTrue(result.contextualActionItems.isEmpty())
}
@Test
fun `reduceAppAction applies shared app state back to Android fields`() {
val result = AndroidSharedStateBridge.reduceAppAction(
current = ReaderScreenState(appThemeMode = AppThemeMode.LIGHT),
projectedState = ReaderScreenState(),
action = SharedAppAction.AppThemeChanged(SharedAppThemeMode.DARK)
)
assertEquals(AppThemeMode.DARK, result.appThemeMode)
}
@Test
fun `setTabsEnabled disables shared tabs but preserves Android active reader session`() {
val result = AndroidSharedStateBridge.setTabsEnabled(
current = ReaderScreenState(
isTabsEnabled = true,
openTabIds = listOf("one", "two"),
activeTabBookId = "two"
),
projectedState = ReaderScreenState(),
enabled = false
)
assertEquals(false, result.isTabsEnabled)
assertEquals(listOf("two"), result.openTabIds)
assertEquals("two", result.activeTabBookId)
}
@Test
fun `openBookTab delegates tab ordering and activation to shared reducer`() {
val result = AndroidSharedStateBridge.openBookTab(
current = ReaderScreenState(
isTabsEnabled = false,
openTabIds = listOf("old"),
activeTabBookId = "old"
),
projectedState = ReaderScreenState(),
bookId = "new"
)
assertEquals(true, result.isTabsEnabled)
assertEquals(listOf("old", "new"), result.openTabIds)
assertEquals("new", result.activeTabBookId)
}
@Test
fun `closeBookTab selects the previous tab when the active tab closes`() {
val result = AndroidSharedStateBridge.closeBookTab(
current = ReaderScreenState(
isTabsEnabled = true,
openTabIds = listOf("one", "two", "three"),
activeTabBookId = "three"
),
projectedState = ReaderScreenState(),
bookId = "three"
)
assertEquals(true, result.isTabsEnabled)
assertEquals(listOf("one", "two"), result.openTabIds)
assertEquals("two", result.activeTabBookId)
}
@Test
fun `closeAllTabs clears Android tab ids through shared reducer`() {
val result = AndroidSharedStateBridge.closeAllTabs(
current = ReaderScreenState(
isTabsEnabled = true,
openTabIds = listOf("one", "two"),
activeTabBookId = "two"
),
projectedState = ReaderScreenState()
)
assertEquals(true, result.isTabsEnabled)
assertTrue(result.openTabIds.isEmpty())
assertEquals(null, result.activeTabBookId)
}
@Test
fun `togglePinsForSelectedBooks pins mixed home selection and clears selection`() {
val pinned = recentFile("pinned")
val unpinned = recentFile("unpinned")
val result = AndroidSharedStateBridge.togglePinsForSelectedBooks(
current = ReaderScreenState(
rawLibraryFiles = listOf(pinned, unpinned),
contextualActionItems = setOf(pinned, unpinned),
pinnedHomeBookIds = setOf(pinned.bookId)
),
projectedState = ReaderScreenState(rawLibraryFiles = listOf(pinned, unpinned)),
isHome = true
)
assertEquals(setOf("pinned", "unpinned"), result.pinnedHomeBookIds)
assertTrue(result.contextualActionItems.isEmpty())
}
@Test
fun `togglePinsForSelectedBooks unpins when all selected library books are pinned`() {
val first = recentFile("first")
val second = recentFile("second")
val result = AndroidSharedStateBridge.togglePinsForSelectedBooks(
current = ReaderScreenState(
rawLibraryFiles = listOf(first, second),
contextualActionItems = setOf(first, second),
pinnedLibraryBookIds = setOf(first.bookId, second.bookId)
),
projectedState = ReaderScreenState(rawLibraryFiles = listOf(first, second)),
isHome = false
)
assertTrue(result.pinnedLibraryBookIds.isEmpty())
assertTrue(result.contextualActionItems.isEmpty())
}
@Test
fun `replaceBookSelectionWithVisibleBooks selects visible books through shared reducer`() {
val visible = recentFile("visible")
val hidden = recentFile("hidden")
val result = AndroidSharedStateBridge.replaceBookSelectionWithVisibleBooks(
current = ReaderScreenState(),
projectedState = ReaderScreenState(rawLibraryFiles = listOf(visible, hidden)),
visibleBooks = listOf(visible)
)
assertEquals(setOf(visible), result.contextualActionItems)
}
@Test
fun `replaceBookSelectionWithVisibleBooks clears when visible books are already selected`() {
val visible = recentFile("visible")
val result = AndroidSharedStateBridge.replaceBookSelectionWithVisibleBooks(
current = ReaderScreenState(contextualActionItems = setOf(visible)),
projectedState = ReaderScreenState(rawLibraryFiles = listOf(visible)),
visibleBooks = listOf(visible)
)
assertTrue(result.contextualActionItems.isEmpty())
}
private fun recentFile(
id: String,
sourceFolderUri: String? = null
) = RecentFileItem(
bookId = id,
uriString = "content://$id",
type = FileType.EPUB,
displayName = "$id.epub",
timestamp = 1L,
sourceFolderUri = sourceFolderUri
)
private fun tag(id: String, name: String) = TagEntity(
id = id,
name = name,
createdAt = 1L
)
}