Comment effacer par programmation les données d'application

Je développe des tests automatisés pour une application Android (utilisant Robotium). Afin d'assurer la cohérence et la fiabilité des tests, je souhaite démarrer chaque test à l'état propre (de l'application sous test). Pour ce faire, je dois effacer les données de l'application. Cela peut être fait manuellement dans Paramètres / Applications / Gérer les applications / [Mon application] / Effacer les données

Quelle est la méthode recommandée pour y parvenir par programme?

Vous pouvez utiliser l'outil de gestion de packages pour effacer les données des applications installées (comme en appuyant sur le bouton `` Effacer les données '' dans les paramètres de l'application sur votre appareil). Donc, en utilisant adb, vous pouvez faire:

adb shell pm clear my.wonderful.app.package

Suite à la réponse de @ edovino, le moyen d'effacer toutes les préférences d'une application par programme serait

private void clearPreferences() {
    try {
        // clearing app data
        Runtime runtime = Runtime.getRuntime();
        runtime.exec("pm clear YOUR_APP_PACKAGE_GOES HERE");

    } catch (Exception e) {
        e.printStackTrace();
    }
}

Attention : l'application va forcer la fermeture.

vous pouvez effacer les données d'application SharedPreferences avec ce

Editor editor = 
context.getSharedPreferences(PREF_FILE_NAME, Context.MODE_PRIVATE).edit();
editor.clear();
editor.commit();

et pour effacer la base de données de l'application, cette réponse est correcte -> Effacer la base de données de l'application

À partir de la version 19 de l'API, il est possible d'appeler ActivityManager.clearApplicationUserData ().

((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).clearApplicationUserData();

Vérifiez ce code pour:

@Override
protected void onDestroy() {
// closing Entire Application
    android.os.Process.killProcess(android.os.Process.myPid());
    Editor editor = getSharedPreferences("clear_cache", Context.MODE_PRIVATE).edit();
    editor.clear();
    editor.commit();
    trimCache(this);
    super.onDestroy();
}


public static void trimCache(Context context) {
    try {
        File dir = context.getCacheDir();
        if (dir != null && dir.isDirectory()) {
            deleteDir(dir);

        }
    } catch (Exception e) {
        // TODO: handle exception
    }
}


public static boolean deleteDir(File dir) {
    if (dir != null && dir.isDirectory()) {
        String[] children = dir.list();
        for (int i = 0; i < children.length; i++) {
            boolean success = deleteDir(new File(dir, children[i]));
            if (!success) {
                return false;
            }
        }
    }

    // <uses-permission
    // android:name="android.permission.CLEAR_APP_CACHE"></uses-permission>
    // The directory is now empty so delete it

    return dir.delete();
}

Si vous n'avez que quelques préférences partagées à effacer, cette solution est bien plus agréable .

@Override
protected void setUp() throws Exception {
    super.setUp();
    Instrumentation instrumentation = getInstrumentation();
    SharedPreferences preferences = instrumentation.getTargetContext().getSharedPreferences(...), Context.MODE_PRIVATE);
    preferences.edit().clear().commit();
    solo = new Solo(instrumentation, getActivity());
}

En utilisant le contexte , nous pouvons effacer les fichiers spécifiques à l'application comme les préférences, le fichier de base de données. J'ai utilisé le code ci-dessous pour les tests d'interface utilisateur avec Espresso.

    @Rule
    public ActivityTestRule<HomeActivity> mActivityRule = new ActivityTestRule<>(
            HomeActivity.class);

    public static void clearAppInfo() {
        Activity mActivity = testRule.getActivity();
        SharedPreferences prefs =
                PreferenceManager.getDefaultSharedPreferences(mActivity);
        prefs.edit().clear().commit();
        mActivity.deleteDatabase("app_db_name.db");
    }

La manière la plus simple de procéder est

