Improve pages loading #256

README.md

@@ -26,7 +26,7 @@ Download APK directly from GitHub:
 * Notifications about new chapters with updates feed
 * Shikimori integration (manga tracking)
 * Password/fingerprint protect access to the app
-* History and favourites synchronization across devices (coming soon)
+* History and favourites [synchronization](https://github.com/KotatsuApp/kotatsu-syncserver) across devices
 
 ### Screenshots
 

app/src/main/AndroidManifest.xml

@@ -28,6 +28,7 @@
 		android:fullBackupOnly="true"
 		android:icon="@mipmap/ic_launcher"
 		android:label="@string/app_name"
+		android:largeHeap="true"
 		android:networkSecurityConfig="@xml/network_security_config"
 		android:roundIcon="@mipmap/ic_launcher_round"
 		android:supportsRtl="true"

app/src/main/java/org/koitharu/kotatsu/core/zip/ZipOutput.kt

@@ -115,4 +115,4 @@ class ZipOutput(
 		closeEntry()
 		return true
 	}
-}
+}

app/src/main/java/org/koitharu/kotatsu/download/domain/DownloadManager.kt

@@ -17,7 +17,6 @@ import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
 import kotlinx.coroutines.withContext
@@ -36,6 +35,7 @@ import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.util.await
+import org.koitharu.kotatsu.utils.ext.copyToSuspending
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
 import org.koitharu.kotatsu.utils.ext.referer
