* 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,180 @@
package com.aryan.reader.shared
enum class ReaderPlatform {
ANDROID,
DESKTOP
}
enum class ReaderFeatureSurface {
PDF_VIEWER,
EPUB_READER,
TEXT_READER
}
data class FileTypeCapability(
val type: FileType,
val displayName: String,
val extensions: Set<String>,
val androidSurface: ReaderFeatureSurface?,
val desktopSurface: ReaderFeatureSurface?,
val syncEligible: Boolean = true
) {
val isReadableOnAndroid: Boolean get() = androidSurface != null
val isReadableOnDesktop: Boolean get() = desktopSurface != null
fun surfaceFor(platform: ReaderPlatform): ReaderFeatureSurface? {
return when (platform) {
ReaderPlatform.ANDROID -> androidSurface
ReaderPlatform.DESKTOP -> desktopSurface
}
}
}
object SharedFileCapabilities {
val all: List<FileTypeCapability> = listOf(
FileTypeCapability(
type = FileType.EPUB,
displayName = "EPUB",
extensions = setOf("epub"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.EPUB_READER
),
FileTypeCapability(
type = FileType.PDF,
displayName = "PDF",
extensions = setOf("pdf"),
androidSurface = ReaderFeatureSurface.PDF_VIEWER,
desktopSurface = ReaderFeatureSurface.PDF_VIEWER
),
FileTypeCapability(
type = FileType.TXT,
displayName = "TXT",
extensions = setOf("txt"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.MD,
displayName = "Markdown",
extensions = setOf("md", "markdown"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.HTML,
displayName = "HTML",
extensions = setOf("html", "htm", "xhtml"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.MOBI,
displayName = "MOBI",
extensions = setOf("mobi", "azw", "azw3", "prc"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.FB2,
displayName = "FB2",
extensions = setOf("fb2"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.CBZ,
displayName = "CBZ",
extensions = setOf("cbz"),
androidSurface = ReaderFeatureSurface.PDF_VIEWER,
desktopSurface = ReaderFeatureSurface.PDF_VIEWER
),
FileTypeCapability(
type = FileType.CBR,
displayName = "CBR",
extensions = setOf("cbr"),
androidSurface = ReaderFeatureSurface.PDF_VIEWER,
desktopSurface = ReaderFeatureSurface.PDF_VIEWER
),
FileTypeCapability(
type = FileType.CB7,
displayName = "CB7",
extensions = setOf("cb7"),
androidSurface = ReaderFeatureSurface.PDF_VIEWER,
desktopSurface = ReaderFeatureSurface.PDF_VIEWER
),
FileTypeCapability(
type = FileType.DOCX,
displayName = "DOCX",
extensions = setOf("docx"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.ODT,
displayName = "ODT",
extensions = setOf("odt"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.FODT,
displayName = "FODT",
extensions = setOf("fodt"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
)
)
private val capabilitiesByType: Map<FileType, FileTypeCapability> = all.associateBy { it.type }
private val typesByExtension: Map<String, FileType> = all
.flatMap { capability -> capability.extensions.map { it.lowercase() to capability.type } }
.toMap()
fun capabilityFor(type: FileType): FileTypeCapability? {
return capabilitiesByType[type]
}
fun displayNameFor(type: FileType): String {
return capabilityFor(type)?.displayName ?: type.name
}
fun fileTypeForName(fileName: String): FileType {
val extension = fileName.substringAfterLast('.', missingDelimiterValue = "")
.substringBefore('?')
.substringBefore('#')
.lowercase()
return typesByExtension[extension] ?: FileType.UNKNOWN
}
fun surfaceFor(type: FileType, platform: ReaderPlatform): ReaderFeatureSurface? {
return capabilityFor(type)?.surfaceFor(platform)
}
fun canOpen(type: FileType, platform: ReaderPlatform): Boolean {
return surfaceFor(type, platform) != null
}
fun readableTypesFor(platform: ReaderPlatform): Set<FileType> {
return all.mapNotNullTo(mutableSetOf()) { capability ->
capability.type.takeIf { capability.surfaceFor(platform) != null }
}
}
fun syncableTypesFor(platform: ReaderPlatform): Set<FileType> {
return all.mapNotNullTo(mutableSetOf()) { capability ->
capability.type.takeIf { capability.syncEligible && capability.surfaceFor(platform) != null }
}
}
fun supportedFormatsLabel(platform: ReaderPlatform): String {
return all
.filter { it.surfaceFor(platform) != null }
.joinToString(", ") { it.displayName }
}
fun desktopParityGaps(): List<FileType> {
return all
.filter { it.isReadableOnAndroid && !it.isReadableOnDesktop }
.map { it.type }
}
}