refactor: Use libarchive for Archive support

Co-authored-by: Ahmad Ansori Palembani <palembani@gmail.com>

core/build.gradle.kts

@@ -23,6 +23,8 @@ kotlin {
                 api(kotlinx.coroutines.core)
                 api(kotlinx.serialization.json)
                 api(kotlinx.serialization.json.okio)
+
+                implementation(libs.jsoup)
             }
         }
         val androidMain by getting {
@@ -39,6 +41,10 @@ kotlin {
                 api(androidx.preference)
 
                 implementation(libs.quickjs.android)
+
+                api(libs.unifile)
+
+                implementation(libs.libarchive)
             }
         }
     }

core/src/androidMain/kotlin/eu/kanade/tachiyomi/util/storage/EpubFile.kt

@@ -0,0 +1,141 @@
+package eu.kanade.tachiyomi.util.storage
+
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+import yokai.core.archive.ArchiveReader
+import java.io.Closeable
+import java.io.File
+import java.io.InputStream
+import java.nio.channels.SeekableByteChannel
+import java.text.ParseException
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+/**
+ * Wrapper over ZipFile to load files in epub format.
+ */
+class EpubFile(private val reader: ArchiveReader) : Closeable by reader {
+
+    /**
+     * Path separator used by this epub.
+     */
+    private val pathSeparator = getPathSeparator()
+
+    /**
+     * Returns an input stream for reading the contents of the specified zip file entry.
+     */
+    fun getInputStream(entryName: String): InputStream? {
+        return reader.getInputStream(entryName)
+    }
+
+    /**
+     * Returns the path of all the images found in the epub file.
+     */
+    fun getImagesFromPages(): List<String> {
+        val ref = getPackageHref()
+        val doc = getPackageDocument(ref)
+        val pages = getPagesFromDocument(doc)
+        return getImagesFromPages(pages, ref)
+    }
+
+    /**
+     * Returns the path to the package document.
+     */
+    fun getPackageHref(): String {
+        val meta = getInputStream(resolveZipPath("META-INF", "container.xml"))
+        if (meta != null) {
+            val metaDoc = meta.use { Jsoup.parse(it, null, "") }
+            val path = metaDoc.getElementsByTag("rootfile").first()?.attr("full-path")
+            if (path != null) {
+                return path
+            }
+        }
+        return resolveZipPath("OEBPS", "content.opf")
+    }
+
+    /**
+     * Returns the package document where all the files are listed.
+     */
+    fun getPackageDocument(ref: String): Document {
+        return getInputStream(ref)!!.use { Jsoup.parse(it, null, "") }
+    }
+
+    /**
+     * Returns all the pages from the epub.
+     */
+    private fun getPagesFromDocument(document: Document): List<String> {
+        val pages = document.select("manifest > item")
+            .filter { node -> "application/xhtml+xml" == node.attr("media-type") }
+            .associateBy { it.attr("id") }
+
+        val spine = document.select("spine > itemref").map { it.attr("idref") }
+        return spine.mapNotNull { pages[it] }.map { it.attr("href") }
+    }
+
+    /**
+     * Returns all the images contained in every page from the epub.
+     */
+    private fun getImagesFromPages(pages: List<String>, packageHref: String): List<String> {
+        val result = mutableListOf<String>()
+        val basePath = getParentDirectory(packageHref)
+        pages.forEach { page ->
+            val entryPath = resolveZipPath(basePath, page)
+            val document = getInputStream(entryPath)!!.use { Jsoup.parse(it, null, "") }
+            val imageBasePath = getParentDirectory(entryPath)
+
+            document.allElements.forEach {
+                if (it.tagName() == "img") {
+                    result.add(resolveZipPath(imageBasePath, it.attr("src")))
+                } else if (it.tagName() == "image") {
+                    result.add(resolveZipPath(imageBasePath, it.attr("xlink:href")))
+                }
+            }
+        }
+
+        return result
+    }
+
+    /**
+     * Returns the path separator used by the epub file.
+     */
+    private fun getPathSeparator(): String {
+        val meta = getInputStream("META-INF\\container.xml")
+        return if (meta != null) {
+            meta.close()
+            "\\"
+        } else {
+            "/"
+        }
+    }
+
+    /**
+     * Resolves a zip path from base and relative components and a path separator.
+     */
+    private fun resolveZipPath(basePath: String, relativePath: String): String {
+        if (relativePath.startsWith(pathSeparator)) {
+            // Path is absolute, so return as-is.
+            return relativePath
+        }
+
+        var fixedBasePath = basePath.replace(pathSeparator, File.separator)
+        if (!fixedBasePath.startsWith(File.separator)) {
+            fixedBasePath = "${File.separator}$fixedBasePath"
+        }
+
+        val fixedRelativePath = relativePath.replace(pathSeparator, File.separator)
+        val resolvedPath = File(fixedBasePath, fixedRelativePath).canonicalPath
+        return resolvedPath.replace(File.separator, pathSeparator).substring(1)
+    }
+
+    /**
+     * Gets the parent directory of a path.
+     */
+    private fun getParentDirectory(path: String): String {
+        val separatorIndex = path.lastIndexOf(pathSeparator)
+        return if (separatorIndex >= 0) {
+            path.substring(0, separatorIndex)
+        } else {
+            ""
+        }
+    }
+}

