Desde el nivel 1 de la API, básicamente el comienzo de android, una API para almacenar pares de valores clave ha estado disponible en android. Esta API Si usted es nuevo en android o está aprendiendo a utilizar sharedpreferences.

En este tutorial vamos a ver varios ejemplos de cómo utilizar sharedpreferences para almacenar y recuperar datos. Principalmente almacenaremos tipos dtaa primitivos en nuestras sharedpreferences.

Ejemplo 1: Kotlin Android - Ejemplo de sharedpreferences

Este es un simple ejemplo de sharedpreferences escrito en Kotlin.

Demo

Aquí está la demo de lo que se crea:

Kotlin Android Shared Preferences Example

Paso 1: Dependencias

No son necesarias dependencias especiales o de terceros.

Paso 2: Diseño del layout

Diseña tu layout xml de la siguiente manera:

<?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>

Paso 3: Escribir el código

A continuación, escriba su código kotlin de la siguiente manera:

MainActivity.kt

Aquí está el código completo para la actividad principal:

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()
        }

    }
}

Ejecutar

Ejecuta el proyecto

Referencias

Aquí están los enlaces de descarga:

Descargar Código
Examinar Código

Ejemplo 2: Gestión de sesiones usando SharedPreferences

En este ejemplo aprenderás a gestionar las sesiones de los usuarios, por ejemplo después de que un usuario se registre en la aplicación, utilizando SharedPreferences. Este ejemplo también está escrito en Kotlin.

Contiene estos tres archivos:

  1. Dos actividades: la primera y la de inicio de sesión.
    1. El gestor de sesiones - clase SharedPreferences

Vamos a empezar.

Paso 1: Crear Proyecto

Comienza creando un proyecto vacío de Android Studio.

Paso 2: Dependencias

No se necesitan dependencias externas para este proyecto.

Paso 3: Diseñar diseños.

Diseñaremos dos diseños:

(a). activity_login.xml

Esta es la actividad de inicio de sesión. Añade dos TextViews y un Button:

<?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). activity_first.xml

Este es el diseño de la actividad principal. Añade un Button y dos 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>

Paso 4: Crear el gestor de sesiones

Cree el gestor de sesiones usando sharedpreferences. Comience creando el archivo SessionManager.kt junto con los siguientes campos de instancia: un objeto SharedPreferences, un objeto SharedPreferences.Editor, un objeto Context y un entero para representar el modo privado:

class SessionManager {

    var pref: SharedPreferences
    var edior: SharedPreferences.Editor
    var context: Context
    var PRIVATE_MODE: Int = 0

Inicialízalos en el constructor:

    constructor(context: Context) {

        this.context = context
        pref = context.getSharedPreferences(PREF_NAME, PRIVATE_MODE)
        edior = pref.edit()
    }

Definir los campos estáticos en un objeto compañero:

    companion object {

        val PREF_NAME: String = "KotlinDemo"
        val IS_LOGIN: String = "isLogin"
        val KEY_NAME: String = "name"
        val KEY_PASS: String = "pass"

    }

Así es como se crea una sesión de acceso:

    fun createLoginSession(name: String, emai: String) {

        edior.putBoolean(IS_LOGIN, true)
        edior.putString(KEY_NAME, name)
        edior.putString(KEY_PASS, emai)
        edior.commit()
    }

Así es como se comprueba el inicio de sesión:

    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)
        }
    }

Así es como obtienes los detalles del usuario desde el sharedpreferences y los devuelves en 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
    }

Así es como se cierra la sesión de un usuario:

    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)
    }

Y aquí es cómo se comprueba si un usuario está conectado:


    fun isLoggedIn(): Boolean {

        return pref.getBoolean(IS_LOGIN, false)
    }

Aquí está el código completo:

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)
    }

}

Paso 5: Crear Actividades

Tenemos dos actividades:

(a). FirstActivity.kt

Iniciará la sesión de un usuario y guardará sus datos en 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

Mostrará los detalles de un usuario logueado:

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()
        }
    }
}

Ejecutar

Copia el código o descárgalo en el siguiente enlace, construye y ejecuta.

Referencia

Aquí están los enlaces de referencia:

Descargar Ejemplo

Fragmentos de SharedPreferences

En este tutorial queremos ver SharedPreferences, qué es, por qué es importante y varios ejemplos.

Aquí hay algunos ejemplos 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. Cómo guardar y recuperar datos JSON en SharedPreference

Empecemos por crear nuestra aplicación principal.

Esta clase deriva de la clase Application. Todo lo que hará por nosotros es guardar y darnos el al Contexto de la aplicación.

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;
    }
}

Entonces, habiendo creado nuestra clase de aplicación ahora podemos venir a guardar y cargar nuestros datos json.

El primer método es el método save(). Recibirá dos cadenas y un objeto.

Estamos usando la librería Gson de Google. Es una librería de terceros por lo que tiene que ser añadida como una dependencia en tu archivo build.gradle a nivel de aplicación.

Así que ve a tu archivo build.gradle (ubicado en la carpeta de la app) y añade la siguiente línea bajo el cierre de dependencias:

implementation 'com.google.code.gson:gson:2.8.1'

Tal vez puedas comprobar las versiones posteriores.

A continuación, una vez que hemos sincronizado el proyecto empezamos por instanciar nuestro Gson;

        Gson gson = new Gson();

Luego obtenemos nuestro SharedPreferences:

        SharedPreferences pref = MainApplication.getContext().getSharedPreferences(identifier, Context.MODE_PRIVATE);

Luego obtenemos un objeto SharedPreference.Editor invocando el método edit() de nuestra clase SharedPreferences.

        SharedPreferences.Editor editor = pref.edit();

Luego convertir nuestro objeto a JSON usando el método toJson() de la clase Gson. A continuación, poner esos datos JSON junto a la clave de nuestra instancia SharedPreference.Editor, e invocar el método apply():

        editor.putString(key, gson.toJson(object));
        editor.apply();

Así es como guardamos los datos JSON en SharedPreferences.

¿Qué pasa con la carga de esos datos? Bueno, también podemos cargar fácilmente esos datos. De nuevo se instala el Gson y se inicializa nuestro SharedPreferences.

Luego obtenemos nuestros datos como una cadena JSON invocando el método getString() de la clase SharedPreferences, asegurándonos de pasar la key:

        String json = pref.getString(key, null);

Comprobamos si el valor es null, en cuyo caso devolvemos null. En caso contrario utilizamos el método fromJson() de la clase Gson para obtener nuestro objeto.

Este es el código:

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);
    }
}

Categorizado en: