Depuis le niveau 1 de l'API, c'est-à-dire le début d'android, une API pour le stockage des paires clé-valeur est disponible dans android. Cette API Si vous êtes nouveau sur android ou si vous apprenez à utiliser sharedpreferences.
Dans ce tutoriel, nous allons examiner plusieurs exemples d'utilisation des préférences partagées pour stocker et récupérer des données. La plupart du temps, nous stockerons des types de dtaa primitifs dans nos sharedpreferences.
Exemple 1 : Kotlin Android - Exemple de préférences partagées
Voici un exemple simple de sharedpreferences écrit en Kotlin.
Démo
Voici la démo de ce qui est créé :
Étape 1 : Dépendances
Aucune dépendance particulière ou tierce n'est nécessaire.
Étape 2 : Conception de la mise en page
Concevez votre mise en page xml comme suit :
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity"
android:gravity="center"
android:orientation="vertical">
<TextView
android:id="@+id/txt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="10dp"
android:padding="10dp"
android:textColor="#101010"
android:textSize="25sp"/>
<EditText
android:id="@+id/edt"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="@string/enter_a_text"
android:layout_margin="10dp"
android:textColor="#101010"/>
<Button
android:id="@+id/save"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/save"
android:layout_margin="10dp"/>
<Button
android:id="@+id/show"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/show"
android:layout_margin="10dp"/>
</LinearLayout>Étape 3 : Écrire le code
Ensuite, écrivez votre code kotlin comme suit :
MainActivity.kt
Voici le code complet de l'activité principale :
package arb.test.shared.perferences
import android.content.Context
import android.content.SharedPreferences
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
lateinit var shared : SharedPreferences
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
shared = getSharedPreferences("Test" , Context.MODE_PRIVATE)
save.setOnClickListener {
val edit = shared.edit()
edit.putString("txt" , edt.text.toString())
Toast.makeText(this , "Was Saved" , Toast.LENGTH_SHORT).show()
edit.apply()
}
show.setOnClickListener {
txt.text = shared.getString("txt" , "No imported" )
Toast.makeText(this , shared.getString("txt" , "No imported" ) , Toast.LENGTH_SHORT).show()
}
}
}Exécuter
Exécuter le projet
Références
Voici les liens de téléchargement :
Télécharger Code
Browse Code
Exemple 2 : Gestion des sessions à l'aide de SharedPreferences
Dans cet exemple, vous apprendrez à gérer les sessions utilisateur, par exemple après qu'un utilisateur se soit connecté à l'application, en utilisant SharedPreferences. Cet exemple est également écrit en Kotlin.
Il contient ces trois fichiers :
- Deux activités - Activités First et Login.
- Gestionnaire de session - classe SharedPreferences.
Commençons.
Étape 1 : Créer le projet
Commencez par créer un projet Android Studio vide.
Étape 2 : Dépendances
Aucune dépendance externe n'est nécessaire pour ce projet.
Step 3 : Design Layouts.
Nous allons concevoir deux mises en page :
(a). activité_login.xml
C'est l'activité de connexion. Ajoutez deux TextViews et un bouton :
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:gravity="center"
tools:context=".LoginActivity">
<TextView
android:id="@+id/Disp_Username"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="20sp"
android:text="Username"
android:textColor="@color/colorPrimary"/>
<TextView
android:id="@+id/Disp_Password"
android:layout_marginTop="20dp"
android:textColor="@color/colorPrimary"
android:textSize="20sp"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Password"/>
<Button
android:id="@+id/btnLogout"
android:layout_marginTop="40dp"
android:layout_width="match_parent"
android:layout_height="55dp"
android:layout_marginEnd="40dp"
android:layout_marginStart="40dp"
android:background="@color/colorPrimary"
android:textColor="@android:color/white"
android:text="Logout"/>
</LinearLayout>(b). activité_first.xml
Il s'agit de la mise en page de l'activité principale. Ajoutez un bouton et deux edittexts :
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical"
tools:context=".FirstActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Session Management"
android:textColor="@color/colorPrimary"
android:textSize="30sp"/>
<EditText
android:id="@+id/txtUsername"
android:layout_marginTop="50dp"
android:layout_width="match_parent"
android:layout_height="55dp"
android:textColorHint="@color/colorPrimary"
android:textColor="@color/colorPrimary"
android:layout_marginEnd="40dp"
android:layout_marginStart="40dp"
android:background="@null"
android:hint="Username"/>
<View
android:layout_width="match_parent"
android:layout_height="1dp"
android:layout_marginEnd="40dp"
android:layout_marginStart="40dp"
android:background="@color/colorPrimary"/>
<EditText
android:id="@+id/txtPassword"
android:layout_marginTop="20dp"
android:layout_width="match_parent"
android:layout_height="55dp"
android:textColorHint="@color/colorPrimary"
android:textColor="@color/colorPrimary"
android:layout_marginEnd="40dp"
android:layout_marginStart="40dp"
android:background="@null"
android:hint="Password"/>
<View
android:layout_width="match_parent"
android:layout_height="1dp"
android:layout_marginEnd="40dp"
android:layout_marginStart="40dp"
android:background="@color/colorPrimary"/>
<Button
android:id="@+id/btnLogin"
android:layout_marginTop="20dp"
android:layout_width="match_parent"
android:layout_height="55dp"
android:layout_marginEnd="40dp"
android:layout_marginStart="40dp"
android:text="Login"
android:textColor="@android:color/white"
android:background="@color/colorPrimary"/>
</LinearLayout>Étape 4 : Création du gestionnaire de session
Créez le gestionnaire de session en utilisant sharedpreferences. Commencez par créer le fichier SessionManager.kt avec les champs d'instance suivants : un objet SharedPreferences, un objet SharedPreferences.Editor, un objet Context et un entier pour représenter le mode privé :
class SessionManager {
var pref: SharedPreferences
var edior: SharedPreferences.Editor
var context: Context
var PRIVATE_MODE: Int = 0Initialisez-les dans le constructeur :
constructor(context: Context) {
this.context = context
pref = context.getSharedPreferences(PREF_NAME, PRIVATE_MODE)
edior = pref.edit()
}Définir les champs statiques dans un objet compagnon :
companion object {
val PREF_NAME: String = "KotlinDemo"
val IS_LOGIN: String = "isLogin"
val KEY_NAME: String = "name"
val KEY_PASS: String = "pass"
}Voici comment créer une session de connexion :
fun createLoginSession(name: String, emai: String) {
edior.putBoolean(IS_LOGIN, true)
edior.putString(KEY_NAME, name)
edior.putString(KEY_PASS, emai)
edior.commit()
}Voici comment vous vérifiez la connexion :
fun checkLogin() {
if (!this.isLoggedIn()) {
var i: Intent = Intent(context, FirstActivity::class.java)
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
context.startActivity(i)
}
}Voici comment vous obtenez les détails de l'utilisateur à partir des préférences partagées et les retournez dans un HashMap :
fun getUserDetails(): HashMap<String, String> {
var user: Map<String, String> = HashMap<String, String>()
(user as HashMap).put(KEY_NAME, pref.getString(KEY_NAME, null).toString())
(user as HashMap).put(KEY_PASS, pref.getString(KEY_PASS, null).toString())
return user
}Voici comment vous déconnectez un utilisateur :
fun LogoutUser() {
edior.clear()
edior.commit()
val i: Intent = Intent(context, LoginActivity::class.java)
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
context.startActivity(i)
}Et voici comment vous vérifiez si un utilisateur est connecté :
fun isLoggedIn(): Boolean {
return pref.getBoolean(IS_LOGIN, false)
}Voici le code complet :
SessionManager.kt
import android.content.Context
import android.content.Intent
import android.content.SharedPreferences
import com.example.sessionmanagementusingkotlin.FirstActivity
import com.example.sessionmanagementusingkotlin.LoginActivity
class SessionManager {
var pref: SharedPreferences
var edior: SharedPreferences.Editor
var context: Context
var PRIVATE_MODE: Int = 0
constructor(context: Context) {
this.context = context
pref = context.getSharedPreferences(PREF_NAME, PRIVATE_MODE)
edior = pref.edit()
}
companion object {
val PREF_NAME: String = "KotlinDemo"
val IS_LOGIN: String = "isLogin"
val KEY_NAME: String = "name"
val KEY_PASS: String = "pass"
}
fun createLoginSession(name: String, emai: String) {
edior.putBoolean(IS_LOGIN, true)
edior.putString(KEY_NAME, name)
edior.putString(KEY_PASS, emai)
edior.commit()
}
fun checkLogin() {
if (!this.isLoggedIn()) {
var i: Intent = Intent(context, FirstActivity::class.java)
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
context.startActivity(i)
}
}
fun getUserDetails(): HashMap<String, String> {
var user: Map<String, String> = HashMap<String, String>()
(user as HashMap).put(KEY_NAME, pref.getString(KEY_NAME, null).toString())
(user as HashMap).put(KEY_PASS, pref.getString(KEY_PASS, null).toString())
return user
}
fun LogoutUser() {
edior.clear()
edior.commit()
val i: Intent = Intent(context, LoginActivity::class.java)
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
context.startActivity(i)
}
fun isLoggedIn(): Boolean {
return pref.getBoolean(IS_LOGIN, false)
}
}Étape 5 : Créer des activités
Nous avons deux activités :
(a). PremièreActivité.kt
Va connecter un utilisateur et enregistrer ses détails dans SharedPreferences :
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import com.sdnkcreations.sessionmanagerinkotlin.SessionManager
import kotlinx.android.synthetic.main.activity_first.*
class FirstActivity : AppCompatActivity() {
lateinit var session: SessionManager
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_first)
session = SessionManager(applicationContext)
if (session.isLoggedIn()) {
var i: Intent = Intent(applicationContext, FirstActivity::class.java)
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
startActivity(i)
finish()
}
btnLogin.setOnClickListener {
val username: String = txtUsername.text.toString()
val password: String = txtPassword.text.toString()
if (username.trim().length > 0 && password.trim().length > 0) {
session.createLoginSession(username, password)
var i: Intent = Intent(applicationContext, LoginActivity::class.java)
startActivity(i)
finish()
} else {
Toast.makeText(this, "Login Failed...\n Please enter both credential", Toast.LENGTH_LONG).show()
}
}
}
}(b). LoginActivity.kt
Affichera les détails d'un utilisateur connecté :
class LoginActivity : AppCompatActivity() {
lateinit var session: SessionManager
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
session = SessionManager(applicationContext)
session.checkLogin()
val user: HashMap<String, String> = session.getUserDetails()
val name: String = user.get(SessionManager.KEY_NAME)!!
val pass: String = user.get(SessionManager.KEY_PASS)!!
Disp_Username.setText("Name: " + name)
Disp_Password.setText("Email: " + pass)
btnLogout.setOnClickListener {
session.LogoutUser()
}
}
}Exécution
Copier le code ou le télécharger dans le lien ci-dessous, construire et exécuter.
Référence
Voici les liens de référence :
Télécharger Exemple
Snippets de SharedPreferences
Dans ce tutoriel, nous voulons examiner les SharedPreferences, ce qu'elles sont, pourquoi elles sont importantes et plusieurs exemples.
Voici quelques exemples de SharedPreferences.
import android.content.Context;
import android.content.SharedPreferences;
import android.support.annotation.MainThread;
import com.jiangkang.tools.King;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.Map;
import java.util.Set;
public class SpUtils {
private SharedPreferences preferences;
private static final String DEFAULT_PREF_NAME = "ktools_pref";
private SharedPreferences.Editor editor;
public static SpUtils getInstance(Context context,String name){
return new SpUtils(context,name);
}
private SpUtils(Context context, String name) {
preferences = context.getSharedPreferences(name,Context.MODE_PRIVATE);
editor = preferences.edit();
}
public <T> SpUtils put(String key, T value){
if (value instanceof String){
editor.putString(key, (String) value);
}else if (value instanceof Boolean){
editor.putBoolean(key, (Boolean) value);
}else if (value instanceof Integer){
editor.putInt(key, (Integer) value);
}else if (value instanceof Long){
editor.putLong(key, (Long) value);
}else if (value instanceof Float){
editor.putFloat(key, (Float) value);
}else {
throw new IllegalArgumentException("value can not support");
}
return this;
}
public SpUtils putString(String key, String value){
editor.putString(key,value).commit();
return this;
}
public SpUtils putBoolean(String key, boolean value){
editor.putBoolean(key, value).commit();
return this;
}
public SpUtils putInt(String key, int value){
editor.putInt(key,value).commit();
return this;
}
public SpUtils putFloat(String key, float value){
editor.putFloat(key, value).commit();
return this;
}
public SpUtils putLong(String key, long value){
editor.putLong(key, value).commit();
return this;
}
public SpUtils putJsonObject(String key, JSONObject object){
editor.putString(key,object.toString());
return this;
}
public JSONObject getJsonObject(String key){
String jsonString = preferences.getString(key,"{}");
try {
return new JSONObject(jsonString);
} catch (JSONException e) {
return null;
}
}
public String getString(String key,String defaultValue){
return preferences.getString(key,defaultValue);
}
public boolean getBoolean(String key, boolean defaultValue){
return preferences.getBoolean(key, defaultValue);
}
public int getInt(String key, int defaultValue){
return preferences.getInt(key, defaultValue);
}
public long getLong(String key, long defaultValue){
return preferences.getLong(key, defaultValue);
}
public float getFloat(String key,float defaultValue){
return preferences.getFloat(key, defaultValue);
}
public Map<String,?> getAll(){
return preferences.getAll();
}
}2. Comment enregistrer et récupérer des données JSON dans SharedPreference ?
Commençons par créer notre application principale.
Cette classe dérive de la classe Application. Tout ce qu'elle fera pour nous est de contenir et de nous donner le Contexte de l'application.
import android.app.Application;
import android.content.Context;
public class MainApplication extends Application {
private static Context context;
@Override
public void onCreate() {
super.onCreate();
context = getApplicationContext();
}
public static Context getContext() {
return context;
}
}Ensuite, après avoir créé notre classe d'application, nous pouvons maintenant venir sauvegarder et charger nos données json.
La première méthode est la méthode save(). Elle va recevoir deux chaînes de caractères et un Object.
Nous utilisons la bibliothèque Gson de Google. C'est une bibliothèque tierce qui doit être ajoutée comme dépendance dans le fichier build.gradle de votre application.
Donc vous allez dans votre fichier build.gradle(situé dans le dossier app) et ajoutez la ligne suivante sous la fermeture des dépendances :
implementation 'com.google.code.gson:gson:2.8.1'Vous pouvez peut-être vérifier pour les versions ultérieures.
Ensuite, une fois que nous avons synchronisé le projet, nous commençons par instancier notre Gson ;
Gson gson = new Gson();Puis on récupère nos SharedPreferences :
SharedPreferences pref = MainApplication.getContext().getSharedPreferences(identifier, Context.MODE_PRIVATE);Puis obtenir un objet SharedPreference.Editor en invoquant la méthode edit() de notre classe SharedPreferences.
SharedPreferences.Editor editor = pref.edit();Ensuite, convertissez notre objet en JSON en utilisant la méthode toJson() de la classe Gson. Mettez ensuite ces données JSON à côté de la clé de notre instance SharedPreference.Editor, et invoquez la méthode apply() :
editor.putString(key, gson.toJson(object));
editor.apply();C'est ainsi que nous enregistrons les données JSON dans SharedPreferences.
Et pour charger ces données ? Eh bien, nous pouvons aussi facilement charger ces données. Encore une fois, vous instanciez le Gson et initialisez nos SharedPreferences.
On récupère ensuite nos données sous forme de chaîne JSON en invoquant la méthode getString() de la classe SharedPreferences, en s'assurant de passer la key :
String json = pref.getString(key, null);Nous vérifions si la valeur null, dans ce cas nous retournons null. Sinon, nous utilisons la méthode fromJson() de la classe Gson pour obtenir notre objet.
Voici le code :
import android.content.Context;
import android.content.SharedPreferences;
import com.google.gson.Gson;
import com.slotnslot.slotnslot.MainApplication;
public class StorageUtil {
public static void save(String identifier, String key, Object object) {
Gson gson = new Gson();
SharedPreferences pref = MainApplication.getContext().getSharedPreferences(identifier, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
editor.putString(key, gson.toJson(object));
editor.apply();
}
public static <T> T load(String identifier, String key, Class<T> clazz) {
Gson gson = new Gson();
SharedPreferences pref = MainApplication.getContext().getSharedPreferences(identifier, Context.MODE_PRIVATE);
String json = pref.getString(key, null);
return json == null ? null : gson.fromJson(json, clazz);
}
}