core/src/androidMain/kotlin/eu/kanade/tachiyomi/util/system/UniFileExtensions.kt

@@ -0,0 +1,54 @@
+package eu.kanade.tachiyomi.util.system
+
+import android.content.Context
+import android.os.Build
+import android.os.FileUtils
+import android.os.ParcelFileDescriptor
+import com.hippo.unifile.UniFile
+import java.io.BufferedOutputStream
+import java.io.File
+import java.nio.channels.SeekableByteChannel
+
+val UniFile.nameWithoutExtension: String?
+    get() = name?.substringBeforeLast('.')
+
+val UniFile.extension: String?
+    get() = name?.replace("${nameWithoutExtension.orEmpty()}.", "")
+
+val UniFile.displayablePath: String
+    get() = filePath ?: uri.toString()
+
+fun UniFile.toTempFile(context: Context): File {
+    val inputStream = context.contentResolver.openInputStream(uri)!!
+    val tempFile =
+        File.createTempFile(
+            nameWithoutExtension.orEmpty(),
+            null,
+        )
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        FileUtils.copy(inputStream, tempFile.outputStream())
+    } else {
+        BufferedOutputStream(tempFile.outputStream()).use { tmpOut ->
+            inputStream.use { input ->
+                val buffer = ByteArray(8192)
+                var count: Int
+                while (input.read(buffer).also { count = it } > 0) {
+                    tmpOut.write(buffer, 0, count)
+                }
+            }
+        }
+    }
+
+    return tempFile
+}
+
+fun UniFile.writeText(string: String, onComplete: () -> Unit = {}) {
+    this.openOutputStream().use {
+        it.write(string.toByteArray())
+        onComplete()
+    }
+}
+
+fun UniFile.openFileDescriptor(context: Context, mode: String): ParcelFileDescriptor =
+    context.contentResolver.openFileDescriptor(uri, mode) ?: error("Failed to open file descriptor: $displayablePath")

core/src/androidMain/kotlin/yokai/core/archive/AndroidArchiveInputStream.kt

@@ -0,0 +1,51 @@
+package yokai.core.archive
+
+import me.zhanghai.android.libarchive.Archive
+import me.zhanghai.android.libarchive.ArchiveEntry
+import me.zhanghai.android.libarchive.ArchiveException
+import java.nio.ByteBuffer
+
+class AndroidArchiveInputStream(buffer: Long, size: Long) : ArchiveInputStream() {
+    private val archive = Archive.readNew()
+
+    init {
+        try {
+            Archive.setCharset(archive, Charsets.UTF_8.name().toByteArray())
+            Archive.readSupportFilterAll(archive)
+            Archive.readSupportFormatAll(archive)
+            Archive.readOpenMemoryUnsafe(archive, buffer, size)
+        } catch (e: ArchiveException) {
+            close()
+            throw e
+        }
+    }
+
+    private val oneByteBuffer = ByteBuffer.allocateDirect(1)
+
+    override fun read(): Int {
+        read(oneByteBuffer)
+        return if (oneByteBuffer.hasRemaining()) oneByteBuffer.get().toUByte().toInt() else -1
+    }
+
+    override fun read(b: ByteArray, off: Int, len: Int): Int {
+        val buffer = ByteBuffer.wrap(b, off, len)
+        read(buffer)
+        return if (buffer.hasRemaining()) buffer.remaining() else -1
+    }
+
+    private fun read(buffer: ByteBuffer) {
+        buffer.clear()
+        Archive.readData(archive, buffer)
+        buffer.flip()
+    }
+
+    override fun close() {
+        Archive.readFree(archive)
+    }
+
+    fun getNextEntry() = Archive.readNextHeader(archive).takeUnless { it == 0L }?.let { entry ->
+        val name = ArchiveEntry.pathnameUtf8(entry) ?: ArchiveEntry.pathname(entry)?.decodeToString() ?: return null
+        val isFile = ArchiveEntry.filetype(entry) == ArchiveEntry.AE_IFREG
+        ArchiveEntry(name, isFile)
+    }
+}

core/src/androidMain/kotlin/yokai/core/archive/AndroidArchiveReader.kt

