Use file walking APIs

app/src/main/kotlin/org/koitharu/kotatsu/bookmarks/domain/Bookmark.kt

@@ -1,7 +1,7 @@
 package org.koitharu.kotatsu.bookmarks.domain
 
 import org.koitharu.kotatsu.list.ui.model.ListModel
-import org.koitharu.kotatsu.local.data.ImageFileFilter
+import org.koitharu.kotatsu.local.data.hasImageExtension
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import java.util.Date
@@ -38,7 +38,6 @@ data class Bookmark(
 	)
 
 	private fun isImageUrlDirect(): Boolean {
-		val extension = imageUrl.substringAfterLast('.')
+		return hasImageExtension(imageUrl)
-		return extension.isNotEmpty() && ImageFileFilter().isExtensionValid(extension)
 	}
 }

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/File.kt

@@ -7,7 +7,6 @@ import android.os.Build
 import android.os.Environment
 import android.os.storage.StorageManager
 import android.provider.OpenableColumns
-import androidx.annotation.WorkerThread
 import androidx.core.database.getStringOrNull
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
@@ -19,6 +18,8 @@ import java.io.FileFilter
 import java.nio.file.attribute.BasicFileAttributes
 import java.util.zip.ZipEntry
 import java.util.zip.ZipFile
+import kotlin.io.path.ExperimentalPathApi
+import kotlin.io.path.walk
 import kotlin.io.path.readAttributes
 
 fun File.subdir(name: String) = File(this, name).also {
@@ -71,31 +72,7 @@ fun ContentResolver.resolveName(uri: Uri): String? {
 }
 
 suspend fun File.computeSize(): Long = runInterruptible(Dispatchers.IO) {
-	computeSizeInternal(this)
+	walkCompat().sumOf { it.length() }
-}
-
-@WorkerThread
-private fun computeSizeInternal(file: File): Long {
-	return if (file.isDirectory) {
-		file.children().sumOf { computeSizeInternal(it) }
-	} else {
-		file.length()
-	}
-}
-
-fun File.listFilesRecursive(filter: FileFilter? = null): Sequence<File> = sequence {
-	listFilesRecursiveImpl(this@listFilesRecursive, filter)
-}
-
-private suspend fun SequenceScope<File>.listFilesRecursiveImpl(root: File, filter: FileFilter?) {
-	val ss = root.children()
-	for (f in ss) {
-		if (f.isDirectory) {
-			listFilesRecursiveImpl(f, filter)
-		} else if (filter == null || filter.accept(f)) {
-			yield(f)
-		}
-	}
 }
 
 fun File.children() = FileSequence(this)
@@ -108,3 +85,12 @@ val File.creationTime
 	} else {
 		lastModified()
 	}
+
+@OptIn(ExperimentalPathApi::class)
+fun File.walkCompat() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+	// Use lazy loading on Android 8.0 and later
+	toPath().walk().map { it.toFile() }
+} else {
+	// Directories are excluded by default in Path.walk(), so do it here as well
+	walk().filter { it.isFile }
+}

app/src/main/kotlin/org/koitharu/kotatsu/local/data/CbzFilter.kt

@@ -2,30 +2,16 @@ package org.koitharu.kotatsu.local.data
 
 import android.net.Uri
 import java.io.File
-import java.io.FileFilter
-import java.io.FilenameFilter
-import java.util.Locale
 
-class CbzFilter : FileFilter, FilenameFilter {
+private fun isCbzExtension(ext: String?): Boolean {
-
+	return ext.equals("cbz", ignoreCase = true) || ext.equals("zip", ignoreCase = true)
-	override fun accept(dir: File, name: String): Boolean {
+}
-		return isFileSupported(name)
-	}
-
-	override fun accept(pathname: File?): Boolean {
-		return isFileSupported(pathname?.name ?: return false)
-	}
 
-	companion object {
+fun hasCbzExtension(string: String): Boolean {
+	val ext = string.substringAfterLast('.', "")
+	return isCbzExtension(ext)
+}
 
-		fun isFileSupported(name: String): Boolean {
+fun hasCbzExtension(file: File) = isCbzExtension(file.name)
-			val ext = name.substringAfterLast('.', "").lowercase(Locale.ROOT)
-			return ext == "cbz" || ext == "zip"
-		}
 
-		fun isUriSupported(uri: Uri): Boolean {
+fun isCbzUri(uri: Uri) = isCbzExtension(uri.scheme)
-			val scheme = uri.scheme?.lowercase(Locale.ROOT)
-			return scheme != null && scheme == "cbz" || scheme == "zip"
-		}
-	}
-}

app/src/main/kotlin/org/koitharu/kotatsu/local/data/ImageFileFilter.kt