private void deleteAppData() {
         try {
        // clearing app data
        String packageName = getApplicationContext().getPackageName();
        Runtime runtime = Runtime.getRuntime();
        runtime.exec("pm clear "+packageName);

    } catch (Exception e) {
        e.printStackTrace();
    } 
}

Cela effacera les données et supprimera votre application de la mémoire. Cela équivaut à l'option d'effacement des données sous Paramètres -> Gestionnaire d'applications -> Votre application -> Effacer les données.

Cela supprimera complètement les données et forcera la fermeture de l'application

Cette solution m'a vraiment aidé:

En utilisant les deux méthodes ci-dessous, nous pouvons effacer les données par programme

    public void clearApplicationData() {
    File cacheDirectory = getCacheDir();
    File applicationDirectory = new File(cacheDirectory.getParent());
    if (applicationDirectory.exists()) {
    String[] fileNames = applicationDirectory.list();
        for (String fileName : fileNames) {
            if (!fileName.equals("lib")) {
                deleteFile(new File(applicationDirectory, fileName));
            }
        }
    }
}
    public static boolean deleteFile(File file) {
    boolean deletedAll = true;
    if (file != null) {
        if (file.isDirectory()) {
            String[] children = file.list();
            for (int i = 0; i < children.length; i++) {
                deletedAll = deleteFile(new File(file, children[i])) && deletedAll;
            }
        } else {
            deletedAll = file.delete();
        }
    }

    return deletedAll;
}

si la version Android est supérieure à kitkat, vous pouvez également l'utiliser

public void onClick (vue vue) {

    Context context = getApplicationContext(); // add this line
    if (Build.VERSION_CODES.KITKAT <= Build.VERSION.SDK_INT) {
        ((ActivityManager) context.getSystemService(ACTIVITY_SERVICE))
            .clearApplicationUserData();
        return;
    }

Quelle est la méthode recommandée pour y parvenir par programme?

La seule option possible est d'exécuter la commande ADB adb shell pm clear packageavant le test. Le plus gros problème est que c'est une sorte de casse-tête combinant l'exécution de tests et les commandes shell.

Cependant, nous (chez Mediafe) avons proposé une solution qui peut fonctionner pour vous sur un appareil non enraciné régulier. Tout ce que vous avez à faire est d'ajouter une annotation. Tout le reste est fait en exécutant un simple script bash .

Ajoutez simplement une @ClearDataannotation avant TOUT de vos tests et tada 🎉, la commande ADB clear sera exécutée avant l'exécution du test.

Voici un exemple d'un tel test:

@Test
@ClearData
public void someTest() {
    // your test
}

L'idée est la suivante

1. Lire tous les tests en utilisant adb shell am instrument -e log true
2. Construire un plan d'exécution en analysant la sortie de (1)
3. Exécutez le plan d'exécution ligne par ligne

En utilisant la même idée, ce sont toutes des options que vous pouvez facilement prendre en charge:

• Effacer les données
• Effacer la barre de notification
• Paramétrer
• Filtrer et exécuter par balises

N'utilisez que des annotations. Comme ça:

@Test
@ClearData
@Tags(tags = {"sanity", "medium"})
@Parameterized.Repeat(count = 3)
public void myTest() throws Exception {
    String param = params[index];
    // ...
}

Prime! 🎁 Pour chaque test échoué:

• Récupérer Logcat + stacktrace
• Enregistrer une vidéo (mp4)
• Dump DB (sqlite)
• Vider les préférences partagées par défaut (xml)
• Collectez des fichiers dumpsys tels que: batterie, netstats et autres.

En général, il est facile d'ajouter plus d'options, puisque les tests sont exécutés un par un à partir du script bash plutôt que de la tâche gradle.

📗 Le billet de blog complet : https://medium.com/medisafe-tech-blog/running-android-ui-tests-53e85e5c8da8

📘 Le code source avec des exemples : https://github.com/medisafe/run-android-tests

J'espère que cela répond à la question de 6 ans;)