If debug mode is on, actually parcel the remote stacktrace so we get a full stacktrace across the process boundary.

Not super clean but just used in debug mode and I found no other way :8

Author: d4rken

app-common-io/src/main/java/eu/darken/sdmse/common/pkgs/PackageManagerExtensions.kt

@@ -53,7 +53,6 @@ fun PackageManager.getInstalledPackagesAsUser(
     userHandle: UserHandle2,
 ) = try {
     val functions = PackageManager::class.memberFunctions.filter { it.name == "getInstalledPackagesAsUser" }
-    throw RuntimeException("lol")
     if (hasApiLevel(33)) {
         @Suppress("NewApi")
         functions

app-common/src/main/java/eu/darken/sdmse/common/ipc/IpcClientModule.kt

@@ -1,21 +1,52 @@
 package eu.darken.sdmse.common.ipc
 
+import eu.darken.sdmse.common.debug.Bugs
+import eu.darken.sdmse.common.debug.logging.Logging.Priority.VERBOSE
 import eu.darken.sdmse.common.debug.logging.Logging.Priority.WARN
 import eu.darken.sdmse.common.debug.logging.log
+import java.io.ByteArrayInputStream
+import java.io.ObjectInputStream
+import kotlin.io.encoding.Base64
+import kotlin.io.encoding.ExperimentalEncodingApi
 
 interface IpcClientModule {
 
+    @OptIn(ExperimentalEncodingApi::class)
+    fun String.decodeStacktrace(): Array<StackTraceElement>? = try {
+        val decodedBytes = Base64.decode(this)
+        ObjectInputStream(ByteArrayInputStream(decodedBytes)).use {
+            it.readObject() as Array<StackTraceElement>
+        }
+    } catch (e: Exception) {
+        null
+    }
+
     fun Throwable.unwrapPropagation(): Throwable {
-        val matchResult = Regex("^[a-zA-Z0-9.]+Exception").find((message ?: ""))
-        val exceptionName = matchResult?.value ?: return this
-        val exceptionMessage = message!!.removePrefix("$exceptionName: ").trim()
+        val matchResult = Regex("^([a-zA-Z0-9.]+Exception): ").find((message ?: ""))
+        val exceptionName = matchResult?.groupValues?.get(1) ?: return this
+        val messageParts = message!!
+            .removePrefix(matchResult.groupValues.first())
+            .trim()
+            .split(IpcHostModule.STACK_MARKER)
 
         return try {
             Class.forName(exceptionName)
                 .asSubclass(Throwable::class.java)
                 .getConstructor(String::class.java)
-                .newInstance(exceptionMessage)
-                .also { it.stackTrace = this.stackTrace }
+                .newInstance(messageParts.first())
+                .also { newException ->
+                    //  TODO: Couldn't find a way to keep the trace through parceling
+                    // it.stackTrace = this.stackTrace
+                    if (Bugs.isDebug && messageParts.size > 1) {
+                        log(VERBOSE) { "Decoding stacktrace..." }
+                        messageParts[1].decodeStacktrace()?.let { remoteTrace ->
+                            // Stacktrace on this side of the binder + the stacktrace on the other side of it
+                            newException.stackTrace = (remoteTrace + stackTrace).filter {
+                                !it.className.startsWith("android.os.Binder") && !it.className.startsWith("android.os.Parcel")
+                            }.toTypedArray()
+                        }
+                    }
+                }
         } catch (e: Exception) {
             log(WARN) { "Failed to unwrap exception: $this" }
             this

app-common/src/main/java/eu/darken/sdmse/common/ipc/IpcHostModule.kt

@@ -1,7 +1,27 @@
 package eu.darken.sdmse.common.ipc
 
+import eu.darken.sdmse.common.debug.Bugs
+import eu.darken.sdmse.common.debug.logging.Logging.Priority.VERBOSE
+import eu.darken.sdmse.common.debug.logging.log
+import java.io.ByteArrayOutputStream
+import java.io.ObjectOutputStream
+import kotlin.io.encoding.Base64
+import kotlin.io.encoding.ExperimentalEncodingApi
+
 interface IpcHostModule {
 
+    @OptIn(ExperimentalEncodingApi::class)
+    fun Array<StackTraceElement>.encodeBase64(): String? = try {
+        val baos = ByteArrayOutputStream()
+        ObjectOutputStream(baos).use {
+            it.writeObject(this)
+        }
+        Base64.encode(baos.toByteArray())
+    } catch (e: Exception) {
+        null
+    }
+
+
     // Not all exception can be passed through the binder
     // See Parcel.writeException(...)
     fun Throwable.wrapToPropagate(): Exception {
@@ -11,9 +31,20 @@ interface IpcHostModule {
             msgBuilder.append("\nCaused by: ")
             msgBuilder.append(it.toString())
         }
-        return UnsupportedOperationException(msgBuilder.toString()).also {
-            it.stackTrace = this.stackTrace
-            // The stacktrace is still lost and not encoded for some reason...
+
+        if (Bugs.isDebug) {
+            log(VERBOSE) { "Encoding stacktrace..." }
+            // TODO Find better way to pass trace, see IpcClientModule
+            val encodedTrace = stackTrace.encodeBase64()
+            if (encodedTrace != null) {
+                msgBuilder.append(STACK_MARKER).append(encodedTrace)
+            }
         }
+
+        return UnsupportedOperationException(msgBuilder.toString())
+    }
+
+    companion object {
+        const val STACK_MARKER = "\n\n#STACK#:"
     }
 }