@@ -1,29 +1,11 @@
 package org.koitharu.kotatsu.local.data
 
 import java.io.File
-import java.io.FileFilter
-import java.io.FilenameFilter
-import java.util.Locale
-import java.util.zip.ZipEntry
 
-class ImageFileFilter : FilenameFilter, FileFilter {
+fun hasImageExtension(string: String): Boolean {
-
+	val ext = string.substringAfterLast('.', "")
-	override fun accept(dir: File, name: String): Boolean {
+	return ext.equals("png", ignoreCase = true) || ext.equals("jpg", ignoreCase = true)
-		val ext = name.substringAfterLast('.', "").lowercase(Locale.ROOT)
+		|| ext.equals("jpeg", ignoreCase = true) || ext.equals("webp", ignoreCase = true)
-		return isExtensionValid(ext)
-	}
-
-	override fun accept(pathname: File?): Boolean {
-		val ext = pathname?.extension?.lowercase(Locale.ROOT) ?: return false
-		return isExtensionValid(ext)
-	}
-
-	fun accept(entry: ZipEntry): Boolean {
-		val ext = entry.name.substringAfterLast('.', "").lowercase(Locale.ROOT)
-		return isExtensionValid(ext)
-	}
-
-	fun isExtensionValid(ext: String): Boolean {
-		return ext == "png" || ext == "jpg" || ext == "jpeg" || ext == "webp"
-	}
 }
+
+fun hasImageExtension(file: File) = hasImageExtension(file.name)

app/src/main/kotlin/org/koitharu/kotatsu/local/data/importer/SingleMangaImporter.kt

@@ -15,9 +15,9 @@ import okio.source
 import org.koitharu.kotatsu.core.exceptions.UnsupportedFileException
 import org.koitharu.kotatsu.core.util.ext.resolveName
 import org.koitharu.kotatsu.core.util.ext.writeAllCancellable
-import org.koitharu.kotatsu.local.data.CbzFilter
 import org.koitharu.kotatsu.local.data.LocalStorageChanges
 import org.koitharu.kotatsu.local.data.LocalStorageManager
+import org.koitharu.kotatsu.local.data.hasCbzExtension
 import org.koitharu.kotatsu.local.data.input.LocalMangaInput
 import org.koitharu.kotatsu.local.domain.model.LocalManga
 import java.io.File
@@ -46,7 +46,7 @@ class SingleMangaImporter @Inject constructor(
 	private suspend fun importFile(uri: Uri): LocalManga = withContext(Dispatchers.IO) {
 		val contentResolver = storageManager.contentResolver
 		val name = contentResolver.resolveName(uri) ?: throw IOException("Cannot fetch name from uri: $uri")
-		if (!CbzFilter.isFileSupported(name)) {
+		if (!hasCbzExtension(name)) {
 			throw UnsupportedFileException("Unsupported file on $uri")
 		}
 		val dest = File(getOutputDir(), name)

app/src/main/kotlin/org/koitharu/kotatsu/local/data/input/LocalMangaDirInput.kt

@@ -6,12 +6,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runInterruptible
 import org.koitharu.kotatsu.core.util.AlphanumComparator
 import org.koitharu.kotatsu.core.util.ext.creationTime
-import org.koitharu.kotatsu.core.util.ext.listFilesRecursive
 import org.koitharu.kotatsu.core.util.ext.longHashCode
 import org.koitharu.kotatsu.core.util.ext.toListSorted
-import org.koitharu.kotatsu.local.data.CbzFilter
+import org.koitharu.kotatsu.core.util.ext.walkCompat
-import org.koitharu.kotatsu.local.data.ImageFileFilter
 import org.koitharu.kotatsu.local.data.MangaIndex
+import org.koitharu.kotatsu.local.data.hasCbzExtension
+import org.koitharu.kotatsu.local.data.hasImageExtension
 import org.koitharu.kotatsu.local.data.output.LocalMangaOutput
 import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -91,16 +91,12 @@ class LocalMangaDirInput(root: File) : LocalMangaInput(root) {
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> = runInterruptible(Dispatchers.IO) {
 		val file = chapter.url.toUri().toFile()
 		if (file.isDirectory) {
-			file.listFilesRecursive(ImageFileFilter())
+			file.walkCompat()
+				.filter { hasImageExtension(it) }
 				.toListSorted(compareBy(AlphanumComparator()) { x -> x.name })
 				.map {
 					val pageUri = it.toUri().toString()
-					MangaPage(
+					MangaPage(pageUri.longHashCode(), pageUri, null, MangaSource.LOCAL)
-						id = pageUri.longHashCode(),
-						url = pageUri,
-						preview = null,
-						source = MangaSource.LOCAL,
-					)
 				}
 		} else {
 			ZipFile(file).use { zip ->
@@ -124,20 +120,20 @@ class LocalMangaDirInput(root: File) : LocalMangaInput(root) {
 
 	private fun String.toHumanReadable() = replace("_", " ").toCamelCase()
 
-	private fun getChaptersFiles(): List<File> = root.listFilesRecursive(CbzFilter())
+	private fun getChaptersFiles(): List<File> = root.walkCompat()
-		.toListSorted(compareBy(AlphanumComparator()) { x -> x.name })
+		.filter { hasCbzExtension(it) }
+		.toListSorted(compareBy(AlphanumComparator()) { it.name })
 
 	private fun findFirstImageEntry(): String? {
-		val filter = ImageFileFilter()
+		return root.walkCompat().firstOrNull { hasImageExtension(it) }?.toUri()?.toString()
-		root.listFilesRecursive(filter).firstOrNull()?.let {
+			?: run {
-			return it.toUri().toString()
+				val cbz = root.walkCompat().firstOrNull { hasCbzExtension(it) } ?: return null
-		}
+				ZipFile(cbz).use { zip ->
-		val cbz = root.listFilesRecursive(CbzFilter()).firstOrNull() ?: return null
+					zip.entries().asSequence()
-		return ZipFile(cbz).use { zip ->
+						.firstOrNull { !it.isDirectory && hasImageExtension(it.name) }
-			zip.entries().asSequence()
+						?.let { zipUri(cbz, it.name) }
-				.firstOrNull { x -> !x.isDirectory && filter.accept(x) }
+				}
-				?.let { entry -> zipUri(cbz, entry.name) }
+			}
-		}
 	}
 
 	private fun fileUri(base: File, name: String): String {

app/src/main/kotlin/org/koitharu/kotatsu/local/data/input/LocalMangaInput.kt

@@ -7,7 +7,7 @@ import kotlinx.coroutines.flow.channelFlow
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.launch
-import org.koitharu.kotatsu.local.data.CbzFilter
+import org.koitharu.kotatsu.local.data.hasCbzExtension
 import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
@@ -39,7 +39,7 @@ sealed class LocalMangaInput(
 
 		fun ofOrNull(file: File): LocalMangaInput? = when {
 			file.isDirectory -> LocalMangaDirInput(file)
-			CbzFilter.isFileSupported(file.name) -> LocalMangaZipInput(file)
+			hasCbzExtension(file.name) -> LocalMangaZipInput(file)
 			else -> null
 		}
 

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

@@ -42,8 +42,8 @@ import org.koitharu.kotatsu.core.util.ext.ramAvailable
 import org.koitharu.kotatsu.core.util.ext.withProgress
 import org.koitharu.kotatsu.core.util.progress.ProgressDeferred
 import org.koitharu.kotatsu.core.zip.ZipPool
-import org.koitharu.kotatsu.local.data.CbzFilter
 import org.koitharu.kotatsu.local.data.PagesCache
+import org.koitharu.kotatsu.local.data.isCbzUri
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.reader.ui.pager.ReaderPage
@@ -199,7 +199,7 @@ class PageLoader @Inject constructor(
 		val pageUrl = getPageUrl(page)
 		check(pageUrl.isNotBlank()) { "Cannot obtain full image url" }
 		val uri = Uri.parse(pageUrl)
-		return if (CbzFilter.isUriSupported(uri)) {
+		return if (isCbzUri(uri)) {
 			runInterruptible(Dispatchers.IO) {
 				zipPool[uri]
 			}.use {

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/thumbnails/MangaPageFetcher.kt

@@ -19,8 +19,8 @@ import okio.source
 import org.koitharu.kotatsu.core.network.ImageProxyInterceptor
 import org.koitharu.kotatsu.core.network.MangaHttpClient
 import org.koitharu.kotatsu.core.parser.MangaRepository
-import org.koitharu.kotatsu.local.data.CbzFilter
 import org.koitharu.kotatsu.local.data.PagesCache
+import org.koitharu.kotatsu.local.data.isCbzUri
 import org.koitharu.kotatsu.local.data.util.withExtraCloseable
 import org.koitharu.kotatsu.parsers.model.MangaPage
 import org.koitharu.kotatsu.parsers.util.mimeType
@@ -56,7 +56,7 @@ class MangaPageFetcher(
 
 	private suspend fun loadPage(pageUrl: String): SourceResult {
 		val uri = pageUrl.toUri()
-		return if (CbzFilter.isUriSupported(uri)) {
+		return if (isCbzUri(uri)) {
 			runInterruptible(Dispatchers.IO) {
 				val zip = ZipFile(uri.schemeSpecificPart)
 				val entry = zip.getEntry(uri.fragment)