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

app/src/test/java/com/aryan/reader/data/FileTypeConverterTest.kt

@@ -0,0 +1,21 @@
+package com.aryan.reader.data
+
+import com.aryan.reader.FileType
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class FileTypeConverterTest {
+
+    @Test
+    fun `room converter stores enum names and preserves unknown fallback`() {
+        val converter = FileTypeConverter()
+
+        assertEquals("PDF", converter.fromFileType(FileType.PDF))
+        assertEquals(FileType.PDF, converter.toFileType("PDF"))
+        assertEquals("UNKNOWN", converter.fromFileType(FileType.UNKNOWN))
+        assertEquals(FileType.UNKNOWN, converter.toFileType("UNKNOWN"))
+        assertNull(converter.fromFileType(null))
+        assertNull(converter.toFileType(null))
+    }
+}

app/src/test/java/com/aryan/reader/data/FolderBookMetadataTest.kt

@@ -31,7 +31,15 @@ class FolderBookMetadataTest {
 
         val decoded = FolderBookMetadata.fromJsonString(metadata.toJsonString())
 
-        assertEquals(metadata.copy(author = null, lastPage = null, locatorCharOffset = null), decoded)
+        assertEquals(
+            metadata.copy(
+                title = null,
+                author = null,
+                lastPage = null,
+                locatorCharOffset = null
+            ),
+            decoded
+        )
     }
 
     @Test
@@ -78,8 +86,8 @@ class FolderBookMetadataTest {
 
         assertEquals("book-2", item.bookId)
         assertEquals(FileType.EPUB, item.type)
-        assertEquals("Remote Title", item.title)
-        assertEquals("Author", item.author)
+        assertEquals("Remote", item.title)
+        assertNull(item.author)
         assertEquals(12, item.lastPage)
         assertEquals(7, item.locatorBlockIndex)
         assertEquals(8, item.locatorCharOffset)
@@ -87,4 +95,34 @@ class FolderBookMetadataTest {
         assertEquals("Shelf Name", item.customName)
         assertEquals("highlights", item.highlightsJson)
     }
+
+    @Test
+    fun `toRecentFileItem preserves explicit unknown file type`() {
+        val metadata = FolderBookMetadata(
+            bookId = "book-3",
+            title = null,
+            author = null,
+            displayName = "Remote.bin",
+            type = "UNKNOWN",
+            lastChapterIndex = null,
+            lastPage = null,
+            lastPositionCfi = null,
+            progressPercentage = 0f,
+            isRecent = false,
+            lastModifiedTimestamp = 500L,
+            bookmarksJson = null,
+            locatorBlockIndex = null,
+            locatorCharOffset = null,
+            customName = null,
+            highlightsJson = null
+        )
+
+        val item = metadata.toRecentFileItem(
+            uriString = "content://book",
+            coverPath = null,
+            sourceFolderUri = "content://folder"
+        )
+
+        assertEquals(FileType.UNKNOWN, item.type)
+    }
 }

app/src/test/java/com/aryan/reader/data/RecentFileDaoMetadataExtractionTest.kt