@@ -0,0 +1,42 @@
+package yokai.core.archive
+
+import android.content.Context
+import android.os.ParcelFileDescriptor
+import android.system.Os
+import android.system.OsConstants
+import com.hippo.unifile.UniFile
+import eu.kanade.tachiyomi.util.system.openFileDescriptor
+import me.zhanghai.android.libarchive.ArchiveException
+import java.io.InputStream
+
+class AndroidArchiveReader(pfd: ParcelFileDescriptor) : ArchiveReader {
+    val size = pfd.statSize
+    val address = Os.mmap(0, size, OsConstants.PROT_READ, OsConstants.MAP_PRIVATE, pfd.fileDescriptor, 0)
+
+    override fun <T> useEntries(block: (Sequence<ArchiveEntry>) -> T): T =
+        AndroidArchiveInputStream(address, size).use { block(generateSequence { it.getNextEntry() }) }
+
+    override fun getInputStream(entryName: String): InputStream? {
+        val archive = AndroidArchiveInputStream(address, size)
+        try {
+            while (true) {
+                val entry = archive.getNextEntry() ?: break
+                if (entry.name == entryName) {
+                    return archive
+                }
+            }
+        } catch (e: ArchiveException) {
+            archive.close()
+            throw e
+        }
+        archive.close()
+        return null
+    }
+
+    override fun close() {
+        Os.munmap(address, size)
+    }
+}
+
+fun UniFile.archiveReader(context: Context): ArchiveReader =
+    openFileDescriptor(context, "r").use { AndroidArchiveReader(it) }

core/src/androidMain/kotlin/yokai/core/archive/ZipWriter.kt

@@ -0,0 +1,74 @@
+package yokai.core.archive
+
+import android.content.Context
+import android.system.Os
+import android.system.StructStat
+import com.hippo.unifile.UniFile
+import eu.kanade.tachiyomi.util.system.openFileDescriptor
+import me.zhanghai.android.libarchive.Archive
+import me.zhanghai.android.libarchive.ArchiveEntry
+import me.zhanghai.android.libarchive.ArchiveException
+import java.io.Closeable
+import java.nio.ByteBuffer
+
+class ZipWriter(val context: Context, file: UniFile) : Closeable {
+    private val pfd = file.openFileDescriptor(context, "wt")
+    private val archive = Archive.writeNew()
+    private val entry = ArchiveEntry.new2(archive)
+    private val buffer = ByteBuffer.allocateDirect(8192)
+
+    init {
+        try {
+            Archive.setCharset(archive, Charsets.UTF_8.name().toByteArray())
+            Archive.writeSetFormatZip(archive)
+            Archive.writeZipSetCompressionStore(archive)
+            Archive.writeOpenFd(archive, pfd.fd)
+        } catch (e: ArchiveException) {
+            close()
+            throw e
+        }
+    }
+
+    fun write(file: UniFile) {
+        file.openFileDescriptor(context, "r").use {
+            val fd = it.fileDescriptor
+            ArchiveEntry.clear(entry)
+            ArchiveEntry.setPathnameUtf8(entry, file.name)
+            val stat = Os.fstat(fd)
+            ArchiveEntry.setStat(entry, stat.toArchiveStat())
+            Archive.writeHeader(archive, entry)
+            while (true) {
+                buffer.clear()
+                Os.read(fd, buffer)
+                if (buffer.position() == 0) break
+                buffer.flip()
+                Archive.writeData(archive, buffer)
+            }
+            Archive.writeFinishEntry(archive)
+        }
+    }
+
+    override fun close() {
+        ArchiveEntry.free(entry)
+        Archive.writeFree(archive)
+        pfd.close()
+    }
+}
+
+private fun StructStat.toArchiveStat() = ArchiveEntry.StructStat().apply {
+    stDev = st_dev
+    stMode = st_mode
+    stNlink = st_nlink.toInt()
+    stUid = st_uid
+    stGid = st_gid
+    stRdev = st_rdev
+    stSize = st_size
+    stBlksize = st_blksize
+    stBlocks = st_blocks
+    stAtim = timespec(st_atime)
+    stMtim = timespec(st_mtime)
+    stCtim = timespec(st_ctime)
+    stIno = st_ino
+}
+
+private fun timespec(tvSec: Long) = ArchiveEntry.StructTimespec().also { it.tvSec = tvSec }

core/src/commonMain/kotlin/yokai/core/archive/ArchiveEntry.kt

@@ -0,0 +1,6 @@
+package yokai.core.archive
+
+class ArchiveEntry(
+    val name: String,
+    val isFile: Boolean,
+)

core/src/commonMain/kotlin/yokai/core/archive/ArchiveInputStream.kt

@@ -0,0 +1,6 @@
+package yokai.core.archive
+
+import java.io.InputStream
+
+// TODO: Use Okio's Source
+abstract class ArchiveInputStream : InputStream()

core/src/commonMain/kotlin/yokai/core/archive/ArchiveReader.kt

@@ -0,0 +1,9 @@
+package yokai.core.archive
+
+import java.io.Closeable
+import java.io.InputStream
+
+interface ArchiveReader : Closeable {
+    fun <T> useEntries(block: (Sequence<ArchiveEntry>) -> T): T
+    fun getInputStream(entryName: String): InputStream?
+}