@@ -219,10 +219,8 @@ class DownloadManager @AssistedInject constructor(
 		val call = okHttp.newCall(request)
 		val file = File(destination, tempFileName)
 		val response = call.clone().await()
-		runInterruptible(Dispatchers.IO) {
+		file.outputStream().use { out ->
-			file.outputStream().use { out ->
+			checkNotNull(response.body).byteStream().copyToSuspending(out)
-				checkNotNull(response.body).byteStream().copyTo(out)
-			}
 		}
 		return file
 	}

app/src/main/java/org/koitharu/kotatsu/local/data/PagesCache.kt

@@ -3,15 +3,21 @@ package org.koitharu.kotatsu.local.data
 import android.content.Context
 import com.tomclaw.cache.DiskLruCache
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.withContext
+import org.koitharu.kotatsu.utils.FileSize
+import org.koitharu.kotatsu.utils.ext.copyToSuspending
+import org.koitharu.kotatsu.utils.ext.longHashCode
+import org.koitharu.kotatsu.utils.ext.subdir
+import org.koitharu.kotatsu.utils.ext.takeIfReadable
 import java.io.File
 import java.io.InputStream
 import javax.inject.Inject
 import javax.inject.Singleton
-import kotlinx.coroutines.flow.MutableStateFlow
-import org.koitharu.kotatsu.utils.FileSize
-import org.koitharu.kotatsu.utils.ext.longHashCode
-import org.koitharu.kotatsu.utils.ext.subdir
-import org.koitharu.kotatsu.utils.ext.takeIfReadable
 
 @Singleton
 class PagesCache @Inject constructor(@ApplicationContext context: Context) {
@@ -26,37 +32,44 @@ class PagesCache @Inject constructor(@ApplicationContext context: Context) {
 		return lruCache.get(url)?.takeIfReadable()
 	}
 
-	fun put(url: String, inputStream: InputStream): File {
+	suspend fun put(url: String, inputStream: InputStream): File = withContext(Dispatchers.IO) {
 		val file = File(cacheDir, url.longHashCode().toString())
-		file.outputStream().use { out ->
+		try {
-			inputStream.copyTo(out)
+			file.outputStream().use { out ->
+				inputStream.copyToSuspending(out)
+			}
+			lruCache.put(url, file)
+		} finally {
+			file.delete()
 		}
-		val res = lruCache.put(url, file)
-		file.delete()
-		return res
 	}
 
-	fun put(
+	suspend fun put(
 		url: String,
 		inputStream: InputStream,
 		contentLength: Long,
 		progress: MutableStateFlow<Float>,
-	): File {
+	): File = withContext(Dispatchers.IO) {
+		val job = currentCoroutineContext()[Job]
 		val file = File(cacheDir, url.longHashCode().toString())
-		file.outputStream().use { out ->
+		try {
-			var bytesCopied: Long = 0
+			file.outputStream().use { out ->
-			val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+				var bytesCopied: Long = 0
-			var bytes = inputStream.read(buffer)
+				val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
-			while (bytes >= 0) {
+				var bytes = inputStream.read(buffer)
-				out.write(buffer, 0, bytes)
+				while (bytes >= 0) {
-				bytesCopied += bytes
+					out.write(buffer, 0, bytes)
-				publishProgress(contentLength, bytesCopied, progress)
+					bytesCopied += bytes
-				bytes = inputStream.read(buffer)
+					job?.ensureActive()
+					publishProgress(contentLength, bytesCopied, progress)
+					bytes = inputStream.read(buffer)
+					job?.ensureActive()
+				}
 			}
+			lruCache.put(url, file)
+		} finally {
+			file.delete()
 		}
-		val res = lruCache.put(url, file)
-		file.delete()
-		return res
 	}
 
 	private fun publishProgress(contentLength: Long, bytesCopied: Long, progress: MutableStateFlow<Float>) {

app/src/main/java/org/koitharu/kotatsu/local/domain/importer/DirMangaImporter.kt

@@ -4,7 +4,6 @@ import android.content.Context
 import android.net.Uri
 import android.webkit.MimeTypeMap
 import androidx.documentfile.provider.DocumentFile
-import java.io.File
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.local.data.LocalStorageManager
@@ -14,8 +13,10 @@ import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.RATING_UNKNOWN
+import org.koitharu.kotatsu.utils.ext.copyToSuspending
 import org.koitharu.kotatsu.utils.ext.deleteAwait
 import org.koitharu.kotatsu.utils.ext.longOf
+import java.io.File
 
 // TODO: Add support for chapters in cbz
 // https://github.com/KotatsuApp/Kotatsu/issues/31
@@ -62,6 +63,7 @@ class DirMangaImporter(
 				file.isDirectory -> {
 					addPages(output, file, path + "/" + file.name, state)
 				}
+
 				file.isFile -> {
 					val tempFile = file.asTempFile()
 					if (!state.hasCover) {
@@ -86,7 +88,7 @@ class DirMangaImporter(
 			"Cannot open input stream for $uri"
 		}.use { input ->
 			file.outputStream().use { output ->
-				input.copyTo(output)
+				input.copyToSuspending(output)
 			}
 		}
 		return file

app/src/main/java/org/koitharu/kotatsu/local/domain/importer/ZipMangaImporter.kt

@@ -1,8 +1,6 @@
 package org.koitharu.kotatsu.local.domain.importer
 
 import android.net.Uri
-import java.io.File
-import java.io.IOException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.withContext
@@ -11,7 +9,10 @@ import org.koitharu.kotatsu.local.data.CbzFilter
 import org.koitharu.kotatsu.local.data.LocalStorageManager
 import org.koitharu.kotatsu.local.domain.LocalMangaRepository
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.utils.ext.copyToSuspending
 import org.koitharu.kotatsu.utils.ext.resolveName
+import java.io.File
+import java.io.IOException
 
 class ZipMangaImporter(
 	storageManager: LocalStorageManager,
@@ -27,10 +28,10 @@ class ZipMangaImporter(
 			}
 			val dest = File(getOutputDir(), name)
 			runInterruptible {
-				contentResolver.openInputStream(uri)?.use { source ->
+				contentResolver.openInputStream(uri)
-					dest.outputStream().use { output ->
+			}?.use { source ->
-						source.copyTo(output)
+				dest.outputStream().use { output ->
-					}
+					source.copyToSuspending(output)
 				}
 			} ?: throw IOException("Cannot open input stream: $uri")
 			localMangaRepository.getFromFile(dest)

app/src/main/java/org/koitharu/kotatsu/reader/domain/PageLoader.kt

@@ -179,9 +179,12 @@ class PageLoader @Inject constructor(
 		val uri = Uri.parse(pageUrl)
 		return if (uri.scheme == "cbz") {
 			runInterruptible(Dispatchers.IO) {
-				val zip = ZipFile(uri.schemeSpecificPart)
+				ZipFile(uri.schemeSpecificPart)
-				val entry = zip.getEntry(uri.fragment)
+			}.use { zip ->
-				zip.getInputStream(entry).use {
+				runInterruptible(Dispatchers.IO) {
+					val entry = zip.getEntry(uri.fragment)
+					zip.getInputStream(entry)
+				}.use {
 					cache.put(pageUrl, it)
 				}
 			}
@@ -200,10 +203,8 @@ class PageLoader @Inject constructor(
 				val body = checkNotNull(response.body) {
 					"Null response"
 				}
-				runInterruptible(Dispatchers.IO) {
+				body.byteStream().use {
-					body.byteStream().use {
+					cache.put(pageUrl, it, body.contentLength(), progress)
-						cache.put(pageUrl, it, body.contentLength(), progress)
-					}
 				}
 			}
 		}

app/src/main/java/org/koitharu/kotatsu/reader/ui/PageSaveHelper.kt

@@ -6,10 +6,6 @@ import android.webkit.MimeTypeMap
 import androidx.activity.result.ActivityResultLauncher
 import androidx.core.net.toUri
 import dagger.hilt.android.qualifiers.ApplicationContext
-import java.io.File
-import javax.inject.Inject
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.resume
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.suspendCancellableCoroutine
@@ -20,6 +16,11 @@ import org.koitharu.kotatsu.base.domain.MangaDataRepository
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.util.toFileNameSafe
 import org.koitharu.kotatsu.reader.domain.PageLoader
+import org.koitharu.kotatsu.utils.ext.copyToSuspending
+import java.io.File
+import javax.inject.Inject
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
 
 private const val MAX_FILENAME_LENGTH = 10
 private const val EXTENSION_FALLBACK = "png"
@@ -48,12 +49,12 @@ class PageSaveHelper @Inject constructor(
 			}
 		}
 		runInterruptible(Dispatchers.IO) {
-			contentResolver.openOutputStream(destination)?.use { output ->
+			contentResolver.openOutputStream(destination)
-				pageFile.inputStream().use { input ->
+		}?.use { output ->
-					input.copyTo(output)
+			pageFile.inputStream().use { input ->
-				}
+				input.copyToSuspending(output)
-			} ?: throw IOException("Output stream is null")
+			}
-		}
+		} ?: throw IOException("Output stream is null")
 		return destination
 	}
 

app/src/main/java/org/koitharu/kotatsu/reader/ui/pager/PageHolderDelegate.kt

@@ -9,6 +9,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.launchIn
@@ -118,18 +119,20 @@ class PageHolderDelegate(
 		}
 	}
 
-	private suspend fun CoroutineScope.doLoad(data: MangaPage, force: Boolean) {
+	private suspend fun doLoad(data: MangaPage, force: Boolean) {
 		state = State.LOADING
 		error = null
 		callback.onLoadingStarted()
 		try {
 			val task = loader.loadPageAsync(data, force)
-			val progressObserver = observeProgress(this, task.progressAsFlow())
+			file = coroutineScope {
-			val file = task.await()
+				val progressObserver = observeProgress(this, task.progressAsFlow())
-			progressObserver.cancel()
+				val file = task.await()
-			this@PageHolderDelegate.file = file
+				progressObserver.cancel()
+				file
+			}
 			state = State.LOADED
-			callback.onImageReady(file.toUri())
+			callback.onImageReady(checkNotNull(file).toUri())
 		} catch (e: CancellationException) {
 			throw e
 		} catch (e: Throwable) {

app/src/main/java/org/koitharu/kotatsu/utils/ext/IO.kt

@@ -0,0 +1,27 @@
+package org.koitharu.kotatsu.utils.ext
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.withContext
+import java.io.InputStream
+import java.io.OutputStream
+
+suspend fun InputStream.copyToSuspending(
+	out: OutputStream,
+	bufferSize: Int = DEFAULT_BUFFER_SIZE
+): Long = withContext(Dispatchers.IO) {
+	val job = currentCoroutineContext()[Job]
+	var bytesCopied: Long = 0
+	val buffer = ByteArray(bufferSize)
+	var bytes = read(buffer)
+	while (bytes >= 0) {
+		out.write(buffer, 0, bytes)
+		bytesCopied += bytes
+		job?.ensureActive()
+		bytes = read(buffer)
+		job?.ensureActive()
+	}
+	bytesCopied
+}