Salvando informações com o Shared Preferences

Como podemos salvar as informações com o Shared Preferences?

No post onde mostro como podemos criar uma splash screen, vimos que diversas Apps fazem uso desse tipo de tela, entretanto, já percebeu quantas vezes essa tela aparece para nós? Será que todas as vezes que abrimos a App? Algumas vezes? Apenas uma vez?

Entendendo o problema de usar splash screen

Imagine se todas as vezes que o usuário abrir a App, tiver que esperar um determinado tempo para a App mostrar o conteúdo que ele vai interagir, sendo que ele já sabe o que é a App e o que ela faz. Será que ele vai gostar disso? Provavelmente não... Então como poderíamos resolver esse problema?

Conceito para evitar o problema

Teoricamente, quando o usuário abrir a App, precisamos armazenar uma pequena informação indicando que o usuário já iniciou a App uma vez. Porém, no Android, como podemos armazenar dados ou informações?

Podemos optar por criar um banco de dados no SQLite, e então, criamos uma tabela para armazenar essas informações. Entretanto, precisamos apenas armazenar uma informaçãozinha, ou seja, um true ou false, 1 ou 0.

Em outras palavras, qualquer dado que indica se o usuário iniciou ou não a App.

Considerando esse aspecto, faz sentido criar uma estrutura complexa como um banco de dados, apenas pra resolver isso? Aparentemente não... Então como resolvemos esse mesmo problema sem a utilização de um banco de dados?

Conhecendo o Shared Preferences do Android

No Android, existem diversas opções de armazenamento, conhecidas como Storage Options, dentre essas opções, temos a Shared Preferences que nos permite armazenar valores primitivos, como por exemplo, booleans, floats, ints, longs e Strings a partir de uma chave, por exemplo:

• chave: ja_abriu_app, valor: true

Bem legal, né? Vamos então adicioná-la na activity SplashScreenActivity que é a LAUNCHER da App. Como podemos fazer isso?

Utilizando o Shared Preferences

Simples! Primeiro chamamos o método getSharedPreference() enviando 2 parâmetros:

getSharedPreferences("user_preferences", MODE_PRIVATE);

• 1º parâmetro: nome da shared preferences que queremos buscar.
• 2º parâmetro: modo de acesso (Por defautl utilizamos o MODE_PRIVATE pois ele restringe o acesso apenas para a App que está chamando ou para todas as Apps que tiverem o mesmo user ID)

Esse método nos devolve uma instância da classe SharedPreferences:

public class SplashScreenActivity extends AppCompatActivity { 
@Override 
protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
setContentView(R.layout.activity_splash_screen);
SharedPreferences preferences = getSharedPreferences("user_preferences", MODE_PRIVATE);
Handler handle = new Handler(); 
handle.postDelayed(new Runnable() { 
@Override 
public void run() { mostrarLogin(); } }, 2000); 
}
//métodos
}

A partir do objeto preferences podemos verificar se existe uma chave com o método contains(). Portanto, antes de chamar o postDelayed() do handler, vamos verificar se existe a chave "ja_abriu_app".

if(preferences.contains("ja_abriu_app")){ }

Caso exista, mostramos a tela de login:

if(preferences.contains("ja_abriu_app")){ mostrarLogin() }

Mas e se a chave não existe? O que fazemos? Adicionamos um else para mostrar a splash screen, certo?

Antes de adicionar o else, para facilitar a leitura e compreensão do código, vamos extrair o método mostrarSplash() enviando todo o código que cria a splash screen dentro dele. Então ficamos com o seguinte resultado:

public class SplashScreenActivity extends AppCompatActivity { 
@Override protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
setContentView(R.layout.activity_splash_screen); 
SharedPreferences preferences = getSharedPreferences("user_preferences", MODE_PRIVATE);
if (preferences.contains("ja_abriu_app")) { mostrarLogin() } 
  else { mostrarSplash() 
  } 
}
private void mostrarSplash() { 
Handler handle = new Handler(); 
handle.postDelayed(new Runnable() { 
@Override 
public   { mostrarLogin();
    } 
  }, ); 
}

}

Se executarmos a App, teremos o mesmo comportamento de antes, pois a chave que enviamos ainda não existe! Então o que precisamos fazer agora?