@@ -0,0 +1,244 @@
+package com.aryan.reader.data
+
+import androidx.room.Room
+import com.aryan.reader.FileType
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class RecentFileDaoMetadataExtractionTest {
+
+    private lateinit var db: AppDatabase
+    private lateinit var dao: RecentFileDao
+
+    @Before
+    fun setUp() {
+        db = Room.inMemoryDatabaseBuilder(
+            RuntimeEnvironment.getApplication(),
+            AppDatabase::class.java
+        ).allowMainThreadQueries().build()
+        dao = db.recentFileDao()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+    }
+
+    @Test
+    fun `cover-only ebook metadata candidate is marked attempted after no cover is found`() = runTest {
+        dao.insertOrUpdateFile(
+            recentFileEntity(
+                folderTextMetadataParsed = true,
+                folderCoverMetadataParsed = false
+            )
+        )
+
+        assertEquals(1, dao.countFolderBooksNeedingTextMetadata("content://folder"))
+
+        dao.updateExtractedMetadata(
+            bookId = "book-1",
+            coverImagePath = null,
+            title = null,
+            author = null,
+            seriesName = null,
+            seriesIndex = null,
+            description = null,
+            fileSize = 0L,
+            fileContentModifiedTimestamp = 0L,
+            textMetadataParsed = false,
+            coverMetadataParsed = true
+        )
+
+        val saved = dao.getFileByBookId("book-1")!!
+        assertFalse(saved.coverImagePath?.isNotBlank() == true)
+        assertTrue(saved.folderCoverMetadataParsed)
+        assertEquals(0, dao.countFolderBooksNeedingTextMetadata("content://folder"))
+    }
+
+    @Test
+    fun `metadata candidate query respects batch limit`() = runTest {
+        dao.insertOrUpdateFile(recentFileEntity(bookId = "book-1", timestamp = 1_000L))
+        dao.insertOrUpdateFile(recentFileEntity(bookId = "book-2", timestamp = 2_000L))
+
+        val pending = dao.getFolderBooksNeedingTextMetadata("content://folder", limit = 1)
+
+        assertEquals(1, pending.size)
+        assertEquals("book-2", pending.single().bookId)
+    }
+
+    @Test
+    fun `metadata extraction does not replace user edited metadata`() = runTest {
+        dao.insertOrUpdateFile(
+            recentFileEntity().copy(
+                title = "Edited title",
+                author = "Edited author",
+                originalTitle = "Original title",
+                originalAuthor = "Original author"
+            )
+        )
+
+        dao.updateExtractedMetadata(
+            bookId = "book-1",
+            coverImagePath = null,
+            title = "Extracted title",
+            author = "Extracted author",
+            seriesName = null,
+            seriesIndex = null,
+            description = null,
+            fileSize = 0L,
+            fileContentModifiedTimestamp = 0L,
+            textMetadataParsed = true,
+            coverMetadataParsed = false
+        )
+
+        val saved = dao.getFileByBookId("book-1")!!
+        assertEquals("Edited title", saved.title)
+        assertEquals("Edited author", saved.author)
+        assertEquals("Original title", saved.originalTitle)
+        assertEquals("Original author", saved.originalAuthor)
+    }
+
+    @Test
+    fun `metadata extraction promotes extracted values before user edits`() = runTest {
+        dao.insertOrUpdateFile(
+            recentFileEntity().copy(
+                title = "book-1.epub",
+                author = null,
+                originalTitle = "book-1.epub",
+                originalAuthor = null
+            )
+        )
+
+        dao.updateExtractedMetadata(
+            bookId = "book-1",
+            coverImagePath = null,
+            title = "Extracted title",
+            author = "Extracted author",
+            seriesName = null,
+            seriesIndex = null,
+            description = null,
+            fileSize = 0L,
+            fileContentModifiedTimestamp = 0L,
+            textMetadataParsed = true,
+            coverMetadataParsed = false
+        )
+
+        val saved = dao.getFileByBookId("book-1")!!
+        assertEquals("Extracted title", saved.title)
+        assertEquals("Extracted author", saved.author)
+        assertEquals("Extracted title", saved.originalTitle)
+        assertEquals("Extracted author", saved.originalAuthor)
+    }
+
+    @Test
+    fun `restore original metadata restores snapshot and clears display override`() = runTest {
+        dao.insertOrUpdateFile(
+            recentFileEntity().copy(
+                title = "Edited title",
+                author = "Edited author",
+                seriesName = "Edited series",
+                seriesIndex = 2.0,
+                description = "Edited summary",
+                customName = "Edited display",
+                originalTitle = "Original title",
+                originalAuthor = "Original author",
+                originalSeriesName = "Original series",
+                originalSeriesIndex = 1.0,
+                originalDescription = "Original summary"
+            )
+        )
+
+        dao.restoreOriginalMetadata("book-1", fileSize = 0L, fileContentModifiedTimestamp = 0L, timestamp = 9_000L)
+
+        val saved = dao.getFileByBookId("book-1")!!
+        assertEquals("Original title", saved.title)
+        assertEquals("Original author", saved.author)
+        assertEquals("Original series", saved.seriesName)
+        assertEquals(1.0, saved.seriesIndex)
+        assertEquals("Original summary", saved.description)
+        assertNull(saved.customName)
+        assertEquals(9_000L, saved.lastModifiedTimestamp)
+    }
+
+    @Test
+    fun `manual metadata update seeds missing original snapshot from previous values`() = runTest {
+        dao.insertOrUpdateFile(
+            recentFileEntity().copy(
+                title = "Existing title",
+                author = "Existing author",
+                customName = "Display override",
+                originalTitle = null,
+                originalAuthor = null
+            )
+        )
+
+        dao.updateUserEditableMetadata(
+            bookId = "book-1",
+            title = "Edited title",
+            author = "Edited author",
+            seriesName = null,
+            seriesIndex = null,
+            description = null,
+            fileSize = 0L,
+            fileContentModifiedTimestamp = 0L,
+            timestamp = 5_000L
+        )
+
+        val saved = dao.getFileByBookId("book-1")!!
+        assertEquals("Edited title", saved.title)
+        assertEquals("Edited author", saved.author)
+        assertEquals("Existing title", saved.originalTitle)
+        assertEquals("Existing author", saved.originalAuthor)
+        assertNull(saved.customName)
+    }
+
+    private fun recentFileEntity(
+        bookId: String = "book-1",
+        timestamp: Long = 1_000L,
+        folderTextMetadataParsed: Boolean = false,
+        folderCoverMetadataParsed: Boolean = false
+    ): RecentFileEntity {
+        return RecentFileEntity(
+            bookId = bookId,
+            uriString = "content://books/$bookId",
+            type = FileType.EPUB,
+            displayName = "$bookId.epub",
+            timestamp = timestamp,
+            coverImagePath = null,
+            title = "One",
+            author = "Author",
+            lastChapterIndex = null,
+            lastPage = null,
+            lastPositionCfi = null,
+            progressPercentage = null,
+            isRecent = false,
+            isAvailable = true,
+            lastModifiedTimestamp = timestamp,
+            isDeleted = false,
+            locatorBlockIndex = null,
+            locatorCharOffset = null,
+            bookmarks = null,
+            sourceFolderUri = "content://folder",
+            isReflowPreferred = false,
+            customName = null,
+            highlights = null,
+            fileSize = 123L,
+            fileContentModifiedTimestamp = 1_234L,
+            seriesName = null,
+            seriesIndex = null,
+            description = null,
+            folderTextMetadataParsed = folderTextMetadataParsed,
+            folderCoverMetadataParsed = folderCoverMetadataParsed
+        )
+    }
+}

