for (receiver in receivers) {
            val key = "${receiver.packageName}/${receiver.receiverName}"
            states[key] = receiver.isEnabled
        }

package wspdyb.bootcommander

import java.util.LinkedHashMap


object BackupManager {

    private var lastSnapshot: BackupSnapshot? = null

    fun saveSnapshot(receivers: List<BootReceiverInfo>) {

        val states = LinkedHashMap<String, Boolean>()

        for (receiver in receivers) {
            val key = "${receiver.packageName}/${receiver.receiverName}"
            states[key] = receiver.isEnabled
        }

        lastSnapshot = BackupSnapshot(
            receiverStates = states
        )
    }

    fun getLastSnapshot(): BackupSnapshot? {
        return lastSnapshot
    }
}

package wspdyb.bootcommander

import android.content.Context
import android.widget.Toast
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.File
import java.io.InputStreamReader

fun isRootAvailable(): Boolean {
    val paths = arrayOf(
        "/system/bin/su", "/system/xbin/su", "/sbin/su", 
        "/system/sd/xbin/su", "/system/bin/failsafe/su", 
        "/data/local/xbin/su", "/data/local/bin/su", "/data/local/su", 
        "/system/sbin/su", "/usr/bin/su", "/vendor/bin/su"
    )
    return paths.any { File(it).exists() }
}


suspend fun executeRootCommand(
    command: String,
    context: Context,
    packageName: String = ""
): Boolean {

    if (!isRootAvailable()) {
        withContext(Dispatchers.Main) {
            Toast.makeText(context, context.getString(R.string.error_no_root), Toast.LENGTH_LONG).show()

            LogManager.addLog(
                command = command,
                success = false,
                message = context.getString(R.string.error_no_root),
                packageName = packageName
            )
        }
        return false
    }
    return withContext(Dispatchers.IO) {
        var process: Process? = null
        var os: DataOutputStream? = null
        val errorOutput = StringBuilder()

        try {

            process = Runtime.getRuntime().exec("su")
            os = DataOutputStream(process.outputStream)

            os.writeBytes("$command\n")
            os.writeBytes("exit\n")
            os.flush()

            val reader = BufferedReader(InputStreamReader(process.errorStream))
            var line: String?
            while (reader.readLine().also { line = it } != null) {
                errorOutput.append(line)
            }

            val result = process.waitFor()

            withContext(Dispatchers.Main) {
                if (result == 0) {
                    // Success logic
                    val statusMsg = if (command.contains("enable")) {
                        context.getString(R.string.status_enabled)
                    } else {
                        context.getString(R.string.status_disabled)
                    }
                    LogManager.addLog(command, true, statusMsg, packageName)
                    true
                } else {
                    val baseError = context.getString(R.string.error_shell_code, result)
                    val fullError = if (errorOutput.isNotEmpty()) "$baseError: $errorOutput" else baseError
                    
                    LogManager.addLog(command, false, fullError, packageName)
                    Toast.makeText(context, fullError, Toast.LENGTH_LONG).show()
                    false
                }
            } ?: false
        } catch (e: Exception) {

            withContext(Dispatchers.Main) {
                val errorMsg = e.message ?: context.getString(R.string.error_unknown)
                val finalMsg = if (errorOutput.isNotEmpty()) "$errorMsg ($errorOutput)" else errorMsg
                
                LogManager.addLog(command, false, finalMsg, packageName)
                Toast.makeText(context, context.getString(R.string.error_prefix, finalMsg), Toast.LENGTH_SHORT).show()
            }
            false
        } finally {
            os?.close()
            process?.destroy()
        }
    }
}

suspend fun performRestore(snapshot: BackupSnapshot, context: Context) {
    withContext(Dispatchers.IO) {
        val states = snapshot.receiverStates 
        states.forEach { (component, shouldBeEnabled) ->
            val pkg = component.substringBefore("/", "")
            
            val action = if (shouldBeEnabled) "enable" else "disable"
            val command = "pm $action $component"
            
            executeRootCommand(command, context, pkg)
        }
    }
}

האמת זה יכול להיות גם כלי adb,
די נחמד אתה יכול לעשות אתר שעושה פעולה דומה.

ראיתי שהיה כאן צורך דחוף אז עשיתי עכשיו מהר שיהיה לי זמן אני יעבוד על זה יותר

@מתכנת-חובב מתחיל להיות חריגה מהנושא