From 74cb92278ff5c9c1dd049036d277eae4aa44be97 Mon Sep 17 00:00:00 2001 From: BookOasis Reader Date: Sat, 26 Sep 2026 20:23:45 +0900 Subject: [PATCH] Fix EPUB/TXT pagination and reading position restore --- .../tachiyomi/ui/reader/ReaderViewModel.kt | 21 +++++- .../ui/reader/loader/ChapterLoader.kt | 23 ++++-- .../ui/reader/loader/EpubPageLoader.kt | 13 ++-- .../ui/reader/loader/TextPageLoader.kt | 9 ++- .../ui/reader/loader/TextPageRenderer.kt | 72 ++++++++++++++----- .../ui/reader/loader/TextReaderPage.kt | 16 ++++- .../reader/setting/ReaderSettingsViewModel.kt | 8 +-- 7 files changed, 124 insertions(+), 38 deletions(-) diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderViewModel.kt index 66255157a..ab8a9f726 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderViewModel.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderViewModel.kt @@ -40,6 +40,7 @@ import eu.kanade.tachiyomi.source.model.Page import eu.kanade.tachiyomi.source.online.HttpSource import eu.kanade.tachiyomi.ui.reader.loader.ChapterLoader import eu.kanade.tachiyomi.ui.reader.loader.DownloadPageLoader +import eu.kanade.tachiyomi.ui.reader.loader.TextReaderAnchor import eu.kanade.tachiyomi.ui.reader.loader.TextReaderPage import eu.kanade.tachiyomi.ui.reader.model.InsertPage import eu.kanade.tachiyomi.ui.reader.model.ReaderChapter @@ -851,15 +852,29 @@ class ReaderViewModel( val oldPageCount = chapter.pages?.size?.coerceAtLeast(1) ?: 1 val requestedPage = chapter.requestedPage.coerceIn(0, oldPageCount - 1) - // Anchor at the middle of the visible page so position remains stable - // when font size/spacing changes the total page count. + val currentTextPage = chapter.pages?.getOrNull(requestedPage) as? TextReaderPage + val readingAnchor = currentTextPage?.anchor?.let { anchor -> + val midpoint = anchor.startOffset + + ((anchor.endOffsetExclusive - anchor.startOffset).coerceAtLeast(1L) / 2L) + TextReaderAnchor( + documentIndex = anchor.documentIndex, + startOffset = midpoint, + endOffsetExclusive = midpoint + 1L, + ) + } + // Keep the page-ratio fallback for non-text/malformed cases, but prefer + // the source-text anchor so font/spacing changes return to the same text. val readingProgress = ((requestedPage + 0.5f) / oldPageCount) .coerceIn(0f, 0.999999f) textRepaginationJob?.cancel() textRepaginationJob = viewModelScope.launchIO { try { - val oldLoader = chapterLoader.reloadTextChapter(chapter, readingProgress) ?: return@launchIO + val oldLoader = chapterLoader.reloadTextChapter( + chapter = chapter, + readingAnchor = readingAnchor, + readingProgress = readingProgress, + ) ?: return@launchIO // Resource cleanup must survive cancellation by the next slider value. viewModelScope.launchNonCancellable { diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/ChapterLoader.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/ChapterLoader.kt index a30f2863c..5c62f329c 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/ChapterLoader.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/ChapterLoader.kt @@ -76,7 +76,11 @@ class ChapterLoader( } - suspend fun reloadTextChapter(chapter: ReaderChapter, readingProgress: Float): PageLoader? { + internal suspend fun reloadTextChapter( + chapter: ReaderChapter, + readingAnchor: TextReaderAnchor?, + readingProgress: Float, + ): PageLoader? { return withIOContext { val newLoader = getPageLoader(chapter) if (!newLoader.usesTextReaderStyle) { @@ -97,9 +101,20 @@ class ChapterLoader( val oldLoader = chapter.pageLoader chapter.pageLoader = newLoader - chapter.requestedPage = (readingProgress.coerceIn(0f, 0.999999f) * pages.size) - .toInt() - .coerceIn(0, pages.lastIndex) + val anchoredPageIndex = readingAnchor?.let { anchor -> + val textPages = pages.filterIsInstance() + textPages.firstOrNull { it.anchor.contains(anchor) }?.index + ?: textPages + .filter { it.anchor.documentIndex == anchor.documentIndex } + .minByOrNull { page -> + kotlin.math.abs(page.anchor.startOffset - anchor.startOffset) + } + ?.index + } + chapter.requestedPage = anchoredPageIndex + ?: (readingProgress.coerceIn(0f, 0.999999f) * pages.size) + .toInt() + .coerceIn(0, pages.lastIndex) chapter.state = ReaderChapter.State.Loaded(pages) oldLoader } catch (e: Throwable) { diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/EpubPageLoader.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/EpubPageLoader.kt index 1b6f820a4..ec5ff5ae1 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/EpubPageLoader.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/EpubPageLoader.kt @@ -68,21 +68,26 @@ internal class EpubPageLoader( .map { it.attr("idref") } val result = mutableListOf() - spine.forEach { id -> + spine.forEachIndexed { documentIndex, id -> val href = manifest[id]?.attr("href").orEmpty() - if (href.isBlank()) return@forEach + if (href.isBlank()) return@forEachIndexed openEntry(packageHref, href)?.use { input -> val text = extractText(input) if (text.isBlank()) return@use StringReader(text).use { textReader -> - TextPageRenderer.paginate(textReader, style) { pageText -> - val ref = store.append(pageText) + TextPageRenderer.paginate(textReader, style) { page -> + val ref = store.append(page.text) result += TextReaderPage( index = result.size, pageTextProvider = { store.read(ref) }, initialStyle = style, + anchor = TextReaderAnchor( + documentIndex = documentIndex, + startOffset = page.startOffset, + endOffsetExclusive = page.endOffsetExclusive, + ), ) } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageLoader.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageLoader.kt index b12a23d48..3634f9769 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageLoader.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageLoader.kt @@ -29,12 +29,17 @@ internal class TextPageLoader( return try { val pages = mutableListOf() openDecodedReader().use { reader -> - TextPageRenderer.paginate(reader, style) { pageText -> - val ref = store.append(pageText) + TextPageRenderer.paginate(reader, style) { page -> + val ref = store.append(page.text) pages += TextReaderPage( index = pages.size, pageTextProvider = { store.read(ref) }, initialStyle = style, + anchor = TextReaderAnchor( + documentIndex = 0, + startOffset = page.startOffset, + endOffsetExclusive = page.endOffsetExclusive, + ), ) } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageRenderer.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageRenderer.kt index d94fe01a9..00759fe45 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageRenderer.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextPageRenderer.kt @@ -18,21 +18,31 @@ import java.io.InputStream import java.io.Reader import kotlin.math.roundToInt +internal data class PaginatedTextPage( + val text: String, + val startOffset: Long, + val endOffsetExclusive: Long, +) + internal object TextPageRenderer { private const val MARGIN_DP = 32f private const val STREAM_BUFFER_CHARS = 64 * 1024 private const val STREAM_READ_CHARS = 8 * 1024 - fun paginate(text: String, style: TextReaderStyle): List { + fun paginate(text: String, style: TextReaderStyle): List { if (text.isBlank()) return emptyList() return calculatePageSlices(text, style) - .mapNotNull { slice -> - text.substring(slice.start, slice.endExclusive) - .trim() - .takeIf { it.isNotEmpty() } + .mapNotNull { slice -> createPage(text, slice, 0L) } + .ifEmpty { + listOf( + PaginatedTextPage( + text = text, + startOffset = 0L, + endOffsetExclusive = text.length.toLong(), + ), + ) } - .ifEmpty { listOf(text) } } /** @@ -43,11 +53,12 @@ internal object TextPageRenderer { fun paginate( reader: Reader, style: TextReaderStyle, - onPage: (String) -> Unit, + onPage: (PaginatedTextPage) -> Unit, ) { val working = StringBuilder(STREAM_BUFFER_CHARS + STREAM_READ_CHARS) val chars = CharArray(STREAM_READ_CHARS) var firstChunk = true + var workingStartOffset = 0L while (true) { val read = reader.read(chars) @@ -59,6 +70,7 @@ internal object TextPageRenderer { firstChunk = false if (chars[0] == '\uFEFF') { offset = 1 + workingStartOffset = 1L } } if (offset < read) { @@ -66,33 +78,52 @@ internal object TextPageRenderer { } if (working.length >= STREAM_BUFFER_CHARS) { - emitCompletePages(working, style, onPage) + val consumed = emitCompletePages(working, style, workingStartOffset, onPage) + workingStartOffset += consumed } } if (working.isNotEmpty()) { - paginate(working.toString(), style).forEach(onPage) + val text = working.toString() + calculatePageSlices(text, style) + .mapNotNull { slice -> createPage(text, slice, workingStartOffset) } + .forEach(onPage) } } private fun emitCompletePages( working: StringBuilder, style: TextReaderStyle, - onPage: (String) -> Unit, - ) { + baseOffset: Long, + onPage: (PaginatedTextPage) -> Unit, + ): Long { val text = working.toString() val slices = calculatePageSlices(text, style) - if (slices.size <= 1) return + if (slices.size <= 1) return 0L for (index in 0 until slices.lastIndex) { - val slice = slices[index] - text.substring(slice.start, slice.endExclusive) - .trim() - .takeIf { it.isNotEmpty() } - ?.let(onPage) + createPage(text, slices[index], baseOffset)?.let(onPage) } - working.delete(0, slices.last().start) + val consumed = slices.last().start + working.delete(0, consumed) + return consumed.toLong() + } + + private fun createPage( + text: String, + slice: PageSlice, + baseOffset: Long, + ): PaginatedTextPage? { + val pageText = text.substring(slice.start, slice.endExclusive) + .trim() + .takeIf { it.isNotEmpty() } + ?: return null + return PaginatedTextPage( + text = pageText, + startOffset = baseOffset + slice.start, + endOffsetExclusive = baseOffset + slice.endExclusive, + ) } private fun calculatePageSlices(text: String, style: TextReaderStyle): List { @@ -157,7 +188,10 @@ internal object TextPageRenderer { return StaticLayout.Builder .obtain(styledText, 0, styledText.length, paint, contentWidth) .setAlignment(Layout.Alignment.ALIGN_NORMAL) - .setIncludePad(true) + // Page slices are laid out again when rendered. Keeping font padding + // here can make the sliced layout taller than the same lines measured + // during pagination, which clips the last line at larger font sizes. + .setIncludePad(false) .setLineSpacing(0f, style.lineSpacingPercent / 100f) .build() } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextReaderPage.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextReaderPage.kt index 6884f7bfc..4a285889b 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextReaderPage.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/TextReaderPage.kt @@ -8,10 +8,23 @@ import eu.kanade.tachiyomi.ui.reader.setting.TextReaderStyle * A rendered text page whose visual style can be refreshed cheaply while layout-affecting * changes trigger a debounced chapter repagination to rebuild page boundaries. */ +internal data class TextReaderAnchor( + val documentIndex: Int, + val startOffset: Long, + val endOffsetExclusive: Long, +) { + fun contains(other: TextReaderAnchor): Boolean { + if (documentIndex != other.documentIndex) return false + val point = other.startOffset + return point in startOffset until endOffsetExclusive + } +} + internal class TextReaderPage( index: Int, private val pageTextProvider: () -> String, initialStyle: TextReaderStyle, + val anchor: TextReaderAnchor, ) : ReaderPage(index) { @Volatile @@ -26,7 +39,8 @@ internal class TextReaderPage( index: Int, pageText: String, initialStyle: TextReaderStyle, - ) : this(index, { pageText }, initialStyle) + anchor: TextReaderAnchor, + ) : this(index, { pageText }, initialStyle, anchor) fun updateStyle(newStyle: TextReaderStyle) { style = newStyle diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderSettingsViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderSettingsViewModel.kt index c705138dd..d2d879cf6 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderSettingsViewModel.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReaderSettingsViewModel.kt @@ -36,16 +36,15 @@ class ReaderSettingsViewModel( private var textSettingsDirty = false /** - * Layout-affecting text settings are previewed quickly, then the chapter is - * repaginated after a short debounce. This keeps the slider responsive while - * ensuring the number of characters/lines on a page follows the new style. + * Layout-affecting text settings are applied only after the chapter has been + * repaginated. Applying a new style to pages that still use old boundaries + * can push text below the rendered page and clip the last lines. */ fun requestTextSettingsReload() { textSettingsDirty = true textSettingsReloadJob?.cancel() textSettingsReloadJob = viewModelScope.launch { delay(250) - onTextSettingsPreview() textSettingsDirty = false onTextSettingsCommit() textSettingsReloadJob = null @@ -77,7 +76,6 @@ class ReaderSettingsViewModel( } textSettingsReloadJob?.cancel() textSettingsReloadJob = null - onTextSettingsPreview() textSettingsDirty = false onTextSettingsCommit() }