chore(release): 13.0.0 [skip ci]

# [13.0.0](https://github.com/ReVanced/revanced-patcher/compare/v12.1.1...v13.0.0) (2023-08-14)

### Bug Fixes

* decode in correct order ([8fb2f2d](8fb2f2dc1d))
* disable correct loggers ([c2d89c6](c2d89c622e))
* get framework ids to compile resources ([f2cb7ee](f2cb7ee7df))
* only enable logging for ReVanced ([783ccf8](783ccf8529))
* set package metadata correctly ([02d6ff1](02d6ff15fe))

* build(Needs bump)!: Bump dependencies ([d5f89a9](d5f89a903f))

### BREAKING CHANGES

* This bump updates smali, a crucial dependency

.releaserc

@@ -7,7 +7,13 @@
     }
   ],
   "plugins": [
-    "@semantic-release/commit-analyzer",
+    [
+      "@semantic-release/commit-analyzer", {
+        "releaseRules": [
+          { "type": "build", "scope": "Needs bump", "release": "patch" }
+        ]
+      }
+    ],
     "@semantic-release/release-notes-generator",
     "@semantic-release/changelog",
     "gradle-semantic-release-plugin",

CHANGELOG.md

@@ -1,3 +1,125 @@
+# [13.0.0](https://github.com/ReVanced/revanced-patcher/compare/v12.1.1...v13.0.0) (2023-08-14)
+
+
+### Bug Fixes
+
+* decode in correct order ([8fb2f2d](https://github.com/ReVanced/revanced-patcher/commit/8fb2f2dc1d3b9b1e9fd13b39485985d2886d52ae))
+* disable correct loggers ([c2d89c6](https://github.com/ReVanced/revanced-patcher/commit/c2d89c622e06e58e5042e1a00ef67cee8a246e53))
+* get framework ids to compile resources ([f2cb7ee](https://github.com/ReVanced/revanced-patcher/commit/f2cb7ee7dffa573c31df497cf235a3f5d120f91f))
+* only enable logging for ReVanced ([783ccf8](https://github.com/ReVanced/revanced-patcher/commit/783ccf8529f5d16aa463982da6977328306232bb))
+* set package metadata correctly ([02d6ff1](https://github.com/ReVanced/revanced-patcher/commit/02d6ff15fe87c2352de29749610e9d72db8ba418))
+
+
+* build(Needs bump)!: Bump dependencies ([d5f89a9](https://github.com/ReVanced/revanced-patcher/commit/d5f89a903f019c199bdb27a50287124fc4b4978e))
+
+
+### BREAKING CHANGES
+
+* This bump updates smali, a crucial dependency
+
+# [13.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v13.0.0-dev.2...v13.0.0-dev.3) (2023-08-14)
+
+
+### Bug Fixes
+
+* decode in correct order ([8fb2f2d](https://github.com/ReVanced/revanced-patcher/commit/8fb2f2dc1d3b9b1e9fd13b39485985d2886d52ae))
+* only enable logging for ReVanced ([783ccf8](https://github.com/ReVanced/revanced-patcher/commit/783ccf8529f5d16aa463982da6977328306232bb))
+
+# [13.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v13.0.0-dev.1...v13.0.0-dev.2) (2023-08-12)
+
+
+### Bug Fixes
+
+* disable correct loggers ([c2d89c6](https://github.com/ReVanced/revanced-patcher/commit/c2d89c622e06e58e5042e1a00ef67cee8a246e53))
+* get framework ids to compile resources ([f2cb7ee](https://github.com/ReVanced/revanced-patcher/commit/f2cb7ee7dffa573c31df497cf235a3f5d120f91f))
+* set package metadata correctly ([02d6ff1](https://github.com/ReVanced/revanced-patcher/commit/02d6ff15fe87c2352de29749610e9d72db8ba418))
+
+# [13.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v12.1.1...v13.0.0-dev.1) (2023-08-11)
+
+
+* build(Needs bump)!: Bump dependencies ([d5f89a9](https://github.com/ReVanced/revanced-patcher/commit/d5f89a903f019c199bdb27a50287124fc4b4978e))
+
+
+### BREAKING CHANGES
+
+* This bump updates smali, a crucial dependency
+
+## [12.1.1](https://github.com/ReVanced/revanced-patcher/compare/v12.1.0...v12.1.1) (2023-08-03)
+
+
+### Bug Fixes
+
+* clear method lookup maps before initializing them ([#210](https://github.com/ReVanced/revanced-patcher/issues/210)) ([746544f](https://github.com/ReVanced/revanced-patcher/commit/746544f9d51d1013bb160075709cd26bffd425b3))
+
+## [12.1.1-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v12.1.1-dev.1...v12.1.1-dev.2) (2023-08-03)
+
+## [12.1.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v12.1.0...v12.1.1-dev.1) (2023-08-03)
+
+
+### Bug Fixes
+
+* clear method lookup maps before initializing them ([#210](https://github.com/ReVanced/revanced-patcher/issues/210)) ([746544f](https://github.com/ReVanced/revanced-patcher/commit/746544f9d51d1013bb160075709cd26bffd425b3))
+
+# [12.1.0](https://github.com/ReVanced/revanced-patcher/compare/v12.0.0...v12.1.0) (2023-08-03)
+
+
+### Features
+
+* add `MutableMethod.getInstructions` extension function ([fae4029](https://github.com/ReVanced/revanced-patcher/commit/fae4029cfccfad7aa3dd8f7fbef1c63ee26b85b3))
+
+# [12.1.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v12.1.0-dev.1...v12.1.0-dev.2) (2023-08-03)
+
+# [12.1.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v12.0.0...v12.1.0-dev.1) (2023-08-01)
+
+
+### Features
+
+* add `MutableMethod.getInstructions` extension function ([fae4029](https://github.com/ReVanced/revanced-patcher/commit/fae4029cfccfad7aa3dd8f7fbef1c63ee26b85b3))
+
+# [12.0.0](https://github.com/ReVanced/revanced-patcher/compare/v11.0.4...v12.0.0) (2023-07-30)
+
+
+### Bug Fixes
+
+* correct access flags of `PackageMetadata` ([416d691](https://github.com/ReVanced/revanced-patcher/commit/416d69142f50dab49c9ea3f027e9d53e4777f257))
+* set resource table via resource decoder ([e0f8e1b](https://github.com/ReVanced/revanced-patcher/commit/e0f8e1b71a295948b610029c89a48f52762396b6))
+
+
+### Features
+
+* Deprecate `Version` annotation ([c9bbcf2](https://github.com/ReVanced/revanced-patcher/commit/c9bbcf2bf2b0f50ab9100380a3a66c6346ad42ac))
+* remove `Path` option ([#202](https://github.com/ReVanced/revanced-patcher/issues/202)) ([69e4a49](https://github.com/ReVanced/revanced-patcher/commit/69e4a490659ebc4fb4bf46148634f4b064ef1713))
+
+
+### BREAKING CHANGES
+
+* This removes the previously available `Path` option
+
+# [12.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v12.0.0-dev.1...v12.0.0-dev.2) (2023-07-28)
+
+
+### Features
+
+* Deprecate `Version` annotation ([400442f](https://github.com/ReVanced/revanced-patcher/commit/400442f70ee56cafd4493b2ce64a294db9836509))
+
+# [12.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v11.0.4...v12.0.0-dev.1) (2023-07-26)
+
+
+### Bug Fixes
+
+* correct access flags of `PackageMetadata` ([416d691](https://github.com/ReVanced/revanced-patcher/commit/416d69142f50dab49c9ea3f027e9d53e4777f257))
+* set resource table via resource decoder ([e0f8e1b](https://github.com/ReVanced/revanced-patcher/commit/e0f8e1b71a295948b610029c89a48f52762396b6))
+
+
+### Features
+
+* remove `Path` option ([#202](https://github.com/ReVanced/revanced-patcher/issues/202)) ([69e4a49](https://github.com/ReVanced/revanced-patcher/commit/69e4a490659ebc4fb4bf46148634f4b064ef1713))
+
+
+### BREAKING CHANGES
+
+* This removes the previously available `Path` option
+
 ## [11.0.4](https://github.com/revanced/revanced-patcher/compare/v11.0.3...v11.0.4) (2023-07-01)
 
 

arsclib-utils/.gitignore

@@ -1,42 +0,0 @@
-.gradle
-build/
-!gradle/wrapper/gradle-wrapper.jar
-!**/src/main/**/build/
-!**/src/test/**/build/
-
-### IntelliJ IDEA ###
-.idea/modules.xml
-.idea/jarRepositories.xml
-.idea/compiler.xml
-.idea/libraries/
-*.iws
-*.iml
-*.ipr
-out/
-!**/src/main/**/out/
-!**/src/test/**/out/
-
-### Eclipse ###
-.apt_generated
-.classpath
-.factorypath
-.project
-.settings
-.springBeans
-.sts4-cache
-bin/
-!**/src/main/**/bin/
-!**/src/test/**/bin/
-
-### NetBeans ###
-/nbproject/private/
-/nbbuild/
-/dist/
-/nbdist/
-/.nb-gradle/
-
-### VS Code ###
-.vscode/
-
-### Mac OS ###
-.DS_Store

arsclib-utils/build.gradle.kts

@@ -1,18 +0,0 @@
-plugins {
-    kotlin("jvm")
-    `maven-publish`
-}
-
-group = "app.revanced"
-
-dependencies {
-    implementation("io.github.reandroid:ARSCLib:1.1.7")
-}
-
-java {
-    withSourcesJar()
-}
-
-kotlin {
-    jvmToolchain(11)
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/ApkResourceException.kt

@@ -1,72 +0,0 @@
-package app.revanced.arsc
-
-/**
- * An exception thrown when there is an error with APK resources.
- *
- * @param message The exception message.
- * @param throwable The corresponding [Throwable].
- */
-sealed class ApkResourceException(message: String, throwable: Throwable? = null) : Exception(message, throwable) {
-    /**
-     * An exception when locking resources.
-     *
-     * @param message The exception message.
-     * @param throwable The corresponding [Throwable].
-     */
-    class Locked(message: String, throwable: Throwable? = null) : ApkResourceException(message, throwable)
-
-    /**
-     * An exception when writing resources.
-     *
-     * @param message The exception message.
-     * @param throwable The corresponding [Throwable].
-     */
-     class Write(message: String, throwable: Throwable? = null) : ApkResourceException(message, throwable)
-
-    /**
-     * An exception when reading resources.
-     *
-     * @param message The exception message.
-     * @param throwable The corresponding [Throwable].
-     */
-    class Read(message: String, throwable: Throwable? = null) : ApkResourceException(message, throwable)
-    /**
-     * An exception when decoding resources.
-     *
-     * @param message The exception message.
-     * @param throwable The corresponding [Throwable].
-     */
-    class Decode(message: String, throwable: Throwable? = null) : ApkResourceException(message, throwable)
-
-    /**
-     * An exception when encoding resources.
-     *
-     * @param message The exception message.
-     * @param throwable The corresponding [Throwable].
-     */
-    class Encode(message: String, throwable: Throwable? = null) : ApkResourceException(message, throwable)
-
-    /**
-     * An exception thrown when a reference could not be resolved.
-     *
-     * @param reference The invalid reference.
-     * @param throwable The corresponding [Throwable].
-     */
-    class InvalidReference(reference: String, throwable: Throwable? = null) :
-        ApkResourceException("Failed to resolve: $reference", throwable) {
-
-        /**
-         * An exception thrown when a reference could not be resolved.
-         *
-         * @param type The type of the reference.
-         * @param name The name of the reference.
-         * @param throwable The corresponding [Throwable].
-         */
-        constructor(type: String, name: String, throwable: Throwable? = null) : this("@$type/$name", throwable)
-    }
-
-    /**
-     * An exception thrown when the Apk file not have a resource table, but was expected to have one.
-     */
-    class MissingResourceTable : ApkResourceException("Apk does not have a resource table.")
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/archive/Archive.kt

@@ -1,28 +0,0 @@
-@file:Suppress("MemberVisibilityCanBePrivate")
-
-package app.revanced.arsc.archive
-
-import app.revanced.arsc.resource.ResourceContainer
-import com.reandroid.apk.ApkModule
-import com.reandroid.apk.DexFileInputSource
-import com.reandroid.archive.InputSource
-import java.io.File
-import java.io.Flushable
-
-/**
- * A class for reading/writing files in an [ApkModule].
- *
- * @param module The [ApkModule] to operate on.
- */
-class Archive(internal val module: ApkModule) : Flushable {
-    val mainPackageResources = ResourceContainer(this, module.tableBlock)
-
-    fun save(output: File) {
-        flush()
-        module.writeApk(output)
-    }
-    fun readDexFiles(): MutableList<DexFileInputSource> = module.listDexFiles()
-    fun write(inputSource: InputSource) = module.apkArchive.add(inputSource) // Overwrites existing files.
-    fun read(name: String): InputSource? = module.apkArchive.getInputSource(name)
-    override fun flush() = mainPackageResources.flush()
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/logging/Logger.kt

@@ -1,7 +0,0 @@
-package app.revanced.arsc.logging
-interface Logger {
-    fun error(msg: String)
-    fun warn(msg: String)
-    fun info(msg: String)
-    fun trace(msg: String)
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/resource/Resource.kt

@@ -1,166 +0,0 @@
-package app.revanced.arsc.resource
-
-import app.revanced.arsc.ApkResourceException
-import com.reandroid.arsc.coder.EncodeResult
-import com.reandroid.arsc.coder.ValueDecoder
-import com.reandroid.arsc.value.Entry
-import com.reandroid.arsc.value.ValueType
-import com.reandroid.arsc.value.array.ArrayBag
-import com.reandroid.arsc.value.array.ArrayBagItem
-import com.reandroid.arsc.value.plurals.PluralsBag
-import com.reandroid.arsc.value.plurals.PluralsBagItem
-import com.reandroid.arsc.value.plurals.PluralsQuantity
-import com.reandroid.arsc.value.style.StyleBag
-import com.reandroid.arsc.value.style.StyleBagItem
-
-/**
- * A resource value.
- */
-sealed class Resource {
-    internal abstract fun write(entry: Entry, resources: ResourceContainer)
-}
-
-internal val Resource.isComplex get() = when (this) {
-    is Scalar -> false
-    is Complex -> true
-}
-
-/**
- * A simple resource.
- */
-open class Scalar internal constructor(private val valueType: ValueType, private val value: Int) : Resource() {
-    protected open fun data(resources: ResourceContainer) = value
-
-    override fun write(entry: Entry, resources: ResourceContainer) {
-        entry.setValueAsRaw(valueType, data(resources))
-    }
-
-    internal open fun toArrayItem(resources: ResourceContainer) = ArrayBagItem.create(valueType, data(resources))
-    internal open fun toStyleItem(resources: ResourceContainer) = StyleBagItem.create(valueType, data(resources))
-}
-
-/**
- * A marker class for complex resources.
- */
-sealed class Complex : Resource()
-
-private fun encoded(encodeResult: EncodeResult?) = encodeResult?.let { Scalar(it.valueType, it.value) }
-    ?: throw ApkResourceException.Encode("Failed to encode value")
-
-/**
- * Encode a color.
- *
- * @param hex The hex value of the color.
- * @return The encoded [Resource].
- */
-fun color(hex: String) = encoded(ValueDecoder.encodeColor(hex))
-
-/**
- * Encode a dimension or fraction.
- *
- * @param value The dimension value such as 24dp.
- * @return The encoded [Resource].
- */
-fun dimension(value: String) = encoded(ValueDecoder.encodeDimensionOrFraction(value))
-
-/**
- * Encode a boolean resource.
- *
- * @param value The boolean.
- * @return The encoded [Resource].
- */
-fun boolean(value: Boolean) = Scalar(ValueType.INT_BOOLEAN, if (value) -Int.MAX_VALUE else 0)
-
-/**
- * Encode a float.
- *
- * @param n The number to encode.
- * @return The encoded [Resource].
- */
-fun float(n: Float) = Scalar(ValueType.FLOAT, n.toBits())
-
-/**
- * Create an integer [Resource].
- *
- * @param n The number to encode.
- * @return The integer [Resource].
- */
-fun integer(n: Int) = Scalar(ValueType.INT_DEC, n)
-
-/**
- * Create a reference [Resource].
- *
- * @param resourceId The target resource.
- * @return The reference resource.
- */
-fun reference(resourceId: Int) = Scalar(ValueType.REFERENCE, resourceId)
-
-/**
- * Resolve and create a reference [Resource].
- *
- * @see reference
- * @param ref The reference string to resolve.
- * @param resourceTable The resource table to resolve the reference with.
- * @return The reference resource.
- */
-fun reference(resourceTable: ResourceTable, ref: String) = reference(resourceTable.resolve(ref))
-
-/**
- * An array [Resource].
- *
- * @param elements The elements of the array.
- */
-class Array(private val elements: Collection<Scalar>) : Complex() {
-    override fun write(entry: Entry, resources: ResourceContainer) {
-        ArrayBag.create(entry).addAll(elements.map { it.toArrayItem(resources) })
-    }
-}
-
-/**
- * A style resource.
- *
- * @param elements The attributes to override.
- * @param parent A reference to the parent style.
- */
-class Style(private val elements: Map<String, Scalar>, private val parent: String? = null) : Complex() {
-    override fun write(entry: Entry, resources: ResourceContainer) {
-        val resTable = resources.resourceTable
-        val style = StyleBag.create(entry)
-        parent?.let {
-            style.parentId = resTable.resolve(parent)
-        }
-
-        style.putAll(
-            elements.asIterable().associate {
-                StyleBag.resolve(resTable.encodeMaterials, it.key) to it.value.toStyleItem(resources)
-            })
-    }
-}
-
-/**
- * A quantity string [Resource].
- *
- * @param elements A map of the quantity to the corresponding string.
- */
-class Plurals(private val elements: Map<String, String>) : Complex() {
-    override fun write(entry: Entry, resources: ResourceContainer) {
-        val plurals = PluralsBag.create(entry)
-
-        plurals.putAll(elements.asIterable().associate { (k, v) ->
-            PluralsQuantity.value(k) to PluralsBagItem.string(resources.getOrCreateString(v))
-        })
-    }
-}
-
-/**
- * A string [Resource].
- *
- * @param value The string value.
- */
-class StringResource(val value: String) : Scalar(ValueType.STRING, 0) {
-    private fun tableString(resources: ResourceContainer) = resources.getOrCreateString(value)
-
-    override fun data(resources: ResourceContainer) = tableString(resources).index
-    override fun toArrayItem(resources: ResourceContainer) = ArrayBagItem.string(tableString(resources))
-    override fun toStyleItem(resources: ResourceContainer) = StyleBagItem.string(tableString(resources))
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/resource/ResourceContainer.kt

@@ -1,167 +0,0 @@
-package app.revanced.arsc.resource
-
-import app.revanced.arsc.ApkResourceException
-import app.revanced.arsc.archive.Archive
-import com.reandroid.apk.xmlencoder.EncodeUtil
-import com.reandroid.arsc.chunk.TableBlock
-import com.reandroid.arsc.chunk.xml.ResXmlDocument
-import com.reandroid.arsc.value.Entry
-import com.reandroid.arsc.value.ResConfig
-import java.io.Closeable
-import java.io.File
-import java.io.Flushable
-
-class ResourceContainer(private val archive: Archive, internal val tableBlock: TableBlock) : Flushable {
-    private val packageBlock = tableBlock.pickOne() // Pick the main package block.
-    internal lateinit var resourceTable: ResourceTable // TODO: Set this.
-
-    private val lockedResourceFileNames = mutableSetOf<String>()
-
-    private fun lock(resourceFile: ResourceFile) {
-        if (resourceFile.name in lockedResourceFileNames) {
-            throw ApkResourceException.Locked("Resource file ${resourceFile.name} is already locked.")
-        }
-
-        lockedResourceFileNames.add(resourceFile.name)
-    }
-
-    private fun unlock(resourceFile: ResourceFile) {
-        lockedResourceFileNames.remove(resourceFile.name)
-    }
-
-
-    fun <T : ResourceFile> openResource(name: String): ResourceFileEditor<T> {
-        val inputSource = archive.read(name)
-            ?: throw ApkResourceException.Read("Resource file $name not found.")
-
-        val resourceFile = when {
-            ResXmlDocument.isResXmlBlock(inputSource.openStream()) -> {
-                val xmlDocument = archive.module
-                    .loadResXmlDocument(inputSource)
-                    .decodeToXml(resourceTable.entryStore, packageBlock.id)
-
-                ResourceFile.XmlResourceFile(name, xmlDocument)
-            }
-
-            else -> {
-                val bytes = inputSource.openStream().use { it.readAllBytes() }
-
-                ResourceFile.BinaryResourceFile(name, bytes)
-            }
-        }
-
-        try {
-            @Suppress("UNCHECKED_CAST")
-            return ResourceFileEditor(resourceFile as T).also {
-                lockedResourceFileNames.add(name)
-            }
-        } catch (e: ClassCastException) {
-            throw ApkResourceException.Decode("Resource file $name is not ${resourceFile::class}.", e)
-        }
-    }
-
-    inner class ResourceFileEditor<T : ResourceFile> internal constructor(
-        private val resourceFile: T,
-    ) : Closeable {
-        fun use(block: (T) -> Unit) = block(resourceFile)
-        override fun close() {
-            lockedResourceFileNames.remove(resourceFile.name)
-        }
-    }
-
-    override fun flush() {
-        TODO("Not yet implemented")
-    }
-
-    /**
-     * Open a resource file, creating it if the file does not exist.
-     *
-     * @param path The resource file path.
-     * @return The corresponding [ResourceFiles],
-     */
-    fun openFile(path: String) = ResourceFiles(createHandle(path), archive)
-
-    private fun getPackageBlock() = packageBlock ?: throw ApkResourceException.MissingResourceTable
-
-    internal fun getOrCreateString(value: String) =
-        tableBlock?.stringPool?.getOrCreate(value) ?: throw ApkResourceException.MissingResourceTable
-
-    private fun Entry.set(resource: Resource) {
-        val existingEntryNameReference = specReference
-
-        // Sets this.specReference if the entry is not yet initialized.
-        // Sets this.specReference to 0 if the resource type of the existing entry changes.
-        ensureComplex(resource.isComplex)
-
-        if (existingEntryNameReference != 0) {
-            // Preserve the entry name by restoring the previous spec block reference (if present).
-            specReference = existingEntryNameReference
-        }
-
-        resource.write(this, this@ResourceContainer)
-        resourceTable.registerChanged(this)
-    }
-
-    /**
-     * Retrieve an [Entry] from the resource table.
-     *
-     * @param type The resource type.
-     * @param name The resource name.
-     * @param qualifiers The variant to use.
-     */
-    private fun getEntry(type: String, name: String, qualifiers: String?): Entry? {
-        val resourceId = try {
-            resourceTable.resolve("@$type/$name")
-        } catch (_: ApkResourceException.InvalidReference) {
-            return null
-        }
-
-        val config = ResConfig.parse(qualifiers)
-        return tableBlock?.resolveReference(resourceId)?.singleOrNull { it.resConfig == config }
-    }
-
-    /**
-     * Create a [ResourceFiles.Handle] that can be used to open a [ResourceFiles].
-     * This may involve looking it up in the resource table to find the actual location in the archive.
-     *
-     * @param path The path of the resource.
-     */
-    private fun createHandle(path: String): ResourceFiles.Handle {
-        if (path.startsWith("res/values")) throw ApkResourceException.Decode("Decoding the resource table as a file is not supported")
-
-        var onClose = {}
-        var archivePath = path
-
-        if (tableBlock != null && path.startsWith("res/") && path.count { it == '/' } == 2) {
-            val file = File(path)
-
-            val qualifiers = EncodeUtil.getQualifiersFromResFile(file)
-            val type = EncodeUtil.getTypeNameFromResFile(file)
-            val name = file.nameWithoutExtension
-
-            // The resource file names that the app developers used may have been minified, so we have to resolve it with the resource table.
-            // Example: res/drawable-hdpi/icon.png -> res/4a.png
-            getEntry(type, name, qualifiers)?.resValue?.valueAsString?.let {
-                archivePath = it
-            } ?: run {
-                // An entry for this specific resource file was not found in the resource table, so we have to register it after we save.
-                onClose = { setResource(type, name, StringResource(archivePath), qualifiers) }
-            }
-        }
-
-        return ResourceFiles.Handle(path, archivePath, onClose)
-    }
-
-    fun setResource(type: String, entryName: String, resource: Resource, qualifiers: String? = null) =
-        getPackageBlock().getOrCreate(qualifiers, type, entryName).also { it.set(resource) }.resourceId
-
-    fun setResources(type: String, resources: Map<String, Resource>, configuration: String? = null) {
-        getPackageBlock().getOrCreateSpecTypePair(type).getOrCreateTypeBlock(configuration).apply {
-            resources.forEach { (entryName, resource) -> getOrCreateEntry(entryName).set(resource) }
-        }
-    }
-
-    override fun flush() {
-        packageBlock?.name = archive
-    }
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/resource/ResourceFiles.kt

@@ -1,91 +0,0 @@
-package app.revanced.arsc.resource
-
-import app.revanced.arsc.ApkResourceException
-import app.revanced.arsc.archive.Archive
-import com.reandroid.archive.InputSource
-import com.reandroid.xml.XMLDocument
-import com.reandroid.xml.XMLException
-import java.io.*
-
-
-abstract class ResourceFile(val name: String) {
-    internal var realName: String? = null
-
-    class XmlResourceFile(name: String, val document: XMLDocument) : ResourceFile(name)
-    class BinaryResourceFile(name: String, var bytes: ByteArray) : ResourceFile(name)
-}
-
-
-class ResourceFiles private constructor(
-) : Closeable {
-
-    /**
-     * Instantiate a [ResourceFiles].
-     *
-     * @param handle The [Handle] associated with this file.
-     * @param archive The [Archive] that the file resides in.
-     */
-    internal constructor(handle: Handle, archive: Archive) : this(
-        handle,
-        archive,
-        try {
-            archive.read(handle.archivePath)
-        } catch (e: XMLException) {
-            throw ApkResourceException.Decode("Failed to decode XML while reading ${handle.virtualPath}", e)
-        } catch (e: IOException) {
-            throw ApkResourceException.Decode("Could not read ${handle.virtualPath}", e)
-        }
-    )
-
-    companion object {
-        const val DEFAULT_BUFFER_SIZE = 1024
-    }
-
-    var contents = readResult?.data ?: ByteArray(0)
-        set(value) {
-            pendingWrite = true
-            field = value
-        }
-
-    val exists = readResult != null
-
-    override fun toString() = handle.virtualPath
-
-    override fun close() {
-        if (pendingWrite) {
-            val path = handle.archivePath
-
-            if (isXmlResource) archive.writeXml(
-                path,
-                try {
-                    XMLDocument.load(inputStream())
-                } catch (e: XMLException) {
-                    throw ApkResourceException.Encode("Failed to parse XML while writing ${handle.virtualPath}", e)
-                }
-
-            ) else archive.writeRaw(path, contents)
-        }
-
-        handle.onClose()
-
-
-        archive.unlock(this)
-    }
-
-    fun inputStream(): InputStream = ByteArrayInputStream(contents)
-
-    fun outputStream(bufferSize: Int = DEFAULT_BUFFER_SIZE): OutputStream =
-        object : ByteArrayOutputStream(bufferSize) {
-            override fun close() {
-                this@ResourceFiles.contents = if (buf.size > count) buf.copyOf(count) else buf
-                super.close()
-            }
-        }
-
-    /**
-     * @param virtualPath The resource file path. Example: /res/drawable-hdpi/icon.png.
-     * @param archivePath The actual file path in the archive. Example: res/4a.png.
-     * @param onClose An action to perform when the file associated with this handle is closed
-     */
-    internal data class Handle(val virtualPath: String, val archivePath: String, val onClose: () -> Unit)
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/resource/ResourceTable.kt

@@ -1,100 +0,0 @@
-package app.revanced.arsc.resource
-
-import app.revanced.arsc.ApkResourceException
-import com.reandroid.apk.xmlencoder.EncodeException
-import com.reandroid.apk.xmlencoder.EncodeMaterials
-import com.reandroid.arsc.util.FrameworkTable
-import com.reandroid.arsc.value.Entry
-import com.reandroid.common.TableEntryStore
-
-/**
- * A high-level API for resolving resources in the resource table, which spans the entire ApkBundle.
- */
-class ResourceTable(base: ResourceContainer, all: Sequence<ResourceContainer>) {
-    private val packageName = base.tableBlock!!.name
-
-    /**
-     * A [TableEntryStore] used to decode XML.
-     */
-    internal val entryStore = TableEntryStore()
-
-    /**
-     * The [EncodeMaterials] to use for resolving resources and encoding XML.
-     */
-    internal val encodeMaterials: EncodeMaterials = object : EncodeMaterials() {
-        /*
-        Our implementation is more efficient because it does not have to loop through every single entry group
-        when the resource id cannot be found in the TableIdentifier, which does not update when you create a new resource.
-        It also looks at the entire table instead of just the current package.
-        */
-        override fun resolveLocalResourceId(type: String, name: String) = resolveLocal(type, name)
-    }
-
-    /**
-     * The resource mappings which are generated when the ApkBundle is created.
-     */
-    private val tableIdentifier = encodeMaterials.tableIdentifier
-
-    /**
-     * A table of all the resources that have been changed or added.
-     */
-    private val modifiedResources = HashMap<String, HashMap<String, Int>>()
-
-
-    /**
-     * Resolve a resource id for the specified resource.
-     * Cannot resolve resources from the android framework.
-     *
-     * @param type The type of the resource.
-     * @param name The name of the resource.
-     * @return The id of the resource.
-     */
-    fun resolveLocal(type: String, name: String) =
-        modifiedResources[type]?.get(name)
-            ?: tableIdentifier.get(packageName, type, name)?.resourceId
-            ?: throw ApkResourceException.InvalidReference(
-                type,
-                name
-            )
-
-    /**
-     * Resolve a resource id for the specified resource.
-     *
-     * @param reference The resource reference string.
-     * @return The id of the resource.
-     */
-    fun resolve(reference: String) = try {
-        encodeMaterials.resolveReference(reference)
-    } catch (e: EncodeException) {
-        throw ApkResourceException.InvalidReference(reference, e)
-    }
-
-    /**
-     * Notify the [ResourceTable] that an [Entry] has been created or modified.
-     */
-    internal fun registerChanged(entry: Entry) {
-        modifiedResources.getOrPut(entry.typeName, ::HashMap)[entry.name] = entry.resourceId
-    }
-
-    init {
-        all.forEach {
-            it.tableBlock?.let { table ->
-                entryStore.add(table)
-                tableIdentifier.load(table)
-            }
-
-            it.resourceTable = this
-        }
-
-        base.also {
-            encodeMaterials.currentPackage = it.tableBlock
-
-            it.tableBlock!!.frameWorks.forEach { fw ->
-                if (fw is FrameworkTable) {
-                    entryStore.add(fw)
-                    encodeMaterials.addFramework(fw)
-                }
-            }
-        }
-    }
-}

arsclib-utils/src/main/kotlin/app/revanced/arsc/xml/LazyXMLEncodeSource.kt

@@ -1,56 +0,0 @@
-package app.revanced.arsc.xml
-
-import app.revanced.arsc.resource.ResourceContainer
-import app.revanced.arsc.resource.boolean
-import com.reandroid.apk.xmlencoder.EncodeException
-import com.reandroid.apk.xmlencoder.XMLEncodeSource
-import com.reandroid.arsc.chunk.xml.ResXmlDocument
-import com.reandroid.xml.XMLDocument
-import com.reandroid.xml.XMLElement
-import com.reandroid.xml.source.XMLDocumentSource
-
-/**
- * Archive input source to lazily encode an [XMLDocument] after it has been modified.
- *
- * @param name The file name of this input source.
- * @param document The [XMLDocument] to encode.
- * @param resources The [ResourceContainer] to use for encoding.
- */
-internal class LazyXMLEncodeSource(
-    name: String,
-    val document: XMLDocument,
-    private val resources: ResourceContainer
-) : XMLEncodeSource(resources.resourceTable.encodeMaterials, XMLDocumentSource(name, document)) {
-    private var encoded = false
-
-    override fun getResXmlBlock(): ResXmlDocument {
-        if (encoded) return super.getResXmlBlock()
-
-        XMLEncodeSource(resources.resourceTable.encodeMaterials, XMLDocumentSource(name, document))
-        
-        fun XMLElement.registerIds() {
-            listAttributes().forEach { attr ->
-                if (!attr.value.startsWith("@+id/")) return@forEach
-
-                val name = attr.value.split('/').last()
-                resources.setResource("id", name, boolean(false))
-                attr.value = "@id/$name"
-            }
-
-            listChildElements().forEach { it.registerIds() }
-        }
-
-        // Handle all @+id/id_name references in the document.
-        document.documentElement.registerIds()
-
-        encoded = true
-
-        // This will call XMLEncodeSource.getResXmlBlock(),
-        // which will encode the document if it has not already been encoded.
-        try {
-            return super.getResXmlBlock()
-        } catch (e: EncodeException) {
-            throw EncodeException("Failed to encode $name", e)
-        }
-    }
-}

build.gradle.kts

@@ -1,3 +1,74 @@
 plugins {
-    kotlin("jvm") version "1.8.20" apply false
+    kotlin("jvm") version "1.8.20"
+    `maven-publish`
+}
+
+group = "app.revanced"
+
+val githubUsername: String = project.findProperty("gpr.user") as? String ?: System.getenv("GITHUB_ACTOR")
+val githubPassword: String = project.findProperty("gpr.key") as? String ?: System.getenv("GITHUB_TOKEN")
+
+repositories {
+    mavenCentral()
+    google()
+    listOf("multidexlib2", "apktool").forEach { repo ->
+        maven {
+            url = uri("https://maven.pkg.github.com/revanced/$repo")
+            credentials {
+                username = githubUsername
+                password = githubPassword
+            }
+        }
+    }
+}
+
+dependencies {
+    implementation("xpp3:xpp3:1.1.4c")
+    implementation("com.android.tools.smali:smali:3.0.3")
+    implementation("app.revanced:multidexlib2:3.0.3.r2")
+    implementation("app.revanced:apktool-lib:2.8.2-3")
+
+    implementation("org.jetbrains.kotlin:kotlin-reflect:1.8.22")
+    testImplementation("org.jetbrains.kotlin:kotlin-test:1.8.20-RC")
+}
+
+tasks {
+    test {
+        useJUnitPlatform()
+        testLogging {
+            events("PASSED", "SKIPPED", "FAILED")
+        }
+    }
+    processResources {
+        expand("projectVersion" to project.version)
+    }
+}
+
+java {
+    withSourcesJar()
+}
+
+kotlin {
+    jvmToolchain(11)
+}
+
+publishing {
+    repositories {
+        if (System.getenv("GITHUB_ACTOR") != null)
+            maven {
+                name = "GitHubPackages"
+                url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
+                credentials {
+                    username = System.getenv("GITHUB_ACTOR")
+                    password = System.getenv("GITHUB_TOKEN")
+                }
+            }
+        else
+            mavenLocal()
+    }
+    publications {
+        register<MavenPublication>("gpr") {
+            from(components["java"])
+        }
+    }
 }

gradle.properties

@@ -1,4 +1,4 @@
-org.gradle.parallel=true
+org.gradle.parallel = true
-org.gradle.caching=true
+org.gradle.caching = true
 kotlin.code.style = official
-version = 11.0.4
+version = 13.0.0

revanced-patcher/build.gradle.kts

@@ -1,61 +0,0 @@
-plugins {
-    kotlin("jvm")
-    `maven-publish`
-}
-
-group = "app.revanced"
-
-dependencies {
-    implementation("xpp3:xpp3:1.1.4c")
-    implementation("app.revanced:smali:2.5.3-a3836654")
-    implementation("app.revanced:multidexlib2:2.5.3-a3836654")
-    implementation("io.github.reandroid:ARSCLib:1.1.7")
-    implementation(project(":arsclib-utils"))
-
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1")
-    implementation("org.jetbrains.kotlin:kotlin-reflect:1.8.20-RC")
-    testImplementation("org.jetbrains.kotlin:kotlin-test:1.8.20-RC")
-
-    compileOnly("com.google.android:android:4.1.1.4")
-}
-
-tasks {
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
-    }
-    processResources {
-        expand("projectVersion" to project.version)
-    }
-}
-
-java {
-    withSourcesJar()
-}
-
-kotlin {
-    jvmToolchain(11)
-}
-
-publishing {
-    repositories {
-        if (System.getenv("GITHUB_ACTOR") != null)
-            maven {
-                name = "GitHubPackages"
-                url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
-                credentials {
-                    username = System.getenv("GITHUB_ACTOR")
-                    password = System.getenv("GITHUB_TOKEN")
-                }
-            }
-        else
-            mavenLocal()
-    }
-    publications {
-        register<MavenPublication>("gpr") {
-            from(components["java"])
-        }
-    }
-}

revanced-patcher/settings.gradle.kts

@@ -1 +0,0 @@
-rootProject.name = "revanced-patcher"

revanced-patcher/src/main/kotlin/app/revanced/patcher/Context.kt

@@ -1,113 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.arsc.resource.ResourceContainer
-import app.revanced.patcher.apk.Apk
-import app.revanced.patcher.apk.ApkBundle
-import app.revanced.arsc.resource.ResourceFiles
-import app.revanced.patcher.util.method.MethodWalker
-import org.jf.dexlib2.iface.Method
-import org.w3c.dom.Document
-import java.io.Closeable
-import java.io.InputStream
-import java.io.StringWriter
-import javax.xml.parsers.DocumentBuilderFactory
-import javax.xml.transform.TransformerFactory
-import javax.xml.transform.dom.DOMSource
-import javax.xml.transform.stream.StreamResult
-
-/**
- * A common class to constrain [Context] to [BytecodeContext] and [ResourceContext].
- * @param apkBundle The [ApkBundle] for this context.
- */
-sealed class Context(val apkBundle: ApkBundle)
-
-/**
- * A context for the bytecode of an [Apk.Base] file.
- *
- * @param apkBundle The [ApkBundle] for this context.
- */
-class BytecodeContext internal constructor(apkBundle: ApkBundle) : Context(apkBundle) {
-    /**
-     * The list of classes.
-     */
-    val classes = apkBundle.base.bytecodeData.classes
-
-    /**
-     * Create a [MethodWalker] instance for the current [BytecodeContext].
-     *
-     * @param startMethod The method to start at.
-     * @return A [MethodWalker] instance.
-     */
-    fun traceMethodCalls(startMethod: Method) = MethodWalker(this, startMethod)
-}
-
-/**
- * A context for [Apk] file resources.
- *
- * @param apkBundle the [ApkBundle] for this context.
- */
-class ResourceContext internal constructor(apkBundle: ApkBundle) : Context(apkBundle) {
-
-    /**
-     * Open an [DomFileEditor] for a given DOM file.
-     *
-     * @param inputStream The input stream to read the DOM file from.
-     * @return A [DomFileEditor] instance.
-     */
-    fun openXmlFile(inputStream: InputStream) = DomFileEditor(inputStream)
-}
-
-
-/**
- * Open a [DomFileEditor] for a resource file in the archive.
- *
- * @see [ResourceContainer.openFile]
- * @param path The resource file path.
- * @return A [DomFileEditor].
- */
-fun ResourceContainer.openXmlFile(path: String) = DomFileEditor(openFile(path))
-
-/**
- * Wrapper for a file that can be edited as a dom document.
- *
- * @param inputStream the input stream to read the xml file from.
- * @param onSave A callback that will be called when the editor is closed to save the file.
- */
-class DomFileEditor internal constructor(
-    private val inputStream: InputStream,
-    private val onSave: ((String) -> Unit)? = null
-) : Closeable {
-    private var closed: Boolean = false
-
-    /**
-     * The document of the xml file.
-     */
-    val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
-        .also(Document::normalize)
-
-    internal constructor(file: ResourceFiles) : this(
-        file.inputStream(),
-        {
-            file.contents = it.toByteArray()
-            file.close()
-        }
-    )
-
-    /**
-     * Closes the editor and writes back to the file.
-     */
-    override fun close() {
-        if (closed) return
-
-        inputStream.close()
-
-        onSave?.let { callback ->
-            // Save the updated file.
-            val writer = StringWriter()
-            TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), StreamResult(writer))
-            callback(writer.toString())
-        }
-
-        closed = true
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/Patcher.kt

@@ -1,222 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.apk.Apk
-import app.revanced.patcher.extensions.PatchExtensions.dependencies
-import app.revanced.patcher.extensions.PatchExtensions.patchName
-import app.revanced.patcher.extensions.PatchExtensions.requiresIntegrations
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolveUsingLookupMap
-import app.revanced.patcher.patch.*
-import app.revanced.patcher.util.VersionReader
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-import lanchon.multidexlib2.BasicDexFileNamer
-import java.io.Closeable
-import java.io.File
-import java.util.function.Function
-
-typealias ExecutedPatchResults = Flow<Pair<String, PatchException?>>
-
-/**
- * The ReVanced Patcher.
- * @param options The options for the patcher.
- * @param patches The patches to use.
- * @param integrations The integrations to merge if necessary. Must be dex files or dex file container such as ZIP, APK or DEX files.
- */
-class Patcher(private val options: PatcherOptions, patches: Iterable<PatchClass>, integrations: Iterable<File>) :
-    Function<Boolean, ExecutedPatchResults> {
-    private val context = PatcherContext(options, patches.toList(), integrations)
-    private val logger = options.logger
-
-    companion object {
-        /**
-         * The version of the ReVanced Patcher.
-         */
-        @JvmStatic
-        val version = VersionReader.read()
-
-        @Suppress("SpellCheckingInspection")
-        internal val dexFileNamer = BasicDexFileNamer()
-    }
-
-    init {
-        /**
-         * Returns true if at least one patches or its dependencies matches the given predicate.
-         */
-        fun PatchClass.anyRecursively(predicate: (PatchClass) -> Boolean): Boolean =
-            predicate(this) || dependencies?.any { it.java.anyRecursively(predicate) } == true
-
-        // Determine if merging integrations is required.
-        for (patch in context.patches) {
-            if (patch.anyRecursively { it.requiresIntegrations }) {
-                context.integrations.merge = true
-                break
-            }
-        }
-    }
-
-    /**
-     * Execute the patcher.
-     *
-     * @param stopOnError If true, the patches will stop on the first error.
-     * @return A pair of the name of the [Patch] and a [PatchException] if it failed.
-     */
-    override fun apply(stopOnError: Boolean) = flow {
-        /**
-         * Execute a [Patch] and its dependencies recursively.
-         *
-         * @param patchClass The [Patch] to execute.
-         * @param executedPatches A map of [Patch]es paired to a boolean indicating their success, to prevent infinite recursion.
-         */
-        suspend fun executePatch(
-            patchClass: PatchClass,
-            executedPatches: HashMap<String, ExecutedPatch>
-        ) {
-            val patchName = patchClass.patchName
-
-            // If the patch has already executed silently skip it.
-            if (executedPatches.contains(patchName)) {
-                if (!executedPatches[patchName]!!.success)
-                    throw PatchException("'$patchName' did not succeed previously")
-
-                logger.trace("Skipping '$patchName' because it has already been executed")
-
-                return
-            }
-
-            // Recursively execute all dependency patches.
-            patchClass.dependencies?.forEach { dependencyClass ->
-                val dependency = dependencyClass.java
-
-                try {
-                    executePatch(dependency, executedPatches)
-                } catch (throwable: Throwable) {
-                    throw PatchException(
-                        "'$patchName' depends on '${dependency.patchName}' " +
-                                "but the following exception was raised: ${throwable.cause?.stackTraceToString() ?: throwable.message}",
-                        throwable
-                    )
-                }
-            }
-
-            val isResourcePatch = ResourcePatch::class.java.isAssignableFrom(patchClass)
-            val patchInstance = patchClass.getDeclaredConstructor().newInstance()
-
-            // TODO: implement this in a more polymorphic way.
-            val patchContext = if (isResourcePatch) {
-                context.resourceContext
-            } else {
-                context.bytecodeContext.apply {
-                    val bytecodePatch = patchInstance as BytecodePatch
-                    bytecodePatch.fingerprints?.resolveUsingLookupMap(context.bytecodeContext)
-                }
-            }
-
-            logger.trace("Executing '$patchName' of type: ${if (isResourcePatch) "resource" else "bytecode"}")
-
-            var success = false
-            try {
-                patchInstance.execute(patchContext)
-
-                success = true
-            } catch (patchException: PatchException) {
-                throw patchException
-            } catch (throwable: Throwable) {
-                throw PatchException("Unhandled patch exception: ${throwable.message}", throwable)
-            } finally {
-                executedPatches[patchName] = ExecutedPatch(patchInstance, success)
-            }
-        }
-
-        if (context.integrations.merge) context.integrations.merge(logger)
-
-        logger.trace("Initialize lookup maps for method MethodFingerprint resolution")
-
-        MethodFingerprint.initializeFingerprintResolutionLookupMaps(context.bytecodeContext)
-
-        logger.info("Executing patches")
-
-        // Key is patch name.
-        LinkedHashMap<String, ExecutedPatch>().apply {
-            context.patches.forEach { patch ->
-                var exception: PatchException? = null
-
-                try {
-                    executePatch(patch, this)
-                } catch (patchException: PatchException) {
-                    exception = patchException
-                }
-
-                // TODO: only emit if the patch is not a closeable.
-                //  If it is a closeable, this should be done when closing the patch.
-                emit(patch.patchName to exception)
-
-                if (stopOnError && exception != null) return@flow
-            }
-        }.let {
-            it.values
-                .filter(ExecutedPatch::success)
-                .map(ExecutedPatch::patchInstance)
-                .filterIsInstance(Closeable::class.java)
-                .asReversed().forEach { patch ->
-                    try {
-                        patch.close()
-                    } catch (throwable: Throwable) {
-                        val patchException =
-                            if (throwable is PatchException) throwable
-                            else PatchException(throwable)
-
-                        val patchName = (patch as Patch<Context>).javaClass.patchName
-
-                        logger.error("Failed to close '$patchName': ${patchException.stackTraceToString()}")
-
-                        emit(patchName to patchException)
-
-                        // This is not failsafe. If a patch throws an exception while closing,
-                        // the other patches that depend on it may fail.
-                        if (stopOnError) return@flow
-                    }
-                }
-        }
-
-        MethodFingerprint.clearFingerprintResolutionLookupMaps()
-    }
-
-    /**
-     * Finish patching all [Apk]s.
-     *
-     * @return The [PatcherResult] of the [Patcher].
-     */
-    fun finish(): PatcherResult {
-        val patchResults = buildList {
-            logger.info("Processing patched apks")
-            options.apkBundle.cleanup(options).forEach { result ->
-                if (result.exception != null) {
-                    logger.error("Got exception while processing ${result.apk}: ${result.exception.stackTraceToString()}")
-                    return@forEach
-                }
-
-                val patch = result.let {
-                    when (it.apk) {
-                        is Apk.Base -> PatcherResult.Patch.Base(it.apk)
-                        is Apk.Split -> PatcherResult.Patch.Split(it.apk)
-                    }
-                }
-
-                add(patch)
-
-                logger.info("Patched ${result.apk}")
-            }
-        }
-
-        return PatcherResult(patchResults)
-    }
-}
-
-/**
- * A result of executing a [Patch].
- *
- * @param patchInstance The instance of the [Patch] that was executed.
- * @param success The result of the [Patch].
- */
-internal data class ExecutedPatch(val patchInstance: Patch<Context>, val success: Boolean)

revanced-patcher/src/main/kotlin/app/revanced/patcher/PatcherContext.kt

@@ -1,55 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.logging.Logger
-import app.revanced.patcher.patch.PatchClass
-import app.revanced.patcher.util.ClassMerger.merge
-import lanchon.multidexlib2.MultiDexIO
-import java.io.File
-
-class PatcherContext(
-    options: PatcherOptions,
-    internal val patches: List<PatchClass>,
-    integrations: Iterable<File>
-) {
-    internal val integrations = Integrations(this, integrations)
-    internal val bytecodeContext = BytecodeContext(options.apkBundle)
-    internal val resourceContext = ResourceContext(options.apkBundle)
-
-    internal class Integrations(val context: PatcherContext, private val dexContainers: Iterable<File>) {
-        var merge = false
-
-        /**
-         * Merge integrations.
-         * @param logger A logger.
-         */
-        fun merge(logger: Logger) {
-            context.bytecodeContext.classes.apply {
-                for (integrations in dexContainers) {
-                    logger.info("Merging $integrations")
-
-                    for (classDef in MultiDexIO.readDexFile(true, integrations, Patcher.dexFileNamer, null, null).classes) {
-                        val type = classDef.type
-
-                        val existingClassIndex = this.indexOfFirst { it.type == type }
-                        if (existingClassIndex == -1) {
-                            logger.trace("Merging type $type")
-                            add(classDef)
-                            continue
-                        }
-
-
-                        logger.trace("Type $type exists. Adding missing methods and fields.")
-
-                        get(existingClassIndex).apply {
-                            merge(classDef, context.bytecodeContext, logger).let { mergedClass ->
-                                if (mergedClass !== this) // referential equality check
-                                    set(existingClassIndex, mergedClass)
-                            }
-                        }
-
-                    }
-                }
-            }
-        }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/PatcherOptions.kt

@@ -1,14 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.apk.ApkBundle
-import app.revanced.patcher.logging.Logger
-
-/**
- * Options for the [Patcher].
- * @param apkBundle The [ApkBundle].
- * @param logger Custom logger implementation for the [Patcher].
- */
-class PatcherOptions(
-    internal val apkBundle: ApkBundle,
-    internal val logger: Logger = Logger.Nop
-)

revanced-patcher/src/main/kotlin/app/revanced/patcher/PatcherResult.kt

@@ -1,33 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.apk.Apk
-import java.io.File
-
-/**
- * The result of a patcher.
- * @param apkFiles The patched [Apk] files.
- */
-data class PatcherResult(val apkFiles: List<Patch>) {
-
-    /**
-     * The result of a patch.
-     *
-     * @param apk The patched [Apk] file.
-     */
-    sealed class Patch(val apk: Apk) {
-
-        /**
-         * The result of a patch of an [Apk.Split] file.
-         *
-         * @param apk The patched [Apk.Split] file.
-         */
-        class Split(apk: Apk.Split) : Patch(apk)
-
-        /**
-         * The result of a patch of an [Apk.Split] file.
-         *
-         * @param apk The patched [Apk.Base] file.
-         */
-        class Base(apk: Apk.Base) : Patch(apk)
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/apk/ApkBundle.kt

@@ -1,105 +0,0 @@
-@file:Suppress("MemberVisibilityCanBePrivate")
-
-package app.revanced.patcher.apk
-
-import app.revanced.arsc.ApkResourceException
-import app.revanced.arsc.resource.ResourceTable
-import app.revanced.patcher.Patcher
-import app.revanced.patcher.PatcherOptions
-import app.revanced.patcher.apk.Apk.Companion.identify
-import com.reandroid.apk.ApkModule
-import java.io.File
-
-/**
- * An [Apk] file of type [Apk.Split].
- *
- * @param files A list of apk files to load.
- */
-class ApkBundle(files: List<File>) : Sequence<Apk> {
-    /**
-     * The [Apk.Base] of this [ApkBundle].
-     */
-    val base: Apk.Base
-
-    /**
-     * A map containing all the [Apk.Split]s in this bundle associated by their configuration.
-     */
-    val splits: Map<String, Apk.Split>?
-
-    init {
-        var baseApk: Apk.Base? = null
-
-        splits = buildMap {
-            files.forEach {
-                val apk = ApkModule.loadApkFile(it)
-                val (module, type) = apk.identify()
-                if (module is Apk.Module.DynamicFeature) {
-                    return@forEach // Dynamic feature modules are not supported yet.
-                }
-
-                when (type) {
-                    Apk.Type.Base -> {
-                        if (baseApk != null) {
-                            throw IllegalArgumentException("Cannot have more than one base apk")
-                        }
-                        baseApk = Apk.Base(apk)
-                    }
-
-                    is Apk.Type.SplitConfig -> {
-                        val target = type.target
-                        if (this.contains(target)) {
-                            throw IllegalArgumentException("Duplicate split: $target")
-                        }
-
-                        val constructor = when (type) {
-                            is Apk.Type.Asset -> Apk.Split::Asset
-                            is Apk.Type.Library -> Apk.Split::Library
-                            is Apk.Type.Language -> Apk.Split::Language
-                        }
-
-                        this[target] = constructor(target, apk)
-                    }
-                }
-            }
-        }.takeIf { it.isNotEmpty() }
-
-        base = baseApk ?: throw IllegalArgumentException("Base apk not found")
-    }
-
-    /**
-     * The [ResourceTable] of this [ApkBundle].
-     */
-    val resources = ResourceTable(base.resources, map { it.resources })
-
-    override fun iterator() = sequence {
-        yield(base)
-        splits?.values?.let {
-            yieldAll(it)
-        }
-    }.iterator()
-
-    /**
-     * Refresh all updated resources in an [ApkBundle].
-     *
-     * @param options The [PatcherOptions] of the [Patcher].
-     * @return A sequence of the [Apk] files which are being refreshed.
-     */
-    internal fun cleanup(options: PatcherOptions) = map {
-        var exception: ApkResourceException? = null
-        try {
-            it.cleanup(options)
-        } catch (e: ApkResourceException) {
-            exception = e
-        }
-
-        SplitApkResult(it, exception)
-    }
-
-    /**
-     * The result of writing an [Apk] file.
-     *
-     * @param apk The corresponding [Apk] file.
-     * @param exception The optional [ApkResourceException] when an exception occurred.
-     */
-    data class SplitApkResult(val apk: Apk, val exception: ApkResourceException? = null)
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/logging/Logger.kt

@@ -1,20 +0,0 @@
-package app.revanced.patcher.logging
-
-interface Logger {
-    fun error(msg: String) {}
-    fun warn(msg: String) {}
-    fun info(msg: String) {}
-    fun trace(msg: String) {}
-
-    object Nop : Logger
-}
-
-/**
- * Turn a Patcher [Logger] into an [app.revanced.arsc.logging.Logger].
- */
-internal fun Logger.asArscLogger() = object : app.revanced.arsc.logging.Logger {
-    override fun error(msg: String) = this@asArscLogger.error(msg)
-    override fun warn(msg: String) = this@asArscLogger.warn(msg)
-    override fun info(msg: String) = this@asArscLogger.info(msg)
-    override fun trace(msg: String) = this@asArscLogger.error(msg)
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/PatchException.kt

@@ -1,12 +0,0 @@
-package app.revanced.patcher.patch
-
-/**
- * An exception thrown when patching.
- *
- * @param errorMessage The exception message.
- * @param cause The corresponding [Throwable].
- */
-class PatchException(errorMessage: String?, cause: Throwable?) : Exception(errorMessage, cause) {
-    constructor(errorMessage: String) : this(errorMessage, null)
-    constructor(cause: Throwable) : this(cause.message, cause)
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/util/ProxyBackedClassList.kt

@@ -1,89 +0,0 @@
-package app.revanced.patcher.util
-
-import app.revanced.patcher.util.proxy.ClassProxy
-import org.jf.dexlib2.iface.ClassDef
-
-/**
- * A class that represents a list of classes and proxies.
- *
- * @param classes The classes to be backed by proxies.
- */
-class ProxyBackedClassList(classes: Set<ClassDef>) : Iterable<ClassDef> {
-    // A list for pending proxied classes to be added to the current ProxyBackedClassList instance.
-    private val proxiedClasses = mutableListOf<ClassProxy>()
-    private val mutableClasses = classes.toMutableList()
-
-    /**
-     * Replace the [mutableClasses]es with their proxies.
-     */
-    internal fun applyProxies() {
-        proxiedClasses.removeIf { proxy ->
-            // If the proxy is unused, keep it in the proxiedClasses list.
-            if (!proxy.resolved) return@removeIf false
-
-            with(mutableClasses) {
-                remove(proxy.immutableClass)
-                add(proxy.mutableClass)
-            }
-
-            return@removeIf true
-        }
-    }
-
-    /**
-     * Replace a [ClassDef] at a given [index].
-     *
-     * @param index The index of the class to be replaced.
-     * @param classDef The new class to replace the old one.
-     */
-    operator fun set(index: Int, classDef: ClassDef) {
-        mutableClasses[index] = classDef
-    }
-
-    /**
-     * Get a [ClassDef] at a given [index].
-     *
-     * @param index The index of the class.
-     */
-    operator fun get(index: Int) = mutableClasses[index]
-
-    /**
-     * Iterator for the classes in [ProxyBackedClassList].
-     *
-     * @return The iterator for the classes.
-     */
-    override fun iterator() = mutableClasses.iterator()
-
-    /**
-     * Proxy a [ClassDef].
-     *
-     * Note: This creates a [ClassProxy] of the [ClassDef], if not already present.
-     *
-     * @return A proxy for the given class.
-     */
-    fun proxy(classDef: ClassDef) = proxiedClasses
-        .find { it.immutableClass.type == classDef.type } ?: ClassProxy(classDef).also(proxiedClasses::add)
-
-    /**
-     * Add a [ClassDef].
-     */
-    fun add(classDef: ClassDef) = mutableClasses.add(classDef)
-
-    /**
-     * Find a class by a given class name.
-     *
-     * @param className The name of the class.
-     * @return A proxy for the first class that matches the class name.
-     */
-    fun findClassProxied(className: String) = findClassProxied { it.type.contains(className) }
-
-    /**
-     * Find a class by a given predicate.
-     *
-     * @param predicate A predicate to match the class.
-     * @return A proxy for the first class that matches the predicate.
-     */
-    fun findClassProxied(predicate: (ClassDef) -> Boolean) = this.find(predicate)?.let(::proxy)
-
-    val size get() = mutableClasses.size
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/util/TypeUtil.kt

@@ -1,19 +0,0 @@
-package app.revanced.patcher.util
-
-import app.revanced.patcher.BytecodeContext
-import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
-
-object TypeUtil {
-    /**
-     * Traverse the class hierarchy starting from the given root class.
-     *
-     * @param targetClass The class to start traversing the class hierarchy from.
-     * @param callback The function that is called for every class in the hierarchy.
-     */
-    fun BytecodeContext.traverseClassHierarchy(targetClass: MutableClass, callback: MutableClass.() -> Unit) {
-        callback(targetClass)
-        this.classes.findClassProxied(targetClass.superclass ?: return)?.mutableClass?.let {
-            traverseClassHierarchy(it, callback)
-        }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/util/VersionReader.kt

@@ -1,19 +0,0 @@
-package app.revanced.patcher.util
-
-import java.util.*
-
-@Deprecated("This class serves no purpose anymore")
-internal object VersionReader {
-    @JvmStatic
-    private val properties = Properties().apply {
-        load(
-            VersionReader::class.java.getResourceAsStream("/app/revanced/patcher/version.properties")
-                ?: throw IllegalStateException("Could not load version.properties")
-        )
-    }
-
-    @JvmStatic
-    fun read(): String {
-        return properties.getProperty("version") ?: throw IllegalStateException("Version not found")
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/util/patch/PatchBundle.kt

@@ -1,59 +0,0 @@
-@file:Suppress("unused")
-
-package app.revanced.patcher.util.patch
-
-import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.PatchClass
-import dalvik.system.PathClassLoader
-import org.jf.dexlib2.DexFileFactory
-import java.io.File
-import java.net.URLClassLoader
-import java.util.jar.JarFile
-import kotlin.streams.toList
-
-/**
- * A patch bundle.
- *
- * @param fromClasses The classes to get [Patch]es from.
- */
-sealed class PatchBundle private constructor(fromClasses: Iterable<Class<*>>) : Iterable<PatchClass> {
-    private val patches = fromClasses.filter {
-        if (it.isAnnotation) return@filter false
-
-        it.findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class) != null
-    }.map {
-        @Suppress("UNCHECKED_CAST")
-        it as PatchClass
-    }
-
-    override fun iterator() = patches.iterator()
-
-    /**
-     * A patch bundle of type [Jar].
-     *
-     * @param patchBundlePath The path to a patch bundle.
-     */
-    class Jar(private val patchBundlePath: File) : PatchBundle(
-        with(URLClassLoader(arrayOf(patchBundlePath.toURI().toURL()), PatchBundle::class.java.classLoader)) {
-            JarFile(patchBundlePath).stream().filter { it.name.endsWith(".class") }.map {
-                loadClass(
-                    it.realName.replace('/', '.').replace(".class", "")
-                )
-            }.toList()
-        }
-    )
-
-    /**
-     * A patch bundle of type [Dex] format.
-     *
-     * @param patchBundlePath The path to a patch bundle of dex format.
-     */
-    class Dex(private val patchBundlePath: File) : PatchBundle(
-        with(PathClassLoader(patchBundlePath.absolutePath, null, PatchBundle::class.java.classLoader)) {
-            DexFileFactory.loadDexFile(patchBundlePath, null).classes.map { classDef ->
-                classDef.type.substring(1, classDef.length - 1).replace('/', '.')
-            }.map { loadClass(it) }
-        }
-    )
-}

settings.gradle.kts

@@ -1,28 +1 @@
-pluginManagement {
+rootProject.name = "revanced-patcher"
-    repositories {
-        mavenCentral()
-        maven {
-            url = uri("https://maven.pkg.github.com/revanced/multidexlib2")
-            credentials {
-                username = providers.gradleProperty("gpr.user").orNull ?: System.getenv("GITHUB_ACTOR")
-                password = providers.gradleProperty("gpr.key").orNull ?: System.getenv("GITHUB_TOKEN")
-            }
-        }
-    }
-}
-
-dependencyResolutionManagement {
-    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
-    repositories {
-        mavenCentral()
-        maven {
-            url = uri("https://maven.pkg.github.com/revanced/multidexlib2")
-            credentials {
-                username = providers.gradleProperty("gpr.user").orNull ?: System.getenv("GITHUB_ACTOR")
-                password = providers.gradleProperty("gpr.key").orNull ?: System.getenv("GITHUB_TOKEN")
-            }
-        }
-    }
-}
-
-include("revanced-patcher", "arsclib-utils")

src/main/kotlin/app/revanced/patcher/PatcherContext.kt

@@ -0,0 +1,64 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.data.*
+import app.revanced.patcher.logging.Logger
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.util.ClassMerger.merge
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import java.io.File
+
+data class PatcherContext(
+    val classes: MutableList<ClassDef>,
+    val resourceCacheDirectory: File,
+) {
+    val packageMetadata = PackageMetadata()
+    internal val patches = mutableListOf<Class<out Patch<Context>>>()
+    internal val integrations = Integrations(this)
+    internal val bytecodeContext = BytecodeContext(classes)
+    internal val resourceContext = ResourceContext(resourceCacheDirectory)
+
+    internal class Integrations(val context: PatcherContext) {
+        var callback: ((File) -> Unit)? = null
+        private val integrations: MutableList<File> = mutableListOf()
+
+        fun add(integrations: List<File>) = this@Integrations.integrations.addAll(integrations)
+
+        /**
+         * Merge integrations.
+         * @param logger A logger.
+         */
+        fun merge(logger: Logger) {
+            with(context.bytecodeContext.classes) {
+                for (integrations in integrations) {
+                    callback?.let { it(integrations) }
+
+                    for (classDef in lanchon.multidexlib2.MultiDexIO.readDexFile(
+                        true,
+                        integrations,
+                        NAMER,
+                        null,
+                        null
+                    ).classes) {
+                        val type = classDef.type
+
+                        val result = classes.findIndexed { it.type == type }
+                        if (result == null) {
+                            logger.trace("Merging type $type")
+                            classes.add(classDef)
+                            continue
+                        }
+
+                        val (existingClass, existingClassIndex) = result
+
+                        logger.trace("Type $type exists. Adding missing methods and fields.")
+
+                        existingClass.merge(classDef, context, logger).let { mergedClass ->
+                            if (mergedClass !== existingClass) // referential equality check
+                                classes[existingClassIndex] = mergedClass
+                        }
+                    }
+                }
+            }
+        }
+    }
+}