Compare commits

..

6 Commits

Author SHA1 Message Date
BookOasis Reader 74cb92278f Fix EPUB/TXT pagination and reading position restore
Build & Test / Build & Test App (push) Has been cancelled
Release / Extract tag name (push) Has been cancelled
Update website / update_website (release) Has been cancelled
Release / Build (push) Has been cancelled
Release / Build (FOSS) (push) Has been cancelled
Release / Create GitHub Release (push) Has been cancelled
2026-09-26 20:23:45 +09:00
BookOasis Reader 5de6a8f110 Reconcile release artifact history
Build & Test / Build & Test App (push) Has been cancelled
Release / Extract tag name (push) Has been cancelled
Update website / update_website (release) Has been cancelled
Release / Build (push) Has been cancelled
Release / Build (FOSS) (push) Has been cancelled
Release / Create GitHub Release (push) Has been cancelled
2026-09-21 16:41:28 +09:00
BookOasis Reader d4789c2373 Update release APKs for 0.20.5 2026-09-21 16:41:02 +09:00
BookOasis Reader 8dc5a0fc0b Update release APKs for 0.20.5
Build & Test / Build & Test App (push) Has been cancelled
Release / Extract tag name (push) Has been cancelled
Release / Build (push) Has been cancelled
Release / Build (FOSS) (push) Has been cancelled
Release / Create GitHub Release (push) Has been cancelled
2026-09-21 16:38:01 +09:00
BookOasis Reader 105551f658 Bump version to 0.20.5
Release / Extract tag name (push) Has been cancelled
Release / Build (push) Has been cancelled
Release / Build (FOSS) (push) Has been cancelled
Release / Create GitHub Release (push) Has been cancelled
2026-09-21 16:29:22 +09:00
BookOasis Reader 6a57bc601f Fix reading downloaded EPUB and TXT books
Build & Test / Build & Test App (push) Has been cancelled
2026-09-21 16:23:42 +09:00
16 changed files with 285 additions and 46 deletions
+3
View File
@@ -22,3 +22,6 @@
*.woff binary
*.pyc binary
*.swp binary
# Android packages
*.apk binary
+2 -2
View File
@@ -33,8 +33,8 @@ android {
defaultConfig {
applicationId = "app.mihon"
versionCode = 30
versionName = "0.20.4"
versionCode = 31
versionName = "0.20.5"
buildConfigField("String", "COMMIT_COUNT", "\"${getLatestCommitCount()}\"")
buildConfigField("String", "COMMIT_SHA", "\"${getLatestCommitSha()}\"")
@@ -117,6 +117,37 @@ class DownloadProvider(
.firstOrNull()
}
/**
* Returns a downloaded EPUB/TXT document for a chapter if it exists.
*
* Document files are checked explicitly before the generic chapter path so
* a stale image directory with the same chapter name cannot shadow them.
*/
fun findChapterDocument(
chapterName: String,
chapterScanlator: String?,
chapterUrl: String,
mangaTitle: String,
source: Source,
): UniFile? {
val mangaDir = findMangaDir(mangaTitle, source) ?: return null
val chapterDirName = getChapterDirName(chapterName, chapterScanlator, chapterUrl)
val legacyChapterDirNames = getLegacyChapterDirNames(chapterName, chapterScanlator, chapterUrl)
return buildList {
DOCUMENT_DOWNLOAD_EXTENSIONS.forEach { extension ->
add("$chapterDirName.$extension")
}
legacyChapterDirNames.forEach { legacyName ->
DOCUMENT_DOWNLOAD_EXTENSIONS.forEach { extension ->
add("$legacyName.$extension")
}
}
}.asSequence()
.mapNotNull { mangaDir.findFile(it) }
.firstOrNull { it.isFile }
}
/**
* Returns a list of downloaded directories for the chapters that exist.
*
@@ -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 {
@@ -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<TextReaderPage>()
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) {
@@ -130,6 +145,33 @@ class ChapterLoader(
)
val bookOasisRef = dbChapter.url.toBookOasisChapterRef()
val kavitaChapterId = dbChapter.url.toKavitaChapterId()
val httpSource = source as? HttpSource
val documentFallback: (() -> PageLoader)? = when {
httpSource != null && httpSource.isBookOasisSource() && bookOasisRef != null &&
(bookOasisRef.format == "epub" || bookOasisRef.format == "txt") -> {
{
BookOasisFilePageLoader(
context,
httpSource,
bookOasisRef,
readerPreferences.textReaderStyle(context),
)
}
}
httpSource != null && httpSource.isKavitaSource() && kavitaChapterId != null -> {
{
KavitaCompatPageLoader(
context = context,
chapter = chapter,
source = httpSource,
chapterCache = chapterCache,
chapterId = kavitaChapterId,
textStyle = readerPreferences.textReaderStyle(context),
)
}
}
else -> null
}
return when {
isDownloaded -> DownloadPageLoader(
@@ -138,6 +180,7 @@ class ChapterLoader(
source,
downloadManager,
downloadProvider,
documentFallback,
)
source is LocalSource -> source.getFormat(chapter.chapter).let { format ->
when (format) {
@@ -10,12 +10,14 @@ import eu.kanade.tachiyomi.source.Source
import eu.kanade.tachiyomi.source.model.Page
import eu.kanade.tachiyomi.ui.reader.model.ReaderChapter
import eu.kanade.tachiyomi.ui.reader.model.ReaderPage
import kotlinx.coroutines.CancellationException
import mihon.core.archive.archiveReader
import mihon.core.archive.epubReader
import tachiyomi.core.common.storage.extension
import tachiyomi.domain.manga.model.Manga
import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
import uy.kohesive.injekt.injectLazy
import java.io.File
/**
* Loader used to load a chapter from the downloaded chapters.
@@ -26,6 +28,7 @@ internal class DownloadPageLoader(
private val source: Source,
private val downloadManager: DownloadManager,
private val downloadProvider: DownloadProvider,
private val documentFallback: (() -> PageLoader)? = null,
) : PageLoader() {
private val context: Context by injectLazy()
@@ -35,9 +38,35 @@ internal class DownloadPageLoader(
override var isLocal: Boolean = true
override val usesTextReaderStyle: Boolean
get() = pageLoader?.usesTextReaderStyle == true
get() = pageLoader?.usesTextReaderStyle == true || findDownloadedDocument() != null
override suspend fun getPages(): List<ReaderPage> {
check(!isRecycled)
return try {
val pages = getDownloadedPages()
if (pages.isNotEmpty() || documentFallback == null) {
pages
} else {
getFallbackPages()
}
} catch (error: Throwable) {
if (error is CancellationException || documentFallback == null) throw error
getFallbackPages()
}
}
private suspend fun getDownloadedPages(): List<ReaderPage> {
val downloadedDocument = findDownloadedDocument()
if (downloadedDocument != null) {
val readableDocument = prepareDownloadedDocument(downloadedDocument)
return when (readableDocument.extension?.lowercase()) {
"epub" -> getPagesFromEpub(readableDocument)
"txt" -> getPagesFromText(readableDocument)
else -> error("Unsupported downloaded document: ${downloadedDocument.name}")
}
}
val dbChapter = chapter.chapter
val chapterPath = downloadProvider.findChapterDir(
dbChapter.name,
@@ -46,17 +75,79 @@ internal class DownloadPageLoader(
manga.title,
source,
)
return if (chapterPath?.isFile == true) {
when (chapterPath.extension?.lowercase()) {
"epub" -> getPagesFromEpub(chapterPath)
"txt" -> getPagesFromText(chapterPath)
else -> getPagesFromArchive(chapterPath)
}
getPagesFromArchive(chapterPath)
} else {
getPagesFromDirectory()
}
}
private fun findDownloadedDocument(): UniFile? {
val dbChapter = chapter.chapter
return downloadProvider.findChapterDocument(
dbChapter.name,
dbChapter.scanlator,
dbChapter.url,
manga.title,
source,
)
}
/**
* Mirror SAF-backed documents into the app cache before opening them.
* EPUB uses mmap internally, which is not guaranteed to work with every
* document provider even though regular stream reads/writes succeed.
*/
private fun prepareDownloadedDocument(file: UniFile): UniFile {
val extension = file.extension?.lowercase()
?: error("Downloaded document has no extension: ${file.name}")
val sourceLength = file.length()
if (sourceLength <= 0L) {
error("Downloaded document is empty: ${file.name}")
}
val cacheDir = File(context.cacheDir, "downloaded_reader").apply { mkdirs() }
val prefix = "${source.id}-${chapter.chapter.id}-"
val target = File(
cacheDir,
"$prefix$sourceLength-${file.lastModified()}.$extension",
)
if (!target.isFile || target.length() != sourceLength) {
cacheDir.listFiles()
?.filter { it.name.startsWith(prefix) }
?.forEach { it.delete() }
val temp = File(cacheDir, "${target.name}.part")
if (temp.exists()) temp.delete()
file.openInputStream().use { input ->
temp.outputStream().use { output -> input.copyTo(output) }
}
if (temp.length() != sourceLength) {
temp.delete()
error("Downloaded document cache copy is incomplete: ${file.name}")
}
if (!temp.renameTo(target)) {
temp.copyTo(target, overwrite = true)
temp.delete()
}
}
return UniFile.fromFile(target)
?: error("Unable to open cached downloaded document: ${target.absolutePath}")
}
private suspend fun getFallbackPages(): List<ReaderPage> {
pageLoader?.recycle()
val fallback = documentFallback?.invoke()
?: error("Downloaded document fallback is unavailable")
pageLoader = fallback
val pages = fallback.getPages()
isLocal = fallback.isLocal
return pages
}
override fun recycle() {
super.recycle()
pageLoader?.recycle()
@@ -68,21 +68,26 @@ internal class EpubPageLoader(
.map { it.attr("idref") }
val result = mutableListOf<ReaderPage>()
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,
),
)
}
}
@@ -29,12 +29,17 @@ internal class TextPageLoader(
return try {
val pages = mutableListOf<ReaderPage>()
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,
),
)
}
}
@@ -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<String> {
fun paginate(text: String, style: TextReaderStyle): List<PaginatedTextPage> {
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<PageSlice> {
@@ -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()
}
@@ -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
@@ -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()
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.