Salvando informações no Shared Preferences

No momento em que o método mostrarSplash() for chamado, precisamos também armazenar essa chave no nosso preferences, certo? Então vamos adicioná-la!

Primeiro, vamos criar o método adicionarPreferenceJaAbriu() que recebe um objeto do tipo SharedPreferences:

private void adicionarPreferenceJaAbriu(SharedPreferences preferences) { }

Dentro do método adicionarPreferenceJaAbriu(), criaremos a chave "ja_abriu_app". Mas como fazemos isso? A partir do preferences chamamos o método edit() que nos devolve um objeto do tipo SharedPreferences.Editor():

SharedPreferences.Editor editor = preferences.edit();

Então, a partir do editor podemos adicionar um valor, por exemplo, para adicionar um boolean, utilizando o método putBoolean() enviando o nome da chave e o valor:

SharedPreferences.Editor editor = preferences.edit(); 
editor.putBoolean("ja_abriu_app", true);

Por fim, precisamos utilizar o método commit() do editor para salvar a operação que realizamos:

private void adicionarPreferenceJaAbriu(SharedPreferences preferences) { 
SharedPreferences.Editor editor = preferences.edit(); 
editor.putBoolean("ja_abriu_app", true); 
editor.commit(); 
}

Nesse exemplo, adicionamos apenas uma chave antes de realizar o commit(), porém, poderíamos adicionar mais de uma antes de chamá-lo!

Por fim, basta apenas chamarmos o método adicionarPreferenceJaAbriu() enviando o preferences logo antes de chamar o método mostrarSplash():

public class SplashScreenActivity extends AppCompatActivity { 
@Override
protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_splash_screen);
SharedPreferences preferences = getSharedPreferences("user_preferences", MODE_PRIVATE);
if (preferences.contains("ja_abriu_app")) { mostrarLogin(); } 
  else { adicionarPreferenceJaAbriu(preferences); mostrarSplash(); 
  } 
}
private void adicionarPreferenceJaAbriu(SharedPreferences preferences) { 
SharedPreferences.Editor editor = preferences.edit(); 
editor.putBoolean("ja_abriu_app", true); 
editor.commit(); }
//métodos
}

Executando novamente a App, temos o mesmo resultado de antes, pois ainda não existe a chave, porém, a partir da segunda execução, a App direciona direto para a tela de login!

Um detalhe importante sobre a Shared Preferences considerando esse nosso exemplo, é que não utilizamos em nenhum momento o seu valor, isto é, foi necessário apenas saber se a chave existia, afinal, caso ela exista sabemos que ele já abriu uma vez. Então vem a questão:

Em quais casos seria interessante pegar o valor da Shared Preferences?

Consideração do Shared Preferences

Atualmente, é muito comum abrirmos uma App, realizarmos o login e, em algum momento, fecharmos a App. Entretanto, quando abrimos novamente a App, não passamos mais pela tela de login, certo?

Como será que isso é feito? Provavelmente, existe algum tipo de token identificador que verifica se esse usuário faz parte ou não do sistema.

Considerando o cenário acima, como faríamos para armazenar esse token na App? Por meio do Shared Preferences também!

Em outras palavras, o Shared Preferences pode nos auxiliar em diversos cenários no dia a dia considerando que precisamos apenas salvar um dado primitivo.

Entretanto, seu uso precisa ser consciente, pois se a sua intenção é armazenar configuração de preferência do usuário, o mais indicado é o uso da PreferenceActivity :)

Conclusão

Nesse post vimos que além do SQLite, temos outras Storage Options que nos permitem armazenar dados nos dispositivos sem a necessidade de criar uma estruta de dados complexa como um banco de dados.

Dentre elas vimos a Shared Preferences que nos permite armazenar valores primitivos utilizando uma estrutura de chave e valor. O que achou da Shared Preferences? Teste na sua App e me conte o que achou! ;)

E que tal aprender a integrar a sua App Android com um Web Service? Seus problemas acabaram! Na Alura temos o curso de Android com Web Service no qual você vai aprender desde o zero como podemos fazer com que a nossa App Android se comunique com um servidor externo.