refactor!: restructure code

This commit focuses on improving code quality in a couple of places and bumping the dependency to ReVanced Patcher.

BREAKING CHANGE: This introduces major changes to how ReVanced CLI is used from the command line.

src/main/kotlin/app/revanced/utils/adb/Adb.kt

@@ -1,113 +0,0 @@
-package app.revanced.utils.adb
-
-import app.revanced.cli.command.MainCommand.logger
-import se.vidstige.jadb.JadbConnection
-import se.vidstige.jadb.JadbDevice
-import se.vidstige.jadb.managers.PackageManager
-import java.io.File
-import java.util.concurrent.Executors
-
-internal class Adb(
-    private val file: File,
-    private val packageName: String,
-    deviceName: String,
-    private val install: Boolean = false,
-    private val logging: Boolean = true
-) {
-    private val device: JadbDevice
-
-    init {
-        device = JadbConnection().devices.let { device -> device.find { it.serial == deviceName } ?: device.first() }
-            ?: throw IllegalArgumentException("No such device with name $deviceName")
-
-        if (!install && device.run("su -h", false) != 0)
-            throw IllegalArgumentException("Root required on $deviceName. Task failed")
-    }
-
-    private fun String.replacePlaceholder(with: String? = null): String {
-        return this.replace(Constants.PLACEHOLDER, with ?: packageName)
-    }
-
-    internal fun deploy() {
-        if (install) {
-            logger.info("Installing without mounting")
-
-            PackageManager(device).install(file)
-        } else {
-            logger.info("Installing by mounting")
-
-            // push patched file
-            device.copy(Constants.PATH_INIT_PUSH, file)
-
-            // create revanced folder path
-            device.run("${Constants.COMMAND_CREATE_DIR} ${Constants.PATH_REVANCED}")
-
-            // prepare mounting the apk
-            device.run(Constants.COMMAND_PREPARE_MOUNT_APK.replacePlaceholder())
-
-            // push mount script
-            device.createFile(
-                Constants.PATH_INIT_PUSH,
-                Constants.CONTENT_MOUNT_SCRIPT.replacePlaceholder()
-            )
-            // install mount script
-            device.run(Constants.COMMAND_INSTALL_MOUNT.replacePlaceholder())
-
-            // unmount the apk for sanity
-            device.run(Constants.COMMAND_UMOUNT.replacePlaceholder())
-            // mount the apk
-            device.run(Constants.PATH_MOUNT.replacePlaceholder())
-
-            // relaunch app
-            device.run(Constants.COMMAND_RESTART.replacePlaceholder())
-
-            // log the app
-            log()
-        }
-    }
-
-    internal fun uninstall() {
-        logger.info("Uninstalling by unmounting")
-
-        // unmount the apk
-        device.run(Constants.COMMAND_UMOUNT.replacePlaceholder())
-
-        // delete revanced app
-        device.run(Constants.COMMAND_DELETE.replacePlaceholder(Constants.PATH_REVANCED_APP).replacePlaceholder())
-
-        // delete mount script
-        device.run(Constants.COMMAND_DELETE.replacePlaceholder(Constants.PATH_MOUNT).replacePlaceholder())
-
-        logger.info("Finished uninstalling")
-    }
-
-    private fun log() {
-        val executor = Executors.newSingleThreadExecutor()
-        val pipe = if (logging) {
-            ProcessBuilder.Redirect.INHERIT
-        } else {
-            ProcessBuilder.Redirect.PIPE
-        }
-
-        val process = device.buildCommand(Constants.COMMAND_LOGCAT.replacePlaceholder())
-            .redirectOutput(pipe)
-            .redirectError(pipe)
-            .useExecutor(executor)
-            .start()
-
-        Thread.sleep(500) // give the app some time to start up.
-        while (true) {
-            try {
-                while (device.run("${Constants.COMMAND_PID_OF} $packageName") == 0) {
-                    Thread.sleep(1000)
-                }
-                break
-            } catch (e: Exception) {
-                throw RuntimeException("An error occurred while monitoring the state of app", e)
-            }
-        }
-        logger.info("Stopped logging because the app was closed")
-        process.destroy()
-        executor.shutdown()
-    }
-}

