Atte149/book-reader
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Desktop app (#308)

Browse source 
* 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
Download patch file Download diff file Expand all files Collapse all files

148
shared/src/commonMain/kotlin/com/aryan/reader/shared/FileCapabilities.kt
View file

@ -31,6 +31,43 @@ data class FileTypeCapability(
}
object SharedFileCapabilities {
private val codeOrDataExtensions = setOf(
"csv",
"tsv",
"json",
"xml",
"log",
"java",
"kt",
"py",
"js",
"cpp",
"c",
"cs",
"rb",
"go"
)
private val manualOnlyReaderMimeTypes = setOf(
"text/csv",
"text/comma-separated-values",
"text/tab-separated-values",
"application/json",
"application/xml",
"text/xml",
"text/x-java-source",
"text/x-python",
"text/x-kotlin",
"text/javascript",
"application/javascript",
"text/x-c",
"text/x-c++",
"text/x-csharp",
"text/x-ruby",
"text/x-go",
"text/x-log"
)
val all: List<FileTypeCapability> = listOf(
FileTypeCapability(
type = FileType.EPUB,
@ -122,6 +159,13 @@ object SharedFileCapabilities {
extensions = setOf("fodt"),
androidSurface = ReaderFeatureSurface.EPUB_READER,
desktopSurface = ReaderFeatureSurface.TEXT_READER
),
FileTypeCapability(
type = FileType.PPTX,
displayName = "PPTX",
extensions = setOf("pptx"),
androidSurface = ReaderFeatureSurface.PDF_VIEWER,
desktopSurface = null
)
)
@ -129,6 +173,23 @@ object SharedFileCapabilities {
private val typesByExtension: Map<String, FileType> = all
.flatMap { capability -> capability.extensions.map { it.lowercase() to capability.type } }
.toMap()
private val mimeTypesByType: Map<FileType, String> = mapOf(
FileType.PDF to "application/pdf",
FileType.EPUB to "application/epub+zip",
FileType.MOBI to "application/x-mobipocket-ebook",
FileType.MD to "text/markdown",
FileType.TXT to "text/plain",
FileType.HTML to "text/html",
FileType.FB2 to "application/x-fictionbook+xml",
FileType.CBZ to "application/zip",
FileType.CBR to "application/zip",
FileType.CB7 to "application/zip",
FileType.DOCX to "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
FileType.PPTX to "application/vnd.openxmlformats-officedocument.presentationml.presentation",
FileType.ODT to "application/vnd.oasis.opendocument.text",
FileType.FODT to "application/x-vnd.oasis.opendocument.text-flat-xml"
)
val knownFileTypes: Set<FileType> = all.mapTo(mutableSetOf()) { it.type }
fun capabilityFor(type: FileType): FileTypeCapability? {
return capabilitiesByType[type]
@ -138,12 +199,63 @@ object SharedFileCapabilities {
return capabilityFor(type)?.displayName ?: type.name
}
fun primaryExtensionFor(type: FileType): String? {
return capabilityFor(type)?.extensions?.firstOrNull()
}
fun mimeTypeFor(type: FileType): String? {
return mimeTypesByType[type]
}
fun fileTypeForName(fileName: String): FileType {
val extension = fileName.substringAfterLast('.', missingDelimiterValue = "")
.substringBefore('?')
.substringBefore('#')
.lowercase()
return typesByExtension[extension] ?: FileType.UNKNOWN
return resolveFileTypeForName(fileName) ?: FileType.UNKNOWN
}
fun resolveFileTypeForName(fileName: String?): FileType? {
val normalized = fileName?.normalizedFileName()?.takeIf { it.isNotBlank() } ?: return null
val effectiveName = normalized.withTransparentTextSuffix()
return fileTypeForEffectiveName(effectiveName)
}
fun isCodeOrDataFileName(fileName: String): Boolean {
return fileName.normalizedFileName()
.withTransparentTextSuffix()
.extensionAfterLastDot() in codeOrDataExtensions
}
fun isManualOnlyReaderFileName(fileName: String?): Boolean {
return fileName?.let(::isCodeOrDataFileName) ?: false
}
fun isManualOnlyReaderMimeType(mimeType: String?): Boolean {
val normalized = mimeType?.lowercase() ?: return false
return normalized in manualOnlyReaderMimeTypes
}
fun isLocalFolderSyncEligibleFile(name: String, mimeType: String?): Boolean {
if (isManualOnlyReaderFileName(name)) return false
if (resolveFileTypeForName(name) != null) return true
return !isManualOnlyReaderMimeType(mimeType)
}
fun fileExtensionSuffixForName(fileName: String?): String? {
val normalized = fileName?.normalizedFileName()?.takeIf { it.isNotBlank() } ?: return null
val effectiveName = normalized.withTransparentTextSuffix()
val effectiveSuffix = when {
effectiveName.endsWith(".fb2.zip") -> ".fb2.zip"
effectiveName.endsWith(".markdown") -> ".markdown"
effectiveName.endsWith(".xhtml") -> ".xhtml"
effectiveName.extensionAfterLastDot() != null && resolveFileTypeForName(effectiveName) != null -> {
".${effectiveName.extensionAfterLastDot()}"
}
else -> null
} ?: return null
return if (effectiveName != normalized && normalized.endsWith(".txt")) {
"$effectiveSuffix.txt"
} else {
effectiveSuffix
}
}
fun surfaceFor(type: FileType, platform: ReaderPlatform): ReaderFeatureSurface? {
@ -177,4 +289,30 @@ object SharedFileCapabilities {
.filter { it.isReadableOnAndroid && !it.isReadableOnDesktop }
.map { it.type }
}
private fun fileTypeForEffectiveName(fileName: String): FileType? {
if (fileName.endsWith(".fb2.zip")) return FileType.FB2
val extension = fileName.extensionAfterLastDot() ?: return null
if (extension in codeOrDataExtensions) return FileType.HTML
return typesByExtension[extension]
}
private fun String.normalizedFileName(): String {
return trim()
.substringBefore('?')
.substringBefore('#')
.lowercase()
}
private fun String.withTransparentTextSuffix(): String {
if (!endsWith(".txt")) return this
val innerName = removeSuffix(".txt")
if (innerName.isBlank() || !innerName.contains('.')) return this
return if (fileTypeForEffectiveName(innerName) != null) innerName else this
}
private fun String.extensionAfterLastDot(): String? {
val dotIndex = lastIndexOf('.')
return if (dotIndex > 0 && dotIndex < lastIndex) substring(dotIndex + 1) else null
}
}