Déterminer si l'appareil fonctionne sur un appareil rooté

Question

Mon application comporte une certaine fonctionnalité qui ne fonctionnera que sur un appareil où l'option Root est disponible. Plutôt que de faire échouer cette fonctionnalité lorsqu'elle est utilisée (et d'afficher un message d'erreur approprié à l'utilisateur), je préférerais une capacité à vérifier silencieusement si Root est disponible en premier lieu, et si ce n'est pas le cas, de cacher les options respectives en premier lieu.

Existe-t-il un moyen de le faire ?

Answer 1

Voici une classe qui vérifiera la présence de Root de trois manières différentes.

/** @author Kevin Kowalewski */
public class RootUtil {
    public static boolean isDeviceRooted() {
        return checkRootMethod1() || checkRootMethod2() || checkRootMethod3();
    }

    private static boolean checkRootMethod1() {
        String buildTags = android.os.Build.TAGS;
        return buildTags != null && buildTags.contains("test-keys");
    }

    private static boolean checkRootMethod2() {
        String[] paths = { "/system/app/Superuser.apk", "/sbin/su", "/system/bin/su", "/system/xbin/su", "/data/local/xbin/su", "/data/local/bin/su", "/system/sd/xbin/su",
                "/system/bin/failsafe/su", "/data/local/su", "/su/bin/su"};
        for (String path : paths) {
            if (new File(path).exists()) return true;
        }
        return false;
    }

    private static boolean checkRootMethod3() {
        Process process = null;
        try {
            process = Runtime.getRuntime().exec(new String[] { "/system/xbin/which", "su" });
            BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream()));
            if (in.readLine() != null) return true;
            return false;
        } catch (Throwable t) {
            return false;
        } finally {
            if (process != null) process.destroy();
        }
    }
}

Answer 2

La bibliothèque RootTools propose des méthodes simples pour vérifier la présence de Root :

RootTools.isRootAvailable()

Référence

Answer 3

Dans mon application, je vérifiais si l'appareil était enraciné ou non en exécutant la commande "su". Mais aujourd'hui, j'ai supprimé cette partie de mon code. Pourquoi ?

Parce que mon application est devenue un tueur de mémoire. Comment ? Laissez-moi vous raconter mon histoire.

Certains se sont plaints que mon application ralentissait les appareils (j'ai bien sûr pensé que ce n'était pas possible). J'ai essayé de comprendre pourquoi. J'ai donc utilisé MAT pour obtenir des heap dumps et les analyser, et tout semblait parfait. Mais après avoir relancé mon application plusieurs fois, j'ai réalisé que l'appareil devenait vraiment plus lent et que l'arrêt de mon application ne le rendait pas plus rapide (à moins de redémarrer l'appareil). J'ai de nouveau analysé les fichiers dumps alors que l'appareil était très lent. Mais tout était encore parfait pour le fichier dump. J'ai alors fait ce qu'il fallait faire en premier. J'ai listé les processus.

$ adb shell ps

Surprise, il y avait plusieurs processus pour ma demande (avec la balise de processus de ma demande au manifeste). Certains d'entre eux étaient des zombies, d'autres non.

Avec un exemple d'application qui n'a qu'une seule activité et qui n'exécute que la commande "su", je me suis rendu compte qu'un processus zombie était créé à chaque lancement de l'application. Au début, ces processus zombies allouent 0 Ko, puis quelque chose se produit et les processus zombies détiennent presque les mêmes Ko que le processus principal de mon application et ils deviennent des processus standard.

Il existe un rapport de bogue pour le même problème sur bugs.sun.com : http://bugs.sun.com/view_bug.do?bug_id=6474073 Ceci explique que si la commande n'est pas trouvée, les zombies seront créés avec la méthode exec(). Mais je ne comprends toujours pas pourquoi et comment ils peuvent devenir des processus autonomes et détenir des KBs significatifs. (Cela ne se produit pas tout le temps)

Vous pouvez essayer si vous le souhaitez avec l'exemple de code ci-dessous ;

String commandToExecute = "su";
executeShellCommand(commandToExecute);

Méthode simple d'exécution des commandes ;

private boolean executeShellCommand(String command){
    Process process = null;            
    try{
        process = Runtime.getRuntime().exec(command);
        return true;
    } catch (Exception e) {
        return false;
    } finally{
        if(process != null){
            try{
                process.destroy();
            }catch (Exception e) {
            }
        }
    }
}

En résumé, je n'ai pas de conseil à vous donner pour déterminer si votre appareil est enraciné ou non. Mais si j'étais vous, je n'utiliserais pas Runtime.getRuntime().exec().

D'ailleurs, RootTools.isRootAvailable() pose le même problème.

Answer 4

http://code.google.com/p/roottools/

Si vous ne souhaitez pas utiliser le fichier jar il suffit d'utiliser le code :

public static boolean findBinary(String binaryName) {
        boolean found = false;
        if (!found) {
            String[] places = { "/sbin/", "/system/bin/", "/system/xbin/",
                    "/data/local/xbin/", "/data/local/bin/",
                    "/system/sd/xbin/", "/system/bin/failsafe/", "/data/local/" };
            for (String where : places) {
                if (new File(where + binaryName).exists()) {
                    found = true;

                    break;
                }
            }
        }
        return found;
    }

Le programme essaiera de trouver le dossier su :

private static boolean isRooted() {
        return findBinary("su");
    }

Ejemplo:

if (isRooted()) {
   textView.setText("Device Rooted");

} else {
   textView.setText("Device Unrooted");
}

Answer 5

Au lieu d'utiliser isRootAvailable(), vous pouvez utiliser isAccessGiven(). Directement de RootTools wiki :

if (RootTools.isAccessGiven()) {
    // your app has been granted root access
}

RootTools.isAccessGiven() ne vérifie pas seulement qu'un appareil est enraciné, il appelle également su. appelle également su pour votre application, demande l'autorisatio votre application a obtenu les permissions d'accès à la racine. Ceci peut être utilisé comme première vérification dans votre application pour vous assurer qu'on vous accordera lorsque vous en aurez besoin.

Référence