Desde o nível 1 da API, basicamente o início do Android, uma API para armazenar pares de valores-chave está disponível no Android. Esta API Se você é novo no Android ou está aprendendo a usar sharedpreferences.
Neste tutorial, veremos vários exemplos de como usar as preferências compartilhadas para armazenar e recuperar dados. Principalmente estaremos armazenando tipos dtaa primitivos em nossas preferências compartilhadas.
Exemplo 1: Kotlin Android - Exemplo SharedPreferences
Este é um exemplo simples de sharedpreferences escrito em Kotlin.
Demonstração
Aqui está a demonstração do que é criado:
Etapa 1: dependências
Não são necessárias dependências especiais ou de terceiros.
Etapa 2: Layout do projeto
Projete seu layout xml da seguinte forma:
<?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>Etapa 3: escrever código
Em seguida, escreva seu código kotlin da seguinte maneira:
MainActivity.kt
Aqui está o código completo para a atividade 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()
}
}
}Correr
Execute o projeto
Referências
Seguem os links para download:
Exemplo 2: Gerenciamento de sessão usando SharedPreferences
Neste exemplo, você aprenderá a gerenciar sessões de usuário, por exemplo, depois que um usuário entrar no aplicativo, usando SharedPreferences. Este exemplo também está escrito em Kotlin.
Ele contém estes três arquivos:
- Duas Atividades - Primeira e Atividades de Login.
- Gerenciador de sessões - classe SharedPreferences
Vamos começar.
Etapa 1: criar projeto
Comece criando um projeto Android Studio vazio.
Etapa 2: dependências
Nenhuma dependência externa é necessária para este projeto.
Etapa 3: Layouts de design.
Faremos dois layouts:
(uma). atividade_login.xml
Esta é a atividade de login. Adicione dois TextViews e um 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). atividade_first.xml
Este é o layout para a atividade principal. Adicione um Button e dois 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>Etapa 4: Criar Gerenciador de Sessões
Crie gerenciador de sessão usando sharedpreferences. Comece criando o arquivo SessionManager.kt junto com os seguintes campos de instância: um objeto SharedPreferences, um objeto SharedPreferences.Editor, um objeto Context e um inteiro para representar o modo privado:
class SessionManager {
var pref: SharedPreferences
var edior: SharedPreferences.Editor
var context: Context
var PRIVATE_MODE: Int = 0Inicialize-os no construtor:
constructor(context: Context) {
this.context = context
pref = context.getSharedPreferences(PREF_NAME, PRIVATE_MODE)
edior = pref.edit()
}Defina campos estáticos em um objeto complementar:
companion object {
val PREF_NAME: String = "KotlinDemo"
val IS_LOGIN: String = "isLogin"
val KEY_NAME: String = "name"
val KEY_PASS: String = "pass"
}Veja como você cria uma sessão de login:
fun createLoginSession(name: String, emai: String) {
edior.putBoolean(IS_LOGIN, true)
edior.putString(KEY_NAME, name)
edior.putString(KEY_PASS, emai)
edior.commit()
}Veja como você verifica o login:
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)
}
}Aqui está como você obtém os detalhes do usuário das preferências compartilhadas e os retorna em um 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
}Aqui está como você desconecta um usuário:
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)
}E aqui está como você verifica se um usuário está logado:
fun isLoggedIn(): Boolean {
return pref.getBoolean(IS_LOGIN, false)
}Aqui está o 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)
}
}Etapa 5: criar atividades
Temos duas atividades:
(uma). FirstActivity.kt
Irá logar um usuário e salvar seus detalhes em 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
Irá exibir os detalhes de um usuário logado:
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()
}
}
}Correr
Copie o código ou baixe-o no link abaixo, construa e execute.
Referência
Seguem os links de referência:
Download Exemplo
Trechos de preferências compartilhadas
Neste tutorial, queremos ver SharedPreferences, o que é, por que é importante e vários exemplos.
Aqui estão alguns exemplos 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. Como salvar e recuperar dados JSON em SharedPreference
Vamos começar criando nosso aplicativo principal.
Esta classe é derivada da classe Application. Tudo o que ele fará por nós é segurar e nos fornecer o Contexto do aplicativo.
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;
}
}Depois de criar nossa classe de aplicativo, agora podemos salvar e carregar nossos dados json.
O primeiro método é o método save(). Ele receberá duas strings e um Object.
Estamos usando a biblioteca Google Gson. É uma biblioteca de terceiros, portanto, deve ser adicionada como uma dependência no arquivo build.gradle no nível do aplicativo.
Então você vai para o seu arquivo build.gradle (localizado na pasta app) e adiciona a seguinte linha sob o fechamento de dependências:
implementation 'com.google.code.gson:gson:2.8.1'Talvez você possa verificar as versões posteriores.
Depois de sincronizarmos o projeto, começamos instanciando nosso Gson;
Gson gson = new Gson();Em seguida, obtenha nossas SharedPreferences:
SharedPreferences pref = MainApplication.getContext().getSharedPreferences(identifier, Context.MODE_PRIVATE);Então obtenha um objeto SharedPreference.Editor invocando o método edit() de nossa classe SharedPreferences.
SharedPreferences.Editor editor = pref.edit();Em seguida, converta nosso objeto para JSON usando o método toJson() da classe Gson. Em seguida, coloque esses dados JSON ao lado da chave para nossa instância SharedPreference.Editor e invoque o método apply():
editor.putString(key, gson.toJson(object));
editor.apply();