* Centralize library management logic and introduce support for plain text and HTML formats

* Centralize library management logic and introduce support for plain text and HTML formats

* Expand unit test coverage for library state management, UI models, and MainViewModel features.

* Add comprehensive unit tests for PDF reader core logic, preferences, and data persistence

* Add unit tests for EPUB parsing, content loading, search functionality, and reader JavaScript bridges.

* Add unit tests for OPDS parsing and Smart Collection engine, and integrate Kover plugin

* Add comprehensive unit tests

* Centralize library snapshot serialization in the `shared` module and improve filtering and sorting logic.

* Implement text selection, highlighting, and reading state persistence for PDF and EPUB engines in desktop version

* Folder import support for desktop app

* Introduce Smart Shelves with rule-based filtering in desktop version

* Implement shared EPUB annotation serialization and highlight rendering

* Centralize file type capabilities and platform-specific support logic

* Refactor reader state management to use a central reducer

* Implement customizable reader toolbar and advanced formatting settings in shared

* Implement locator-based navigation and customizable highlight palette for desktop app

* Enhance reader customization and expand search functionality in desktop app

* Redesign reader settings and tools into a tabbed control panel in desktop app

* Enhance reader navigation and highlight precision in desktop app

* Implement bidirectional position synchronization and dynamic highlights in the desktop reader

* Implement shared state management and enhanced search for the PDF reader in desktop app

* Add vertical scroll support to the desktop PDF reader

* Implement ink, text, and eraser annotation support in desktop PDF viewer

* Implement PDF bookmarks, Table of Contents, and annotation editing in desktop app

* Implement link handling and navigation for PDF and EPUB readers in desktop app

* Implement PDF jump history for navigation in desktop app

* Enhance PDF ink rendering and annotation capabilities in desktop app

* Implement advanced PDF text annotations with inline editing and rich styling in desktop app

* Add move handle and movement logic for PDF text annotations in desktop app

* Implement local folder synchronization and metadata sidecar support in desktop app

* Implement book metadata extraction and drag-and-drop import for Desktop

* Implement dynamic and custom app theme management for desktop

* Introduce canonical PDF annotation codec and support for multi-segment highlights

* Implement rich text editing and pagination support for the PDF reader in desktop app

* Improve PDF rich text pagination, synchronization, and observability in desktop

* Hide trailing structural page breaks in rich text editor

* Implement a unified JVM book loader and expand supported formats on Desktop

* Add comic archive support for Desktop and enhance MOBI parsing

* Implement shared OPDS catalog support and UI for Android and Desktop

* Improve native WebView lifecycle and surface transition management on Desktop

* Enable Compose Swing interop blending and simplify Desktop WebView management

* Integrate BYOK AI features and Cloud TTS for desktop

* Enhance Desktop TTS with streaming audio and improved secure storage for AI key

* Implement scoped Cloud TTS with synchronized highlighting for EPUB and PDF in desktop app

* Implement custom font management and utility screens in desktop app

* Implement PDFium-based PDF annotation export

* Remove PdfBox dependency and standardize PDF export via Pdfium

* Implement local audio caching and playback controls for Gemini Cloud TTS in desktop app

* Implement reader themes and custom texture support in desktop app

* Redesign non-reader UI with responsive navigation and enhanced library management in desktop app

* Introduce ReaderWorkspaceShell to unify EPUB and PDF reader layouts in desktop app

* Exclude manual-only files from automated sync and import

* Implement customizable Text-to-Speech (TTS) word replacements

* Optimize reader performance with persistent layout caching and decoupled theme rendering

* Improve position restoration during reader reconfiguration in epub pagination

* Use independent thickness for eraser tool and stylus override
This commit is contained in:
Aryan 2026-05-10 10:07:37 +05:30 committed by GitHub
parent 88c7fa7b5c
commit 8366d76dcd
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
214 changed files with 53372 additions and 4702 deletions

View file

