diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt index 1e32c3729..a990d548e 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt @@ -95,7 +95,7 @@ class DownloadCache( .stateIn(scope, SharingStarted.WhileSubscribed(), false) private val diskCacheFile: File - get() = File(context.cacheDir, "dl_index_cache_v3") + get() = File(context.cacheDir, "dl_index_cache_v4") private val rootDownloadsDirMutex = Mutex() private var rootDownloadsDir = RootDirectory(storageManager.getDownloadsDirectory()) diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadManager.kt b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadManager.kt index a445ace9a..8b675dfd4 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadManager.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadManager.kt @@ -214,7 +214,8 @@ class DownloadManager( mangaTitle: String, source: Source, ): Boolean { - return provider.findChapterDir(chapterName, chapterScanlator, chapterUrl, mangaTitle, source) != null + return provider.findChapterDir(chapterName, chapterScanlator, chapterUrl, mangaTitle, source) != null || + provider.findChapterDocument(chapterName, chapterScanlator, chapterUrl, mangaTitle, source) != null } /** @@ -253,8 +254,8 @@ class DownloadManager( removeFromDownloadQueue(filteredChapters) - val (mangaDir, chapterDirs) = provider.findChapterDirs(filteredChapters, manga, source) - chapterDirs.forEach { it.delete() } + val (mangaDir, chapterDownloads) = provider.findChapterDirs(filteredChapters, manga, source) + chapterDownloads.forEach { it.delete() } cache.removeChapters(filteredChapters, manga) // Delete manga directory if empty diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadProvider.kt b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadProvider.kt index fa65d7039..63f270725 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadProvider.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadProvider.kt @@ -149,11 +149,8 @@ class DownloadProvider( } /** - * Returns a list of downloaded directories for the chapters that exist. - * - * @param chapters the chapters to query. - * @param manga the manga of the chapter. - * @param source the source of the chapter. + * Returns downloaded chapter entries that exist, including image directories, + * CBZ files and standalone EPUB/TXT document files. */ fun findChapterDirs(chapters: List, manga: Manga, source: Source): Pair> { val mangaDir = findMangaDir(manga.title, source) ?: return null to emptyList() @@ -161,6 +158,13 @@ class DownloadProvider( getValidChapterDirNames(chapter.name, chapter.scanlator, chapter.url).asSequence() .mapNotNull { mangaDir.findFile(it) } .firstOrNull() + ?: findChapterDocument( + chapter.name, + chapter.scanlator, + chapter.url, + manga.title, + source, + ) } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt index 997e77dd2..3f7c3fa71 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt @@ -751,11 +751,16 @@ class ReaderActivity : BaseActivity() { val textPages = chapter.pages?.filterIsInstance().orEmpty() if (textPages.isEmpty()) return - val targetPage = if (ttsState.sourceHighlightStart >= 0L) { + val targetSourceOffset = when { + ttsState.sourceHighlightStart >= 0L -> ttsState.sourceHighlightStart + ttsState.sourceSentenceStart >= 0L -> ttsState.sourceSentenceStart + else -> -1L + } + val targetPage = if (targetSourceOffset >= 0L) { textPages.firstOrNull { page -> page.anchor.documentIndex == ttsState.documentIndex && - ttsState.sourceHighlightStart >= page.anchor.startOffset && - ttsState.sourceHighlightStart < page.anchor.endOffsetExclusive + targetSourceOffset >= page.anchor.startOffset && + targetSourceOffset < page.anchor.endOffsetExclusive } } else { chapter.pages?.getOrNull(ttsState.readerPageIndex) as? TextReaderPage @@ -765,15 +770,29 @@ class ReaderActivity : BaseActivity() { ttsHighlightedPage?.clearTtsHighlight() } + val sentenceStart = maxOf(ttsState.sourceSentenceStart, targetPage.anchor.startOffset) + val sentenceEnd = minOf(ttsState.sourceSentenceEndExclusive, targetPage.anchor.endOffsetExclusive) + val activeStart = maxOf(ttsState.sourceHighlightStart, targetPage.anchor.startOffset) + val activeEnd = minOf(ttsState.sourceHighlightEndExclusive, targetPage.anchor.endOffsetExclusive) + if ( - ttsState.sourceHighlightStart >= 0L && - ttsState.sourceHighlightEndExclusive > ttsState.sourceHighlightStart + ttsState.sourceSentenceStart >= 0L && + ttsState.sourceSentenceEndExclusive > ttsState.sourceSentenceStart && + sentenceEnd > sentenceStart ) { - val start = maxOf(ttsState.sourceHighlightStart, targetPage.anchor.startOffset) - val end = minOf(ttsState.sourceHighlightEndExclusive, targetPage.anchor.endOffsetExclusive) targetPage.updateTtsHighlight( - start = (start - targetPage.anchor.startOffset).toInt(), - endExclusive = (end - targetPage.anchor.startOffset).toInt(), + sentenceStart = (sentenceStart - targetPage.anchor.startOffset).toInt(), + sentenceEndExclusive = (sentenceEnd - targetPage.anchor.startOffset).toInt(), + activeStart = if (activeEnd > activeStart) { + (activeStart - targetPage.anchor.startOffset).toInt() + } else { + -1 + }, + activeEndExclusive = if (activeEnd > activeStart) { + (activeEnd - targetPage.anchor.startOffset).toInt() + } else { + -1 + }, ) } else { targetPage.clearTtsHighlight() 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 477755ee7..bb94c66c5 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 @@ -158,7 +158,8 @@ internal object TextPageRenderer { fun render( text: String, style: TextReaderStyle, - highlightRange: IntRange? = null, + sentenceHighlightRange: IntRange? = null, + activeHighlightRange: IntRange? = null, ): InputStream { val metrics = resolveLayoutMetrics(style) val bitmap = Bitmap.createBitmap(metrics.pageWidth, metrics.pageHeight, Bitmap.Config.ARGB_8888) @@ -167,7 +168,13 @@ internal object TextPageRenderer { canvas.drawColor(backgroundColor) canvas.save() canvas.translate(metrics.horizontalMargin.toFloat(), metrics.verticalMargin.toFloat()) - createLayout(text, style, metrics.contentWidth, highlightRange).draw(canvas) + createLayout( + text = text, + style = style, + contentWidth = metrics.contentWidth, + sentenceHighlightRange = sentenceHighlightRange, + activeHighlightRange = activeHighlightRange, + ).draw(canvas) canvas.restore() val output = ByteArrayOutputStream() @@ -180,7 +187,8 @@ internal object TextPageRenderer { text: String, style: TextReaderStyle, contentWidth: Int, - highlightRange: IntRange? = null, + sentenceHighlightRange: IntRange? = null, + activeHighlightRange: IntRange? = null, ): StaticLayout { val (_, textColor) = resolveColors(style) val paint = TextPaint().apply { @@ -191,7 +199,12 @@ internal object TextPageRenderer { ?.let { Typeface.create(it, Typeface.NORMAL) } ?: Typeface.DEFAULT } - val styledText = addTextSpans(text, style, highlightRange) + val styledText = addTextSpans( + text = text, + style = style, + sentenceHighlightRange = sentenceHighlightRange, + activeHighlightRange = activeHighlightRange, + ) return StaticLayout.Builder .obtain(styledText, 0, styledText.length, paint, contentWidth) .setAlignment(Layout.Alignment.ALIGN_NORMAL) @@ -239,11 +252,13 @@ internal object TextPageRenderer { private fun addTextSpans( text: String, style: TextReaderStyle, - highlightRange: IntRange?, + sentenceHighlightRange: IntRange?, + activeHighlightRange: IntRange?, ): CharSequence { val needsParagraphSpacing = style.paragraphSpacingPx > 0 && '\n' in text - val needsHighlight = highlightRange != null && !highlightRange.isEmpty() - if (!needsParagraphSpacing && !needsHighlight) return text + val needsSentenceHighlight = sentenceHighlightRange != null && !sentenceHighlightRange.isEmpty() + val needsActiveHighlight = activeHighlightRange != null && !activeHighlightRange.isEmpty() + if (!needsParagraphSpacing && !needsSentenceHighlight && !needsActiveHighlight) return text val spannable = SpannableString(text) if (needsParagraphSpacing) { @@ -258,26 +273,45 @@ internal object TextPageRenderer { } } } - if (needsHighlight) { - val start = highlightRange!!.first.coerceIn(0, text.length) - val endExclusive = (highlightRange.last + 1).coerceIn(start, text.length) - if (start < endExclusive) { - val highlightColor = if (resolveColors(style).first == Color.BLACK) { - Color.rgb(92, 82, 24) - } else { - Color.rgb(255, 245, 157) - } - spannable.setSpan( - BackgroundColorSpan(highlightColor), - start, - endExclusive, - Spannable.SPAN_EXCLUSIVE_EXCLUSIVE, - ) - } + + val darkBackground = resolveColors(style).first == Color.BLACK + sentenceHighlightRange?.let { range -> + applyHighlightSpan( + spannable = spannable, + textLength = text.length, + range = range, + color = if (darkBackground) Color.rgb(72, 68, 40) else Color.rgb(255, 249, 196), + ) + } + activeHighlightRange?.let { range -> + applyHighlightSpan( + spannable = spannable, + textLength = text.length, + range = range, + color = if (darkBackground) Color.rgb(150, 117, 0) else Color.rgb(255, 193, 7), + ) } return spannable } + private fun applyHighlightSpan( + spannable: SpannableString, + textLength: Int, + range: IntRange, + color: Int, + ) { + if (range.isEmpty()) return + val start = range.first.coerceIn(0, textLength) + val endExclusive = (range.last + 1).coerceIn(start, textLength) + if (start >= endExclusive) return + spannable.setSpan( + BackgroundColorSpan(color), + start, + endExclusive, + Spannable.SPAN_EXCLUSIVE_EXCLUSIVE, + ) + } + private class ParagraphSpacingSpan(private val spacing: Int) : LineHeightSpan { override fun chooseHeight( text: CharSequence?, 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 0f6ea1404..53c8fe092 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 @@ -31,10 +31,20 @@ internal class TextReaderPage( private var style: TextReaderStyle = initialStyle @Volatile - private var highlightRange: IntRange? = null + private var sentenceHighlightRange: IntRange? = null + + @Volatile + private var activeHighlightRange: IntRange? = null init { - stream = { TextPageRenderer.render(pageTextProvider(), style, highlightRange) } + stream = { + TextPageRenderer.render( + text = pageTextProvider(), + style = style, + sentenceHighlightRange = sentenceHighlightRange, + activeHighlightRange = activeHighlightRange, + ) + } status = Page.State.Ready } @@ -51,11 +61,26 @@ internal class TextReaderPage( fun readText(): String = pageTextProvider() - fun updateTtsHighlight(start: Int, endExclusive: Int) { - highlightRange = if (start >= 0 && endExclusive > start) start until endExclusive else null + fun updateTtsHighlight( + sentenceStart: Int, + sentenceEndExclusive: Int, + activeStart: Int, + activeEndExclusive: Int, + ) { + sentenceHighlightRange = if (sentenceStart >= 0 && sentenceEndExclusive > sentenceStart) { + sentenceStart until sentenceEndExclusive + } else { + null + } + activeHighlightRange = if (activeStart >= 0 && activeEndExclusive > activeStart) { + activeStart until activeEndExclusive + } else { + null + } } fun clearTtsHighlight() { - highlightRange = null + sentenceHighlightRange = null + activeHighlightRange = null } } diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsController.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsController.kt index e7e3b691e..7ffbc16cb 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsController.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsController.kt @@ -14,6 +14,8 @@ object ReaderTtsController { val readerChapterId: Long = -1L, val readerPageIndex: Int = -1, val documentIndex: Int = -1, + val sourceSentenceStart: Long = -1L, + val sourceSentenceEndExclusive: Long = -1L, val sourceHighlightStart: Long = -1L, val sourceHighlightEndExclusive: Long = -1L, ) diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsService.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsService.kt index b32dbc1cb..e113ec422 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsService.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/ui/reader/tts/ReaderTtsService.kt @@ -25,8 +25,10 @@ class ReaderTtsService : Service() { private var sessionId: String? = null private var session: ReaderTtsSessionStore.SessionReader? = null private var pagePosition = 0 - private var currentPageText: String? = null + private var pageSpeechStartOffset = 0 + private var currentWindow: SpeechWindow? = null private var currentSegments: List = emptyList() + private var lookaheadConsumedChars: Map = emptyMap() private var segmentPosition = 0 private var segmentSpeechOffset = 0 private var currentUtteranceBaseOffset = 0 @@ -86,8 +88,10 @@ class ReaderTtsService : Service() { pagePosition = newSession.pages.indexOfFirst { it.readerPageIndex >= requestedPageIndex } .takeIf { it >= 0 } ?: 0 - currentPageText = null + pageSpeechStartOffset = 0 + currentWindow = null currentSegments = emptyList() + lookaheadConsumedChars = emptyMap() segmentPosition = 0 segmentSpeechOffset = 0 currentUtteranceBaseOffset = 0 @@ -202,15 +206,12 @@ class ReaderTtsService : Service() { private fun speakCurrentSegment() { if (!playing || !initialized) return - val session = session ?: return stopPlayback() - if (currentPageText == null) { - currentPageText = session.readPage(pagePosition) - currentSegments = segmentText(currentPageText.orEmpty()) - segmentPosition = 0 + if (currentSegments.isEmpty()) { + if (!prepareCurrentSegments()) return } - if (currentSegments.isEmpty() || segmentPosition !in currentSegments.indices) { + if (segmentPosition !in currentSegments.indices) { advancePage() return } @@ -222,6 +223,7 @@ class ReaderTtsService : Service() { advanceSegment() return } + currentUtteranceBaseOffset = speechOffset val utteranceId = "$ttsGeneration:$pagePosition:$segmentPosition:$speechOffset" currentUtteranceId = utteranceId @@ -238,6 +240,125 @@ class ReaderTtsService : Service() { } } + private fun prepareCurrentSegments(): Boolean { + val session = session ?: run { + stopPlayback() + return false + } + val currentEntry = session.pages.getOrNull(pagePosition) ?: run { + stopPlayback() + return false + } + val currentText = session.readPage(pagePosition) + val safeStart = pageSpeechStartOffset.coerceIn(0, currentText.length) + + if (safeStart >= currentText.length) { + advancePage() + return false + } + + val window = buildSpeechWindow(session, currentEntry.documentIndex, safeStart) + val currentPart = window.parts.firstOrNull { it.pagePosition == pagePosition } ?: run { + advancePage() + return false + } + val segments = segmentText(window.text) + .filter { it.start < currentPart.windowEndExclusive } + + if (segments.isEmpty()) { + advancePage() + return false + } + + currentWindow = window + currentSegments = segments + segmentPosition = 0 + lookaheadConsumedChars = buildMap { + val last = segments.last() + window.parts + .asSequence() + .filter { it.pagePosition > pagePosition } + .forEach { part -> + val consumedEnd = min(last.endExclusive, part.windowEndExclusive) + if (consumedEnd > part.windowStart) { + put(part.pagePosition, consumedEnd - part.windowStart) + } + } + } + return true + } + + private fun buildSpeechWindow( + session: ReaderTtsSessionStore.SessionReader, + documentIndex: Int, + currentPageStart: Int, + ): SpeechWindow { + val text = StringBuilder() + val parts = mutableListOf() + var candidatePage = pagePosition + var pagesAdded = 0 + var firstPageEnd = -1 + + while ( + candidatePage < session.pages.size && + pagesAdded < MAX_LOOKAHEAD_PAGES && + text.length < MAX_SPEECH_WINDOW_CHARS + ) { + val entry = session.pages[candidatePage] + if (entry.documentIndex != documentIndex) break + + val pageText = session.readPage(candidatePage) + val pageStart = if (candidatePage == pagePosition) currentPageStart else 0 + if (pageStart >= pageText.length) { + candidatePage++ + continue + } + + if (text.isNotEmpty()) text.append(' ') + val windowStart = text.length + val available = (MAX_SPEECH_WINDOW_CHARS - text.length).coerceAtLeast(0) + if (available == 0) break + + val takeCount = min(pageText.length - pageStart, available) + text.append(pageText, pageStart, pageStart + takeCount) + val windowEnd = text.length + parts += WindowPart( + windowStart = windowStart, + windowEndExclusive = windowEnd, + pagePosition = candidatePage, + documentIndex = entry.documentIndex, + sourceStartOffset = entry.sourceStartOffset + pageStart, + ) + + if (candidatePage == pagePosition) { + firstPageEnd = windowEnd + } + + pagesAdded++ + if ( + candidatePage > pagePosition && + firstPageEnd >= 0 && + hasSentenceTerminatorAfter(text, firstPageEnd) + ) { + break + } + if (takeCount < pageText.length - pageStart) break + candidatePage++ + } + + return SpeechWindow( + text = text.toString(), + parts = parts, + ) + } + + private fun hasSentenceTerminatorAfter(text: CharSequence, start: Int): Boolean { + for (index in start.coerceAtLeast(0) until text.length) { + if (text[index] in SENTENCE_TERMINATORS) return true + } + return false + } + private fun advanceSegment() { currentUtteranceId = null segmentSpeechOffset = 0 @@ -254,7 +375,8 @@ class ReaderTtsService : Service() { } pagePosition++ - currentPageText = null + pageSpeechStartOffset = lookaheadConsumedChars[pagePosition] ?: 0 + currentWindow = null currentSegments = emptyList() segmentPosition = 0 segmentSpeechOffset = 0 @@ -268,8 +390,9 @@ class ReaderTtsService : Service() { cleanupTts() session?.close() session = null - currentPageText = null + currentWindow = null currentSegments = emptyList() + lookaheadConsumedChars = emptyMap() val oldSessionId = sessionId sessionId = null ReaderTtsSessionStore.delete(this, oldSessionId) @@ -298,6 +421,8 @@ class ReaderTtsService : Service() { readerChapterId = readerChapterId, readerPageIndex = page.readerPageIndex, documentIndex = page.documentIndex, + sourceSentenceStart = if (clearHighlight) -1L else previous.sourceSentenceStart, + sourceSentenceEndExclusive = if (clearHighlight) -1L else previous.sourceSentenceEndExclusive, sourceHighlightStart = if (clearHighlight) -1L else previous.sourceHighlightStart, sourceHighlightEndExclusive = if (clearHighlight) -1L else previous.sourceHighlightEndExclusive, ), @@ -311,22 +436,70 @@ class ReaderTtsService : Service() { relativeEndExclusive: Int = segment.text.length, ) { val session = session ?: return - val page = session.pages.getOrNull(pagePosition) ?: return + val window = currentWindow ?: return + val sentenceStart = window.mapStart(segment.start) ?: return + val sentenceEnd = window.mapEnd(segment.endExclusive) ?: return + val safeStart = relativeStart.coerceIn(0, segment.text.length) val safeEnd = relativeEndExclusive.coerceIn(safeStart, segment.text.length) + val activeStart = if (safeEnd > safeStart) { + window.mapStart(segment.start + safeStart) + } else { + null + } + val activeEnd = if (safeEnd > safeStart) { + window.mapEnd(segment.start + safeEnd) + } else { + null + } + val activePosition = activeStart ?: sentenceStart + val page = session.pages.getOrNull(activePosition.pagePosition) ?: return + ReaderTtsController.updateState( ReaderTtsController.State( active = true, playing = playing, readerChapterId = readerChapterId, readerPageIndex = page.readerPageIndex, - documentIndex = page.documentIndex, - sourceHighlightStart = page.sourceStartOffset + segment.start + safeStart, - sourceHighlightEndExclusive = page.sourceStartOffset + segment.start + safeEnd, + documentIndex = activePosition.documentIndex, + sourceSentenceStart = sentenceStart.sourceOffset, + sourceSentenceEndExclusive = sentenceEnd.sourceOffset, + sourceHighlightStart = activeStart?.sourceOffset ?: -1L, + sourceHighlightEndExclusive = activeEnd?.sourceOffset ?: -1L, ), ) } + private fun SpeechWindow.mapStart(windowOffset: Int): MappedPosition? { + if (text.isEmpty() || parts.isEmpty()) return null + val clamped = windowOffset.coerceIn(0, text.lastIndex) + val part = parts.firstOrNull { clamped in it.windowStart until it.windowEndExclusive } + ?: parts.firstOrNull { it.windowStart > clamped } + ?: parts.lastOrNull() + ?: return null + val charIndex = clamped.coerceIn(part.windowStart, part.windowEndExclusive - 1) + return MappedPosition( + pagePosition = part.pagePosition, + documentIndex = part.documentIndex, + sourceOffset = part.sourceStartOffset + (charIndex - part.windowStart), + ) + } + + private fun SpeechWindow.mapEnd(windowEndExclusive: Int): MappedPosition? { + if (text.isEmpty() || parts.isEmpty()) return null + val clamped = (windowEndExclusive - 1).coerceIn(0, text.lastIndex) + val part = parts.firstOrNull { clamped in it.windowStart until it.windowEndExclusive } + ?: parts.lastOrNull { it.windowEndExclusive <= clamped + 1 } + ?: parts.firstOrNull() + ?: return null + val charIndex = clamped.coerceIn(part.windowStart, part.windowEndExclusive - 1) + return MappedPosition( + pagePosition = part.pagePosition, + documentIndex = part.documentIndex, + sourceOffset = part.sourceStartOffset + (charIndex - part.windowStart) + 1L, + ) + } + private fun refreshNotification() { if (session == null) return startForeground(Notifications.ID_READER_TTS, buildNotification(preparing = false)) @@ -374,7 +547,11 @@ class ReaderTtsService : Service() { mainHandler.post { if (!playing || utteranceId != currentUtteranceId) return@post currentSegments.getOrNull(segmentPosition)?.let { segment -> - publishHighlight(segment, currentUtteranceBaseOffset, segment.text.length) + publishHighlight( + segment = segment, + relativeStart = currentUtteranceBaseOffset, + relativeEndExclusive = (currentUtteranceBaseOffset + 1).coerceAtMost(segment.text.length), + ) } } } @@ -489,6 +666,25 @@ class ReaderTtsService : Service() { val text: String, ) + private data class SpeechWindow( + val text: String, + val parts: List, + ) + + private data class WindowPart( + val windowStart: Int, + val windowEndExclusive: Int, + val pagePosition: Int, + val documentIndex: Int, + val sourceStartOffset: Long, + ) + + private data class MappedPosition( + val pagePosition: Int, + val documentIndex: Int, + val sourceOffset: Long, + ) + companion object { const val ACTION_START = "eu.kanade.tachiyomi.reader.tts.START" const val ACTION_TOGGLE = "eu.kanade.tachiyomi.reader.tts.TOGGLE" @@ -513,6 +709,9 @@ class ReaderTtsService : Service() { private const val MIN_SPEED = 1.2f private const val MAX_SPEED = 3.0f private const val MAX_SEGMENT_CHARS = 1200 + private const val MAX_LOOKAHEAD_PAGES = 3 + private const val MAX_SPEECH_WINDOW_CHARS = 6000 + private val SENTENCE_TERMINATORS = setOf('.', '!', '?', '。', '!', '?') private const val REQUEST_TOGGLE = 9101 private const val REQUEST_STOP = 9102