app/src/test/java/com/aryan/reader/data/RecentFileItemReadingPositionMappingTest.kt

@@ -17,6 +17,7 @@ class RecentFileItemReadingPositionMappingTest {
         assertEquals(item.locatorBlockIndex, roundTripped.locatorBlockIndex)
         assertEquals(item.locatorCharOffset, roundTripped.locatorCharOffset)
         assertEquals(item.progressPercentage, roundTripped.progressPercentage)
+        assertEquals(item.fileContentModifiedTimestamp, roundTripped.fileContentModifiedTimestamp)
     }
 
     @Test
@@ -30,6 +31,59 @@ class RecentFileItemReadingPositionMappingTest {
         assertEquals(item.locatorBlockIndex, roundTripped.locatorBlockIndex)
         assertEquals(item.locatorCharOffset, roundTripped.locatorCharOffset)
         assertEquals(item.progressPercentage, roundTripped.progressPercentage)
+        assertEquals(item.fileContentModifiedTimestamp, roundTripped.fileContentModifiedTimestamp)
+    }
+
+    @Test
+    fun `cloud metadata mapping preserves non epub display rename as custom name`() {
+        val item = recentFileItem().copy(
+            type = FileType.PDF,
+            customName = "Reader Display Name"
+        )
+
+        val roundTripped = item.toBookMetadata().toRecentFileItem()
+
+        assertEquals("Reader Display Name", roundTripped.customName)
+        assertEquals("One.epub", roundTripped.displayName)
+    }
+
+    @Test
+    fun `recent file entity mapping preserves original metadata snapshot`() {
+        val item = recentFileItem().copy(
+            title = "Edited One",
+            author = "Edited Author",
+            seriesName = "Edited Series",
+            seriesIndex = 2.0,
+            description = "Edited summary",
+            originalTitle = "Original One",
+            originalAuthor = "Original Author",
+            originalSeriesName = "Original Series",
+            originalSeriesIndex = 1.0,
+            originalDescription = "Original summary"
+        )
+
+        val roundTripped = item.toRecentFileEntity().toRecentFileItem()
+
+        assertEquals("Original One", roundTripped.originalTitle)
+        assertEquals("Original Author", roundTripped.originalAuthor)
+        assertEquals("Original Series", roundTripped.originalSeriesName)
+        assertEquals(1.0, roundTripped.originalSeriesIndex)
+        assertEquals("Original summary", roundTripped.originalDescription)
+    }
+
+    @Test
+    fun `recent file entity mapping seeds original metadata when first stored`() {
+        val entity = recentFileItem().copy(
+            seriesName = "Series",
+            seriesIndex = 1.0,
+            description = "Summary"
+        ).toRecentFileEntity()
+
+        assertEquals("One", entity.originalTitle)
+        assertEquals("Author", entity.originalAuthor)
+        assertEquals("Series", entity.originalSeriesName)
+        assertEquals(1.0, entity.originalSeriesIndex)
+        assertEquals("Summary", entity.originalDescription)
     }
 
     private fun recentFileItem(): RecentFileItem {
@@ -47,6 +101,7 @@ class RecentFileItemReadingPositionMappingTest {
             locatorCharOffset = 88,
             progressPercentage = 61.5f,
             lastModifiedTimestamp = 2_000L,
+            fileContentModifiedTimestamp = 3_000L,
             bookmarksJson = """[{"cfi":"/4/2"}]""",
             highlightsJson = """[{"cfi":"/4/2/6:88"}]"""
         )

app/src/test/java/com/aryan/reader/data/RecentFilesRepositoryReadingPositionMergeTest.kt

@@ -14,7 +14,9 @@ import io.mockk.unmockkObject
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.test.runTest
 import org.junit.After
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
 import org.junit.Before
 import org.junit.Test
 import java.io.File
@@ -113,14 +115,82 @@ class RecentFilesRepositoryReadingPositionMergeTest {
         assertEquals(82f, inserted.captured.progressPercentage)
     }
 
-    private fun existingEntity(): RecentFileEntity {
+    @Test
+    fun `addRecentFile keeps edited embedded epub metadata when cached parser returns original metadata`() = runTest {
+        val inserted = slot<RecentFileEntity>()
+        coEvery { recentFileDao.getFileByBookId("book-1") } returns existingEntity().copy(
+            author = "Edited Author",
+            originalAuthor = "Author",
+            fileContentModifiedTimestamp = 5_000L
+        )
+        coEvery { recentFileDao.insertOrUpdateFile(capture(inserted)) } just Runs
+
+        repository.addRecentFile(
+            RecentFileItem(
+                bookId = "book-1",
+                uriString = "content://new",
+                type = FileType.EPUB,
+                displayName = "New.epub",
+                timestamp = 2_000L,
+                title = "Old",
+                author = "Author",
+                fileContentModifiedTimestamp = 5_000L,
+                isRecent = true
+            )
+        )
+
+        assertEquals("Edited Author", inserted.captured.author)
+        assertEquals("Author", inserted.captured.originalAuthor)
+    }
+
+    @Test
+    fun `addRecentFile clears extracted metadata when folder file size changes`() = runTest {
+        val inserted = slot<RecentFileEntity>()
+        coEvery { recentFileDao.getFileByBookId("book-1") } returns existingEntity(
+            fileSize = 123L,
+            folderTextMetadataParsed = true,
+            folderCoverMetadataParsed = true,
+            coverImagePath = "/covers/old.png"
+        )
+        coEvery { recentFileDao.insertOrUpdateFile(capture(inserted)) } just Runs
+
+        repository.addRecentFile(
+            RecentFileItem(
+                bookId = "book-1",
+                uriString = "content://new",
+                type = FileType.EPUB,
+                displayName = "New.epub",
+                timestamp = 2_000L,
+                sourceFolderUri = "content://folder",
+                fileSize = 456L,
+                isRecent = true
+            )
+        )
+
+        assertEquals(456L, inserted.captured.fileSize)
+        assertNull(inserted.captured.coverImagePath)
+        assertEquals("New", inserted.captured.title)
+        assertNull(inserted.captured.author)
+        assertNull(inserted.captured.seriesName)
+        assertNull(inserted.captured.description)
+        assertNull(inserted.captured.originalTitle)
+        assertFalse(inserted.captured.folderTextMetadataParsed)
+        assertFalse(inserted.captured.folderCoverMetadataParsed)
+    }
+
+    private fun existingEntity(
+        fileSize: Long = 123L,
+        folderTextMetadataParsed: Boolean = true,
+        folderCoverMetadataParsed: Boolean = false,
+        coverImagePath: String? = "/covers/old.png"
+    ): RecentFileEntity {
         return RecentFileEntity(
             bookId = "book-1",
             uriString = "content://old",
             type = FileType.EPUB,
             displayName = "Old.epub",
             timestamp = 1_000L,
-            coverImagePath = "/covers/old.png",
+            coverImagePath = coverImagePath,
             title = "Old",
             author = "Author",
             lastChapterIndex = 6,
@@ -138,11 +208,12 @@ class RecentFilesRepositoryReadingPositionMergeTest {
             isReflowPreferred = false,
             customName = "Custom",
             highlights = "highlights",
-            fileSize = 123L,
+            fileSize = fileSize,
             seriesName = "Series",
             seriesIndex = 1.0,
             description = "Description",
-            folderTextMetadataParsed = true
+            folderTextMetadataParsed = folderTextMetadataParsed,
+            folderCoverMetadataParsed = folderCoverMetadataParsed
         )
     }
 }