@ -0,0 +1,147 @@
package com.aryan.reader.pdf
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.toArgb
import com.aryan.reader.pdf.data.AnnotationSettingsRepository
import com.aryan.reader.pdf.data.AnnotationToolSettings
import com.aryan.reader.pdf.data.TextStyleConfig
import com.aryan.reader.pdf.data.ToolConfig
import com.aryan.reader.shared.pdf.PdfAnnotationKind
import com.aryan.reader.shared.pdf.PdfInkTool
import com.aryan.reader.shared.pdf.PdfPageBounds
import com.aryan.reader.shared.pdf.PdfPagePoint
import com.aryan.reader.shared.pdf.PdfZoomSpec
import com.aryan.reader.shared.pdf.SharedPdfAnnotation
import com.aryan.reader.shared.pdf.SharedPdfAnnotationDefaults
import com.aryan.reader.shared.pdf.SharedPdfAnnotationSerializer
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
class PdfReaderSettingsAndSharedModelsTest {
@Test
fun `AnnotationToolSettings falls back safely for invalid selected and last tools`() {
val settings = AnnotationToolSettings(
selectedToolName = "BROKEN",
lastActivePenType = "MISSING",
lastActiveHighlighterType = "NOPE"
)
assertEquals(InkType.PEN, settings.getActiveTool())
assertEquals(InkType.PEN, settings.getLastPenTool())
assertEquals(InkType.HIGHLIGHTER, settings.getLastHighlighterTool())
}
@Test
fun `AnnotationToolSettings returns custom configs and palettes`() {
val settings = AnnotationToolSettings(
selectedToolName = InkType.TEXT.name,
toolConfigs = mapOf(InkType.PEN.name to ToolConfig(Color.Cyan.toArgb(), 0.25f)),
penPaletteArgb = listOf(Color.Red.toArgb(), Color.Green.toArgb()),
highlighterPaletteArgb = listOf(Color.Yellow.toArgb()),
textStyle = TextStyleConfig(colorArgb = Color.Magenta.toArgb(), fontSize = 22f),
isHighlighterSnapEnabled = true
)
assertEquals(InkType.TEXT, settings.getActiveTool())
assertEquals(Color.Cyan.toArgb(), settings.getToolColor(InkType.PEN).toArgb())
assertEquals(0.25f, settings.getToolThickness(InkType.PEN), 0.0001f)
assertEquals(Color.Red.toArgb(), settings.getPenPalette().first().toArgb())
assertEquals(Color.Yellow.toArgb(), settings.getHighlighterPalette().single().toArgb())
assertTrue(settings.isHighlighterSnapEnabled)
assertEquals(22f, settings.textStyle.fontSize, 0.0001f)
}
@Test
fun `AnnotationSettingsRepository default configs cover every ink type`() {
InkType.entries.forEach { type ->
val config = AnnotationSettingsRepository.getDefaultConfig(type)
assertTrue("Expected positive thickness for $type", config.thickness > 0f)
}
}
@Test
fun `SharedPdfAnnotationSerializer round trips current store shape`() {
val annotation = SharedPdfAnnotation(
id = "ann-1",
pageIndex = 7,
kind = PdfAnnotationKind.TEXT,
tool = PdfInkTool.TEXT,
points = listOf(PdfPagePoint(0.1f, 0.2f, 100L)),
bounds = PdfPageBounds(0.1f, 0.2f, 0.3f, 0.4f),
text = "Margin note",
colorArgb = 0xFF112233.toInt(),
backgroundArgb = 0x66112233,
strokeWidth = 1.5f,
fontSize = 19f,
isBold = true,
isItalic = true,
createdAt = 1234L
)
val decoded = SharedPdfAnnotationSerializer.decode(
SharedPdfAnnotationSerializer.encode(listOf(annotation))
)
assertEquals(listOf(annotation), decoded)
assertEquals(emptyList<SharedPdfAnnotation>(), SharedPdfAnnotationSerializer.decode(""))
assertEquals(emptyList<SharedPdfAnnotation>(), SharedPdfAnnotationSerializer.decode("bad json"))
}
@Test
fun `SharedPdfAnnotationSerializer decodes legacy bare annotation array`() {
val legacyJson = """
[
{
"id": "legacy",
"pageIndex": 1,
"kind": "INK",
"tool": "PEN",
"points": [{"x":0.2,"y":0.3,"timestamp":9}],
"colorArgb": -1
}
]
""".trimIndent()
val decoded = SharedPdfAnnotationSerializer.decode(legacyJson).single()
assertEquals("legacy", decoded.id)
assertEquals(1, decoded.pageIndex)
assertEquals(PdfAnnotationKind.INK, decoded.kind)
assertEquals(PdfInkTool.PEN, decoded.tool)
assertEquals(PdfPagePoint(0.2f, 0.3f, 9L), decoded.points.single())
}
@Test
fun `SharedPdfAnnotationDefaults supplies expected tool defaults and palettes`() {
assertEquals(5, SharedPdfAnnotationDefaults.penPalette.size)
assertEquals(5, SharedPdfAnnotationDefaults.highlighterPalette.size)
val pen = SharedPdfAnnotationDefaults.configFor(PdfInkTool.PEN)
val eraser = SharedPdfAnnotationDefaults.configFor(PdfInkTool.ERASER)
val highlighter = SharedPdfAnnotationDefaults.configFor(PdfInkTool.HIGHLIGHTER)
assertTrue(pen.strokeWidth > 0f)
assertEquals(0x00000000, eraser.colorArgb)
assertTrue(highlighter.strokeWidth > pen.strokeWidth)
}
@Test
fun `PdfZoomSpec clamps scale and keeps render size under pixel budget`() {
val spec = PdfZoomSpec(min = 0.5f, max = 4f, default = 1f, maxRenderPixels = 1_000_000)
assertEquals(0.5f, spec.clamp(0.1f), 0.0001f)
assertEquals(4f, spec.clamp(10f), 0.0001f)
val safeScale = spec.safeRenderScale(pageWidth = 2_000f, pageHeight = 2_000f, requestedScale = 4f)
assertTrue(safeScale < 1f)
assertTrue(safeScale >= 0.1f)
val (width, height) = spec.renderSize(pageWidth = 2_000f, pageHeight = 2_000f, requestedScale = 4f)
assertTrue(width * height <= 1_000_000)
assertTrue(width >= 1)
assertTrue(height >= 1)
}
}