Comment supprimer les données de préférences partagées de l'application sur Android

Comment supprimer les données SharedPreferences de mon application?

Je crée une application qui utilise de nombreux services Web pour synchroniser les données. À des fins de test, je dois effacer certaines valeurs SharedPreferences lorsque je redémarre l'application.

Pour supprimer des valeurs spécifiques: SharedPreferences.Editor.remove () suivi d'uncommit()

Pour les supprimer tous SharedPreferences.Editor.clear()suivi d'uncommit()

Si vous ne vous souciez pas de la valeur de retour et que vous l'utilisez à partir du thread principal de votre application, envisagez d'utiliser à la apply()place.

Ma solution:

SharedPreferences preferences = getSharedPreferences("Mypref", 0);
preferences.edit().remove("text").commit();

Suppression de toutes les préférences:

SharedPreferences settings = context.getSharedPreferences("PreferencesName", Context.MODE_PRIVATE);
settings.edit().clear().commit();

Suppression d'une seule préférence:

SharedPreferences settings = context.getSharedPreferences("PreferencesName", Context.MODE_PRIVATE);
settings.edit().remove("KeyName").commit();

S'il n'est pas nécessaire d'être supprimé à chaque fois, vous pouvez le supprimer manuellement à partir de:

Paramètres -> Applications -> Gérer les applications -> (choisissez votre application) -> Effacer les données ou Désinstaller

Versions plus récentes d'Android:

Paramètres -> Applications -> (choisissez votre application) -> Stockage -> Effacer les données et vider le cache

Suppression des préférences partagées Android sur une seule ligne :-)

context.getSharedPreferences("YOUR_PREFS", 0).edit().clear().commit();

Ou applypour un fonctionnement asynchrone non bloquant:

this.getSharedPreferences("YOUR_PREFS", 0).edit().clear().apply();

Semble que toutes les solutions ne fonctionnent pas complètement ou sont mortes

pour effacer toutes les préférences partagées d'une activité

PreferenceManager.getDefaultSharedPreferences(getBaseContext()).edit().clear().apply();

Appelez cela depuis l'activité principale après onCreate

note * j'ai utilisé à la .apply()place de .commit(), vous êtes libre de choisir commit ();

Vous pouvez utiliser le shell adb pour le faire même sans téléphone rooté. Le seul hic, c'est que l'application doit être débogable.

run-as <your package name> <command>

Par exemple:

run-as com.asdf.blah rm /data/data/com.asdf.blah/databases/myDB.db

Alternativement, vous pouvez simplement faire ce qui précède mais sans la commande qui vous dirigera vers la racine du package d'application et vous permettra d'exécuter plus de commandes dans le contexte de l'application.

Editor editor = getSharedPreferences("clear_cache", Context.MODE_PRIVATE).edit();
editor.clear();
editor.commit();

Depuis l'API 24 (Nougat), vous pouvez simplement faire:

context.deleteSharedPreferences("YOUR_PREFS");

Cependant, il n'y a pas de compatibilité descendante, donc si vous prenez en charge moins de 24, restez avec:

context.getSharedPreferences("YOUR_PREFS", Context.MODE_PRIVATE).edit().clear().apply(); 

Tout effacer:

PreferenceManager.getDefaultSharedPreferences(context).edit().clear().apply()

Vous pouvez également désinstaller manuellement votre application à l'aide de votre appareil. Ensuite, lorsque vous réinstallez votre application, les préférences partagées ont été réinitialisées.

Dans les définitions de classe:

private static final String PREFERENCES = "shared_prefs";

private static final SharedPreferences sharedPreferences  = getApplicationContext().getSharedPreferences(PREFERENCES, MODE_PRIVATE);

À l'intérieur de la classe:

public static void deleteAllSharedPrefs(){
    sharedPreferences.edit().clear().commit();
}

Essayez ce code:

SharedPreferences sharedPreferences = getSharedPreferences("fake", Context.MODE_PRIVATE);
SharedPreferences.Editor edit = sharedPreferences.edit();
edit.clear().commit();

Si c'est pour vos tests. Vous pouvez utiliser les commandes adb.

adb shell pm clear <package name>

String prefTag = "someTag";
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(applicationContext);
prefs.edit().remove(prefTag).commit();

Cela supprimera les préférences partagées enregistrées sous le nom "someTag".

• Pour supprimer une valeur particulière,

SharedPreferences.Editor remove (String key) suivi d'un commit () ou d'un apply ()

• Pour supprimer toutes les valeurs,

  SharedPreferences.Editor clear () suivi d'un commit () ou d'un apply ()

Pour supprimer les paires valeur / clé de préférence, vous pouvez facilement effectuer les opérations suivantes

getActivity().getSharedPreference().editor().remove("key").apply();

J'ai également développé une bibliothèque pour une manipulation facile des préférences partagées. Vous pouvez trouver le lien suivant

https://github.com/farruhha/SimplePrefs

Pour effacer toutes les SharedPreferences de façon centralisée dans n'importe quelle classe:

public static SharedPreferences.Editor getEditor(Context context) {
    return getPreferences(context).edit();
}

Et puis à partir de n'importe quelle classe: (commit retourne un booléen où vous pouvez vérifier si vos préférences sont effacées ou non)

Navigation.getEditor(this).clear().commit();

Ou vous pouvez utiliser appliquer; il retourne nul

Navigation.getEditor(this).clear().apply();

new File(context.getFilesDir(), fileName).delete();

Je peux supprimer le fichier dans les préférences partagées avec lui

Aucune des réponses ne fonctionne pour moi car j'ai de nombreuses clés de préférences partagées.

Supposons que vous exécutez un test Android au lieu d'un test unitaire.

Il fonctionne pour moi, boucle et supprime tous les fichiers shared_prefs .

@BeforeClass s'exécutera avant tous les tests et ActivityTestRule

@BeforeClass
public static void setUp() {
    Context context = InstrumentationRegistry.getTargetContext();

    File root = context.getFilesDir().getParentFile();
    String[] sharedPreferencesFileNames = new File(root, "shared_prefs").list();
    for (String fileName : sharedPreferencesFileNames) {
        context.getSharedPreferences(fileName.replace(".xml", ""), Context.MODE_PRIVATE).edit().clear().commit();
    }
}

La méthode Kotlin ktx pour effacer toutes les préférences:

val prefs: SharedPreferences = getSharedPreferences("prefsName", Context.MODE_PRIVATE)
prefs.edit(commit = true) {
    clear()
}

Cliquez ici pour toutes les opérations de préférences partagées avec des exemples

Vous pouvez utiliser preferences.edit().remove("key").commit()pour supprimer les valeurs enregistrées des préférences partagées.

Je viens de le faire ce matin. À partir d'une invite de commande:

adb shell
cd /data/data/YOUR_PACKAGE_NAME/shared_prefs
rm * // to remove all shared preference files
rm YOUR_PREFS_NAME.xml // to remove a specific shared preference file

REMARQUE : Cela nécessite un appareil enraciné tel que les appareils virtuels Android d'origine, un appareil Genymotion ou un combiné / tablette enraciné réel, etc.