src/main/kotlin/app/revanced/utils/adb/AdbManager.kt

@@ -0,0 +1,130 @@
+package app.revanced.utils.adb
+
+import app.revanced.cli.logging.CliLogger
+import app.revanced.utils.adb.AdbManager.Apk
+import app.revanced.utils.adb.Constants.COMMAND_CREATE_DIR
+import app.revanced.utils.adb.Constants.COMMAND_DELETE
+import app.revanced.utils.adb.Constants.COMMAND_INSTALL_MOUNT
+import app.revanced.utils.adb.Constants.COMMAND_PREPARE_MOUNT_APK
+import app.revanced.utils.adb.Constants.COMMAND_RESTART
+import app.revanced.utils.adb.Constants.COMMAND_UMOUNT
+import app.revanced.utils.adb.Constants.CONTENT_MOUNT_SCRIPT
+import app.revanced.utils.adb.Constants.PATH_INIT_PUSH
+import app.revanced.utils.adb.Constants.PATH_INSTALLATION
+import app.revanced.utils.adb.Constants.PATH_MOUNT
+import app.revanced.utils.adb.Constants.PATH_PATCHED_APK
+import app.revanced.utils.adb.Constants.PLACEHOLDER
+import se.vidstige.jadb.JadbConnection
+import se.vidstige.jadb.managers.Package
+import se.vidstige.jadb.managers.PackageManager
+import java.io.Closeable
+import java.io.File
+
+/**
+ * Adb manager. Used to install and uninstall [Apk] files.
+ *
+ * @param deviceSerial The serial of the device.
+ */
+internal sealed class AdbManager(deviceSerial: String? = null, protected val logger: CliLogger? = null) : Closeable {
+    protected val device = JadbConnection().devices.find { device -> device.serial == deviceSerial }
+        ?: throw IllegalArgumentException("The device with the serial $deviceSerial can not be found.")
+
+    init {
+        logger?.trace("Established connection to $deviceSerial")
+    }
+
+    /**
+     * Installs the [Apk] file.
+     *
+     * @param apk The [Apk] file.
+     */
+    open fun install(apk: Apk) {
+        logger?.info("Finished installing ${apk.file.name}")
+    }
+
+    /**
+     * Uninstalls the package.
+     *
+     * @param packageName The package name.
+     */
+    open fun uninstall(packageName: String) {
+        logger?.info("Finished uninstalling $packageName")
+    }
+
+    /**
+     * Closes the [AdbManager] instance.
+     */
+    override fun close() {
+        logger?.trace("Closed")
+    }
+
+    class RootAdbManager(deviceSerial: String, logger: CliLogger? = null) : AdbManager(deviceSerial, logger) {
+        init {
+            if (!device.hasSu()) throw IllegalArgumentException("Root required on $deviceSerial. Task failed")
+        }
+
+        override fun install(apk: Apk) {
+            logger?.info("Installing by mounting")
+
+            val applyReplacement = getPlaceholderReplacement(
+                apk.packageName ?: throw IllegalArgumentException("Package name is required")
+            )
+
+            device.copyFile(apk.file, PATH_INIT_PUSH)
+
+            device.run("$COMMAND_CREATE_DIR $PATH_INSTALLATION")
+            device.run(COMMAND_PREPARE_MOUNT_APK.applyReplacement())
+
+            device.createFile(PATH_INIT_PUSH, CONTENT_MOUNT_SCRIPT.applyReplacement())
+
+            device.run(COMMAND_INSTALL_MOUNT.applyReplacement())
+            device.run(COMMAND_UMOUNT.applyReplacement()) // Sanity check.
+            device.run(PATH_MOUNT.applyReplacement())
+            device.run(COMMAND_RESTART.applyReplacement())
+
+            super.install(apk)
+        }
+
+        override fun uninstall(packageName: String) {
+            logger?.info("Uninstalling $packageName by unmounting and deleting the package")
+
+            val applyReplacement = getPlaceholderReplacement(packageName)
+
+            device.run(COMMAND_UMOUNT.applyReplacement(packageName))
+            device.run(COMMAND_DELETE.applyReplacement(PATH_PATCHED_APK).applyReplacement())
+            device.run(COMMAND_DELETE.applyReplacement(PATH_MOUNT).applyReplacement())
+
+            super.uninstall(packageName)
+        }
+
+        companion object Utils {
+            private fun getPlaceholderReplacement(with: String): String.() -> String = { replace(PLACEHOLDER, with) }
+            private fun String.applyReplacement(with: String) = replace(PLACEHOLDER, with)
+        }
+    }
+
+    class UserAdbManager(deviceSerial: String, logger: CliLogger? = null) : AdbManager(deviceSerial, logger) {
+        private val packageManager = PackageManager(device)
+
+        override fun install(apk: Apk) {
+            PackageManager(device).install(apk.file)
+
+            super.install(apk)
+        }
+
+        override fun uninstall(packageName: String) {
+            logger?.info("Uninstalling $packageName")
+
+            packageManager.uninstall(Package(packageName))
+
+            super.uninstall(packageName)
+        }
+    }
+
+    /**
+     * Apk file for [AdbManager].
+     *
+     * @param file The [Apk] file.
+     */
+    internal class Apk(val file: File, val packageName: String? = null)
+}

