安卓APP运行终端命令可行性及实现方法问询：一键执行Mono相关指令

Absolutely, Android apps can run terminal commands—and setting up an app to auto-execute your Mono/C# code and system tasks like apt-get update on launch is totally doable. Let’s break this down step by step, including key considerations for your use case.

Short answer: Yes, but with a critical caveat. Most system-level commands (like apt-get update) require root access on your Android device. Since you’re already using Mono and apt, I’m assuming you’re working with a rooted device (e.g., a custom ROM, or using Magisk to gain root privileges). Non-rooted devices are limited to non-privileged commands, which won’t work for your needs here.

Here’s how to build your auto-executing app using Android Studio:

1. Set Up Your Project #

Start with a new empty activity project in Android Studio. Target API 24 or higher for better compatibility with modern Android versions.

2. Verify Root Access First #

Before running any privileged commands, add a check to confirm your device is rooted. This avoids crashes or confusing error messages later:

private boolean isDeviceRooted() {
    String suBinary = "su";
    String[] possiblePaths = {"/system/bin/", "/system/xbin/", "/sbin/", "/data/local/xbin/", "/data/local/bin/"};
    
    for (String path : possiblePaths) {
        if (new File(path + suBinary).exists()) {
            return true;
        }
    }
    return false;
}

3. Auto-Execute Commands on App Launch #

Put your command execution logic in the onCreate() method of your main activity. Always run commands in a background thread—running them on the UI thread will freeze your app and could lead to an ANR (Application Not Responding) error.

Here’s a complete example that runs apt-get update followed by your Mono C# program:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (isDeviceRooted()) {
        // Launch a background thread to run commands
        new Thread(() -> {
            try {
                // Run apt-get update (prefix with su -c to gain root)
                Process updateProcess = Runtime.getRuntime().exec("su -c apt-get update");
                int exitCode = updateProcess.waitFor();
                Log.d("TerminalLog", "apt-get update finished with code: " + exitCode);

                // Run your Mono C# program (replace with your actual command/path)
                String monoCommand = "su -c mono /storage/emulated/0/MyApps/MyProgram.exe";
                Process monoProcess = Runtime.getRuntime().exec(monoCommand);
                exitCode = monoProcess.waitFor();
                Log.d("TerminalLog", "Mono program finished with code: " + exitCode);

                // Optional: Read and log the command output
                BufferedReader outputReader = new BufferedReader(
                    new InputStreamReader(monoProcess.getInputStream())
                );
                StringBuilder output = new StringBuilder();
                String line;
                while ((line = outputReader.readLine()) != null) {
                    output.append(line).append("\n");
                }
                Log.d("MonoOutput", output.toString());

            } catch (IOException | InterruptedException e) {
                Log.e("TerminalError", "Command execution failed", e);
            }
        }).start();
    } else {
        // Show a toast if device isn't rooted
        Toast.makeText(this, "Root access required to run these commands!", Toast.LENGTH_LONG).show();
    }
}

4. Key Tips for Success #

• Root Command Prefix: Always prefix privileged commands with su -c to run them as the superuser.
• Mono Path: Ensure the mono executable is in your system PATH, or use its full file path (e.g., /data/local/bin/mono) to avoid "command not found" errors.
• Error Handling: The example includes basic logging, but you could extend it to show error messages to the user if a command fails.
• Testing: Test directly on your rooted physical device—emulators often don’t have the same setup (like apt or Mono installed) as your daily driver.

5. Alternative: Use a Root Command Library #

If you want a more robust solution (with built-in error handling and output parsing), consider libraries like RootShell. But for your simple auto-execute use case, the basic Runtime.exec() approach is more than sufficient.

内容的提问来源于stack exchange，提问作者Rishav