Superuser

Pros of Magisk

• More comprehensive root solution with systemless modifications
• Active development and frequent updates
• Supports a wide range of Android versions and devices

Cons of Magisk

• More complex setup and usage for beginners
• Potential for system instability if not used correctly

Code Comparison

Magisk (build.gradle):

android {
    compileSdkVersion 28
    defaultConfig {
        minSdkVersion 21
        targetSdkVersion 28
    }
}

Superuser (AndroidManifest.xml):

<uses-sdk
    android:minSdkVersion="7"
    android:targetSdkVersion="17" />

The code comparison shows that Magisk targets more recent Android versions, while Superuser is designed for older devices. This reflects Magisk's active development and broader device support.

Magisk offers a more feature-rich and up-to-date root solution, with systemless modifications that help avoid detection by SafetyNet. However, it may be more challenging for beginners to set up and use compared to Superuser.

Superuser, being an older project, is simpler and more straightforward but lacks some advanced features and may not work on newer Android versions. It's generally easier to use for basic root access needs but has limited functionality compared to Magisk.

Pros of treble_experimentations

• Focuses on Project Treble and Generic System Images (GSIs), enabling broader device compatibility
• Actively maintained with frequent updates and contributions
• Provides extensive documentation and guides for custom ROM development

Cons of treble_experimentations

• More complex and requires deeper technical knowledge to use effectively
• May have compatibility issues with certain devices or Android versions
• Less focused on root access management compared to Superuser

Code Comparison

treble_experimentations:

#!/bin/bash

repo init -u https://android.googlesource.com/platform/manifest -b android-8.1.0_r43
repo sync -c -j$nproc --force-sync --no-clone-bundle --no-tags
. build/envsetup.sh
lunch aosp_arm64-userdebug
make -j$nproc

Superuser:

public class SuRequestActivity extends Activity {
    private static final String TAG = "SuRequestActivity";
    private static final int REQUEST_CODE = 1;
    private static final String EXTRA_SOCKET = "socket";
}

The code snippets highlight the different focus areas of the projects. treble_experimentations deals with building Android system images, while Superuser manages root access requests.

Pros of libsuperuser

• More comprehensive library for root-related operations
• Actively maintained with regular updates
• Better documentation and examples for developers

Cons of libsuperuser

• Larger codebase, potentially more complex to integrate
• May include unnecessary features for simpler root access needs
• Slightly steeper learning curve for beginners

Code Comparison

Superuser (Shell command execution):

Shell.SU.run("ls -l /data");

libsuperuser (Shell command execution):

Shell.Pool.SU.run("ls -l /data", null, null, false);

Both libraries provide methods for executing shell commands with root privileges, but libsuperuser offers more granular control over the execution process.

Additional Notes

Superuser focuses primarily on managing superuser access, while libsuperuser provides a broader set of tools for root-related operations. Developers should consider their specific needs when choosing between the two libraries. Superuser may be sufficient for basic root access management, while libsuperuser offers more advanced features for complex root-related tasks.

Pros of Island

• Focuses on app isolation and privacy, providing a sandboxed environment for apps
• Supports cloning apps to run multiple instances, useful for work/personal separation
• Offers more advanced features like app freezing and space management

Cons of Island

• More complex setup and usage compared to Superuser's straightforward root access management
• May have compatibility issues with some apps due to its sandboxing approach
• Less widespread adoption and community support than Superuser

Code Comparison

Island (Java):

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    if (savedInstanceState == null) {
        getFragmentManager().beginTransaction().add(R.id.container, new MainFragment()).commit();
    }
}

Superuser (Java):

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.request);
    packageName = getIntent().getStringExtra("package");
    requestName = getIntent().getStringExtra("request");
}

Both repositories use similar Android development patterns, but Island's code focuses on fragment management for its more complex UI, while Superuser's code handles intent extras for root access requests.

Pros of gnirehtet

• Provides reverse tethering functionality, allowing Android devices to use a computer's internet connection
• Cross-platform support (Windows, macOS, Linux)
• Doesn't require root access on the Android device

Cons of gnirehtet

• More complex setup process compared to Superuser
• Limited to reverse tethering functionality, while Superuser offers broader root access management
• Requires running a client application on the computer

Code Comparison

gnirehtet (Rust):

fn relay(tcp_client: TcpStream, selector: &mut Selector) -> io::Result<()> {
    let stream = TcpStream::connect(DEVICE_ADDR)?;
    let (reader, writer) = stream.split();
    relay_streams(tcp_client, reader, writer, selector)
}

Superuser (Java):

public static boolean shellAsync(String shell, String... commands) {
    try {
        Process process = Runtime.getRuntime().exec(shell);
        DataOutputStream os = new DataOutputStream(process.getOutputStream());
        for (String command : commands) {
            os.writeBytes(command + "\n");
            os.flush();
        }
        os.writeBytes("exit\n");
        os.flush();
        return true;
    } catch (Exception e) {
        return false;
    }
}

The code snippets showcase different functionalities: gnirehtet focuses on network relaying, while Superuser handles shell command execution for root access management.