src/main/kotlin/app/revanced/utils/adb/Commands.kt

@@ -2,28 +2,28 @@ package app.revanced.utils.adb
 
 import se.vidstige.jadb.JadbDevice
 import se.vidstige.jadb.RemoteFile
-import se.vidstige.jadb.ShellProcessBuilder
 import java.io.File
+import java.util.concurrent.Callable
+import java.util.concurrent.Executors
 
-internal fun JadbDevice.buildCommand(command: String, su: Boolean = true): ShellProcessBuilder {
-    if (su) {
-        return shellProcessBuilder("su -c \'$command\'")
+// return the input or output stream, depending on which first returns a value
+internal fun JadbDevice.run(command: String, su: Boolean = false) = with(this.startCommand(command, su)) {
+    Executors.newFixedThreadPool(2).let { service ->
+        arrayOf(inputStream, errorStream).map { stream ->
+            Callable { stream.bufferedReader().use { it.readLine() } }
+        }.let { tasks -> service.invokeAny(tasks).also { service.shutdown() } }
     }
-
-    val args = command.split(" ") as ArrayList<String>
-    val cmd = args.removeFirst()
-
-    return shellProcessBuilder(cmd, *args.toTypedArray())
 }
 
-internal fun JadbDevice.run(command: String, su: Boolean = true): Int {
-    return this.buildCommand(command, su).start().waitFor()
-}
+internal fun JadbDevice.hasSu() =
+    this.startCommand("su -h", false).waitFor() == 0
 
-internal fun JadbDevice.copy(targetPath: String, file: File) {
-    push(file, RemoteFile(targetPath))
-}
+internal fun JadbDevice.copyFile(file: File, targetFile: String) =
+    push(file, RemoteFile(targetFile))
 
-internal fun JadbDevice.createFile(targetFile: String, content: String) {
+internal fun JadbDevice.createFile(targetFile: String, content: String) =
     push(content.byteInputStream(), System.currentTimeMillis(), 644, RemoteFile(targetFile))
-}
+
+
+private fun JadbDevice.startCommand(command: String, su: Boolean) =
+    shellProcessBuilder(if (su) "su -c '$command'" else command).start()

src/main/kotlin/app/revanced/utils/adb/Constants.kt

@@ -1,57 +1,40 @@
 package app.revanced.utils.adb
 
 internal object Constants {
-    // template placeholder to replace a string in commands
     internal const val PLACEHOLDER = "TEMPLATE_PACKAGE_NAME"
 
-    // utility commands
-    private const val COMMAND_CHMOD_MOUNT = "chmod +x"
-    internal const val COMMAND_PID_OF = "pidof -s"
-    internal const val COMMAND_CREATE_DIR = "mkdir -p"
-    internal const val COMMAND_LOGCAT = "logcat -c && logcat | grep AndroidRuntime"
-    internal const val COMMAND_RESTART = "pm resolve-activity --brief $PLACEHOLDER | tail -n 1 | xargs am start -n && kill ${'$'}($COMMAND_PID_OF $PLACEHOLDER)"
-
-    // default mount file name
-    private const val NAME_MOUNT_SCRIPT = "mount_revanced_$PLACEHOLDER.sh"
-
-    // initial directory to push files to via adb push
     internal const val PATH_INIT_PUSH = "/data/local/tmp/revanced.delete"
+    internal const val PATH_INSTALLATION = "/data/adb/revanced/"
+    internal const val PATH_PATCHED_APK = "$PATH_INSTALLATION$PLACEHOLDER.apk"
+    internal const val PATH_MOUNT = "/data/adb/service.d/mount_revanced_$PLACEHOLDER.sh"
 
-    // revanced path
-    internal const val PATH_REVANCED = "/data/adb/revanced/"
-
-    // revanced apk path
-    internal const val PATH_REVANCED_APP = "$PATH_REVANCED$PLACEHOLDER.apk"
-
-    // delete command
     internal const val COMMAND_DELETE = "rm -rf $PLACEHOLDER"
+    internal const val COMMAND_CREATE_DIR = "mkdir -p"
+    internal const val COMMAND_RESTART = "pm resolve-activity --brief $PLACEHOLDER | tail -n 1 | " +
+            "xargs am start -n && kill ${'$'}(pidof -s $PLACEHOLDER)"
 
-    // mount script path
-    internal const val PATH_MOUNT = "/data/adb/service.d/$NAME_MOUNT_SCRIPT"
+    internal const val COMMAND_PREPARE_MOUNT_APK = "base_path=\"$PATH_PATCHED_APK\" && " +
+            "mv $PATH_INIT_PUSH ${'$'}base_path && " +
+            "chmod 644 ${'$'}base_path && " +
+            "chown system:system ${'$'}base_path && " +
+            "chcon u:object_r:apk_data_file:s0  ${'$'}base_path"
 
-    // move to revanced apk path & set permissions
-    internal const val COMMAND_PREPARE_MOUNT_APK =
-        "base_path=\"$PATH_REVANCED_APP\" && mv $PATH_INIT_PUSH ${'$'}base_path && chmod 644 ${'$'}base_path && chown system:system ${'$'}base_path && chcon u:object_r:apk_data_file:s0  ${'$'}base_path"
-
-    // unmount command
     internal const val COMMAND_UMOUNT =
         "grep $PLACEHOLDER /proc/mounts | while read -r line; do echo ${'$'}line | cut -d \" \" -f 2 | sed 's/apk.*/apk/' | xargs -r umount -l; done"
 
-    // install mount script & set permissions
-    internal const val COMMAND_INSTALL_MOUNT = "mv $PATH_INIT_PUSH $PATH_MOUNT && $COMMAND_CHMOD_MOUNT $PATH_MOUNT"
+    internal const val COMMAND_INSTALL_MOUNT = "mv $PATH_INIT_PUSH $PATH_MOUNT && chmod +x $PATH_MOUNT"
 
-    // mount script
-    internal val CONTENT_MOUNT_SCRIPT =
+    internal const val CONTENT_MOUNT_SCRIPT =
         """
             #!/system/bin/sh
             MAGISKTMP="${'$'}(magisk --path)" || MAGISKTMP=/sbin
             MIRROR="${'$'}MAGISKTMP/.magisk/mirror"
             while [ "${'$'}(getprop sys.boot_completed | tr -d '\r')" != "1" ]; do sleep 1; done
             
-            base_path="$PATH_REVANCED_APP"
+            base_path="$PATH_PATCHED_APK"
             stock_path=${'$'}( pm path $PLACEHOLDER | grep base | sed 's/package://g' )
 
             chcon u:object_r:apk_data_file:s0  ${'$'}base_path
             mount -o bind ${'$'}MIRROR${'$'}base_path ${'$'}stock_path
-        """.trimIndent()
+        """
 }

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

@@ -1,75 +0,0 @@
-package app.revanced.utils.patcher
-
-import app.revanced.cli.command.MainCommand.args
-import app.revanced.cli.command.MainCommand.logger
-import app.revanced.cli.command.PatchList
-import app.revanced.patcher.Patcher
-import app.revanced.patcher.data.Context
-import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
-import app.revanced.patcher.extensions.PatchExtensions.include
-import app.revanced.patcher.extensions.PatchExtensions.patchName
-import app.revanced.patcher.patch.Patch
-
-fun Patcher.addPatchesFiltered(allPatches: PatchList) {
-    val packageName = this.context.packageMetadata.packageName
-    val packageVersion = this.context.packageMetadata.packageVersion
-
-    val includedPatches = mutableListOf<Class<out Patch<Context>>>()
-    allPatches.forEach patchLoop@{ patch ->
-        val compatiblePackages = patch.compatiblePackages
-        val args = args.patchArgs?.patchingArgs!!
-
-        val prefix = "Skipping ${patch.patchName}"
-
-        if (compatiblePackages == null) logger.trace("${patch.patchName}: No package constraints.")
-        else {
-            if (!compatiblePackages.any { it.name == packageName }) {
-                logger.trace("$prefix: Incompatible with $packageName. This patch is only compatible with ${
-                    compatiblePackages.joinToString(
-                        ", "
-                    ) { it.name }
-                }")
-                return@patchLoop
-            }
-
-            if (!(args.experimental || compatiblePackages.any { it.versions.isEmpty() || it.versions.any { version -> version == packageVersion } })) {
-                val compatibleWith = compatiblePackages.joinToString(";") { _package ->
-                    "${_package.name}: ${_package.versions.joinToString(", ")}"
-                }
-                logger.warn("$prefix: Incompatible with version $packageVersion. This patch is only compatible with $compatibleWith")
-                return@patchLoop
-            }
-        }
-
-        val kebabCasedPatchName = patch.patchName.lowercase().replace(" ", "-")
-        if (args.excludedPatches.contains(kebabCasedPatchName)) {
-            logger.info("$prefix: Manually excluded")
-            return@patchLoop
-        } else if ((!patch.include || args.exclusive) && !args.includedPatches.contains(kebabCasedPatchName)) {
-            logger.info("$prefix: Excluded by default")
-            return@patchLoop
-        }
-
-        logger.trace("Adding ${patch.patchName}")
-        includedPatches.add(patch)
-    }
-
-    this.addPatches(includedPatches)
-}
-
-fun Patcher.applyPatchesVerbose() {
-    this.executePatches().forEach { (patch, result) ->
-        if (result.isSuccess) {
-            logger.info("$patch succeeded")
-            return@forEach
-        }
-        logger.error("$patch failed:")
-        result.exceptionOrNull()!!.printStackTrace()
-    }
-}
-
-fun Patcher.mergeFiles() {
-    this.addIntegrations(args.patchArgs?.patchingArgs!!.mergeFiles) { file ->
-        logger.info("Merging $file")
-    }
-}