להורדה | מנהל האיתחול – ניהול מוחלט של אפליקציות באתחול (למכשירי Root בלבד)

[זונדל גרנד]

אני שמח לשתף אתכם באפליקציה חדשה שפיתחתי – רעיון שנולד מתוך צורך אישי שלי (וכנראה גם של רבים מכם).

המכשיר מתחיל “לזחול” אחרי הדלקה?
יותר מדי אפליקציות מחליטות שהן חייבות לעלות ברקע בלי לשאול אתכם?

תכירו את מנהל האיתחול.

━━━━━━━━━━━━━━━━━━━━
מה האפליקציה עושה?

האפליקציה סורקת את כלל האפליקציות המותקנות במכשיר ומזהה את ה-Receivers (מקלטים) שאחראים להפעלה אוטומטית לאחר סיום האתחול (BOOT_COMPLETED).

באמצעות גישת Root, ניתן “לכבות את השאלטר” של רכיבים ספציפיים – שליטה מלאה ומדויקת על מי יעלה עם המכשיר ומי לא.

בנוסף, גם ללא Root ניתן לצפות ברשימת הרכיבים והטריגרים שמופעלים באתחול או באירועי מערכת שונים.

━━━━━━━━━━━━━━━━━━━━
למה זה טוב?

• שיפור מהירות האתחול – פחות תהליכים שעולים ברקע = מכשיר מוכן לשימוש מהר יותר.
• חיסכון בסוללה – מניעת שירותים מיותרים שרצים מהשנייה הראשונה.
• ניקוי זיכרון RAM – פחות עומס על המערכת.
• שליטה אמיתית במכשיר – אתם מחליטים מה יופעל.

━━━━━━━━━━━━━━━━━━━━
דגשים טכניים (למי שאוהב להבין לעומק)

• נדרשת הרשאת Root לצורך השבתה/הפעלה בפועל.
• השימוש מתבצע דרך פקודות מערכת ישירות:
  pm disable
  pm enable
  כך שהפעולה נקייה, יציבה וללא שירות רץ ברקע.
• האפליקציה ממוקדת מטרה – כרגע נתמכת השבתה/הפעלה של רכיבי עלייה באתחול בלבד.
• פונקציות מורכבות יותר נוטרלו בשלב זה כדי להבטיח יציבות מלאה.
• ממשק קליל, ללא ספריות כבדות וללא עומס מיותר.

━━━━━━━━━━━━━━━━━━━━
איך משתמשים?

1. פותחים את האפליקציה.
2. מאשרים גישת Root.
3. בוחרים אפליקציה מהרשימה.
4. מנטרלים את רכיב העלייה באתחול בלחיצה אחת.

זהו. באתחול הבא היא כבר לא תעלה אוטומטית.

━━━━━━━━━━━━━━━━━━━━
️ חשוב:
לא מומלץ להשבית רכיבי מערכת קריטיים אלא אם כן אתם יודעים בדיוק מה אתם עושים.

━━━━━━━━━━━━━━━━━━━━
תמיכה:
האפליקציה נתמכת באנדרואיד 7 ומעלה.

━━━━━━━━━━━━━━━━━━━━
תמונות:

━━━━━━━━━━━━━━━━━━━━
להורדה:

מנהל איתחול.apk
לחסידי נטפרי
━━━━━━━━━━━━━━━━━━━━
אשמח לפידבקים, הערות והצעות לשיפור

[iosi poli]

פוסט זה נמחק!

[אלי 4]

@זונדל-גרנד יישר כח
רק מה אם נטפרי

[cfopuser]

@זונדל-גרנד אתה מבין שpm disable משביתה את כול האפליקצייה ולא רק את הrecivers כן?
וזה שווה ערך למשתמש משבית ידנית את האפליקציה.

[שניאור שמח]

@אלי-4 כתב בלהורדה | מנהל האיתחול – ניהול מוחלט של אפליקציות באתחול (למכשירי Root בלבד):

רק מה אם נטפרי

מנהל-איתחול.apk.zip

[זונדל גרנד]

@cfopuser למה אתה סתם אומר??
מניח הנחה ומקשה קושיה

[cfopuser]

@זונדל-גרנד צודק. במבט לעומק,
רואים שאתה מכבה רק את הreciver,
שכתבת pm disable ישר חשבתי שזה השבתה של כלל האפליקציה.

אבל באמת כמו שרואים יש השבתה פר קומפוננט

Spoiler

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

Spoiler

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)
        }
    }
}

Spoiler

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

[iosi poli]

@cfopuser רגע אז לא חייב רוט??

[cfopuser]

@iosi-poli חייב רוט כי ההשבתה קורית על ידי פקודה בshell