* 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,200 @@
package com.aryan.reader.epubreader
import android.webkit.WebView
import com.aryan.reader.RenderMode
import io.mockk.mockk
import io.mockk.verify
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.test.runTest
import org.json.JSONArray
import org.json.JSONObject
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
@RunWith(RobolectricTestRunner::class)
class EpubReaderBridgeAndControlsTest {
@Test
fun `sanitizePlaceholders keeps one header per toolbar section and inserts empty placeholders`() {
val input = listOf(
FlatToolItem("old_header", FlatItemType.SECTION_HEADER, section = ToolbarSection.BOTTOM),
FlatToolItem("format", FlatItemType.TOOL, tool = ReaderTool.FORMAT, section = ToolbarSection.BOTTOM),
FlatToolItem("more_header", FlatItemType.MORE_HEADER, title = "More"),
FlatToolItem("reading_mode", FlatItemType.MORE_TOOL, tool = ReaderTool.READING_MODE)
)
val sanitized = sanitizePlaceholders(input)
assertEquals(
listOf(
FlatItemType.SECTION_HEADER,
FlatItemType.EMPTY_PLACEHOLDER,
FlatItemType.SECTION_HEADER,
FlatItemType.TOOL,
FlatItemType.SECTION_HEADER,
FlatItemType.EMPTY_PLACEHOLDER,
FlatItemType.MORE_HEADER,
FlatItemType.MORE_TOOL
),
sanitized.map { it.type }
)
assertEquals(listOf(ToolbarSection.TOP, ToolbarSection.BOTTOM, ToolbarSection.HIDDEN), sanitized.filter { it.type == FlatItemType.SECTION_HEADER }.map { it.section })
assertEquals(ReaderTool.FORMAT, sanitized.single { it.type == FlatItemType.TOOL }.tool)
}
@Test
fun `auto scroll bridge invokes chapter end callback`() {
var calls = 0
AutoScrollJsBridge { calls++ }.onChapterEnd()
assertEquals(1, calls)
}
@Test
fun `tts bridge relays nonblank structured text and normalizes blank payloads`() = runTest {
val received = CompletableDeferred<String>()
val bridge = TtsJsBridge(scope = this, ttsStructuredTextHandler = { received.complete(it) })
bridge.onStructuredTextExtracted("[{\"text\":\"Hello\"}]")
assertEquals("[{\"text\":\"Hello\"}]", received.await())
val blankReceived = CompletableDeferred<String>()
TtsJsBridge(scope = this, ttsStructuredTextHandler = { blankReceived.complete(it) }).onStructuredTextExtracted(" ")
assertEquals("[]", blankReceived.await())
}
@Test
fun `highlight bridge forwards create and click events`() {
var created: Triple<String, String, String>? = null
var clicked: List<Any>? = null
val bridge = HighlightJsBridge(
onCreateCallback = { cfi, text, color -> created = Triple(cfi, text, color) },
onClickCallback = { cfi, text, left, top, right, bottom ->
clicked = listOf(cfi, text, left, top, right, bottom)
}
)
bridge.onHighlightCreated("/4", "Text", "yellow")
bridge.onHighlightClicked("/4", "Text", 1, 2, 3, 4)
assertEquals(Triple("/4", "Text", "yellow"), created)
assertEquals(listOf("/4", "Text", 1, 2, 3, 4), clicked)
}
@Test
fun `content snippet progress footnote and ai bridges forward callbacks`() = runTest {
var requestedChunk = -1
var snippet = "" to ""
var progressCalls = 0
var lastChunk = -1
var footnote = ""
val aiContent = CompletableDeferred<String>()
ContentBridge { requestedChunk = it }.requestChunk(7)
SnippetJsBridge { cfi, text -> snippet = cfi to text }.onSnippetExtracted("/6", "Snippet")
val progress = ProgressJsBridge {
progressCalls++
lastChunk = it
}
progress.updateTopChunk(2)
progress.updateTopChunk(2)
progress.updateTopChunk(3)
FootnoteJsBridge { footnote = it }.onFootnoteRequested("<p>Note</p>")
AiJsBridge(scope = this, onContentReady = { aiContent.complete(it) }).onContentExtractedForSummarization("Chapter text")
assertEquals(7, requestedChunk)
assertEquals("/6" to "Snippet", snippet)
assertEquals(2, progressCalls)
assertEquals(3, lastChunk)
assertEquals("<p>Note</p>", footnote)
assertEquals("Chapter text", aiContent.await())
}
@Test
fun `ai bridge ignores blank content`() = runTest {
var called = false
AiJsBridge(scope = this, onContentReady = { called = true }).onContentExtractedForSummarization(" ")
assertFalse(called)
}
@Test
fun `cfi bridge parses save bookmark and scroll callbacks with fallback for invalid save json`() {
val saved = mutableListOf<String>()
val bookmark = mutableListOf<String>()
val scrollResults = mutableListOf<Boolean>()
val bridge = CfiJsBridge(
onCfiReady = { saved.add(it) },
onCfiForBookmarkReady = { bookmark.add(it) },
onScrollFinishedCallback = { scrollResults.add(it) }
)
bridge.onCfiExtracted(JSONObject().put("cfi", "/4/2:8").put("log", JSONArray()).toString())
bridge.onCfiExtracted(JSONObject().put("cfi", "").toString())
bridge.onCfiExtracted("broken")
bridge.onCfiForBookmarkExtracted(JSONObject().put("cfi", "/6/4:1").toString())
bridge.onCfiForBookmarkExtracted("broken")
bridge.onScrollFinished(true)
bridge.onScrollFinished(false)
assertEquals(listOf("/4/2:8", "/4"), saved)
assertEquals(listOf("/6/4:1"), bookmark)
assertEquals(listOf(true, false), scrollResults)
}
@Test
fun `cfi bridge preserves full reading position cfi payloads for save and bookmark callbacks`() {
val saved = mutableListOf<String>()
val bookmark = mutableListOf<String>()
val bridge = CfiJsBridge(
onCfiReady = { saved.add(it) },
onCfiForBookmarkReady = { bookmark.add(it) },
onScrollFinishedCallback = {}
)
val cfi = "/6/4[chapter]!/4/2/8:137"
bridge.onCfiExtracted(JSONObject().put("cfi", cfi).put("log", JSONArray().put("exact")).toString())
bridge.onCfiForBookmarkExtracted(JSONObject().put("cfi", cfi).put("log", JSONArray()).toString())
assertEquals(listOf(cfi), saved)
assertEquals(listOf(cfi), bookmark)
}
@Test
fun `updateAutoScrollJs emits start and stop commands`() {
val webView = mockk<WebView>(relaxed = true)
updateAutoScrollJs(webView, playing = true, speed = 1.25f)
updateAutoScrollJs(webView, playing = false, speed = 9f)
verify { webView.evaluateJavascript("javascript:window.autoScroll.start(1.25);", null) }
verify { webView.evaluateJavascript("javascript:window.autoScroll.stop();", null) }
}
@Test
fun `initiateTtsPlayback chooses web extraction for vertical mode and callback for paginated mode`() {
val webView = mockk<WebView>(relaxed = true)
var paginatedStarts = 0
initiateTtsPlayback(RenderMode.VERTICAL_SCROLL, webView) { paginatedStarts++ }
initiateTtsPlayback(RenderMode.PAGINATED, webView) { paginatedStarts++ }
verify { webView.evaluateJavascript("javascript:TtsBridgeHelper.extractAndRelayText();", null) }
assertEquals(1, paginatedStarts)
}
@Test
fun `reader tool metadata has stable unique names and categories`() {
assertEquals(ReaderTool.entries.size, ReaderTool.entries.map { it.name }.toSet().size)
assertTrue(ReaderTool.entries.any { it.category == "Top Bar" })
assertTrue(ReaderTool.entries.any { it.category == "Bottom Bar" })
assertTrue(ReaderTool.entries.any { it.category == "Overflow Menu" })
}
}