TUTORIAL Android Parte 4

Persistncia de Dados
Postado 29 de abril de 2013 por Renan Drabach
Com a ltima parte do nosso tutorial sobre desenvolvimento Android, voc j ter
conhecimento suficiente para comear a desenvolver aplicaes voltadas para problemas
e necessidades reais. Caso no tenha visto, vale indicar:
- TUTORIAL Android Parte 1 Primeiros passos
- TUTORIAL Android Parte 2 Conhecendo suas ferramentas
- TUTORIAL Android Parte 3 Construo de Telas
J que pouca coisa realmente til poderia ser feita se tudo comeasse do zero toda vez
que o usurio a fechasse, devemos conhecer as formas de persistir as informaes de uma
aplicao. Hoje vamos abordar as duas formas mais simples de guardar informaes de
forma persistente no Android, utilizando Shared Preferences ou o Storage (interno ou
externo) do dispositivo. Para isso vamos tomar como base o aplicativo que
desenvolvemos no passo anterior, que pode ser baixado neste link (no Eclipse, utilize a
opo Importar e escolha Projeto Existente para o Workspace, selecionando a pasta
descompactada), e alter-lo para o exemplo de hoje.
O que o nosso aplicativo faz salvar as informaes que foram inseridas na tela,
utilizando a opo selecionada que ser a Activity principal. Em seguida, assim que o
boto Exibir for pressionado, sero lidas as informaes que foram previamente salvas.
O primeiro passo construir a tela principal de forma semelhante apresentada abaixo,
utilizando os conceitos da parte 3 do nosso tutorial. Vale salientar que a tela que exibir
o que foi salvo no precisa ser modificada.

Agora precisamos decidir como efetivamente salvar e ler essas informaes, que o ponto
principal que veremos hoje:
- De que forma vamos salvar os dados dos campos da tela (baseando-se no estado dos
Radio Buttons)
- Onde ser realizada a leitura os dados (aps o boto Salvar ser pressionado), que sero
exibidos na segunda tela assim que o boto Exibir for pressionado.
Ento, vamos comear definindo o mtodo que ser executado no uso do boto Salvar:
1. // Evento de clique do boto salvar.
2. public void botaoSalvar(View view) {
3.
4. // Instncia do elemento de opo.
5. RadioButton opcaoSharedPreferences = (RadioButton)
findViewById(R.id.radioButton_SharedPref);
6.
7. // Recuperamos os valores dos campos da tela.
8. EditText campoTexto = (EditText)
findViewById(R.id.editText_Texto);
9. EditText campoNumero = (EditText)
findViewById(R.id.editText_Numero);
10.
11. String texto = campoTexto.getText().toString();
12. long numero =
Long.parseLong(campoNumero.getText().toString());
13.
14. // Teste da opo selecionada.
15. if (opcaoSharedPreferences.isChecked()) {
16. salvarSharedPref(texto, numero);
17. } else {
18. salvarInternalStorage(texto, numero);
19. }
20. }
Instanciamos o Radio Button da esquerda, que representa a opo de Shared Preferences,
recuperamos tambm as informaes digitadas e testamos qual opo foi selecionada,
passando estes para que sejam salvos.
Dica: troque os identificadores de cada componente no arquivo de layout (XML) para
facilitar a identificao.
Shared Preferences Escrita
Utilizando essa forma para armazenar informaes, possvel salvar entradas do tipo
chave-valor, onde se associa um nome a uma determinada informao para que depois
se possa recuper-la justamente atravs deste nome. O Android salva tudo em um arquivo
XML dentro da estrutura interna de disco em cada aplicao. Mas no precisamos nos
preocupar com leitura ou interpretao do XML, o Android oferece funes que abstraem
essas questes, deixando para o programador apenas a tarefa de salvar e depois buscar
novamente o que foi salvo. Essa opo indicada para poucas informaes e que sejam
simples, como nmeros, strings e valores booleanos. Por isso esse mecanismo
geralmente utilizado para armazenar as preferncias que o usurio definiu na aplicao.
1. private void salvarSharedPref(String texto, long numero) {
2.
3. // Cria ou abre.
4. SharedPreferences prefs =
getSharedPreferences("preferencias_1", Context.MODE_PRIVATE);
5.
6. // Precisamos utilizar um editor para alterar Shared
Preferences.
7. Editor ed = prefs.edit();
8.
9. // salvando informaes de acordo com o tipo
10. ed.putString("TEXTO", texto);
11. ed.putLong("NUMERO", numero);
12.
13. // Grava efetivamente as alteraes.
14. ed.commit();
15. }
Primeiro criamos (ou abrimos se j existir) o SharedPreferences informando o nome do
arquivo e o modo de acesso que ele deve ter. Depois criamos um Editor, que nada mais
que uma classe auxiliar para escrever no arquivo, e salvamos o que foi passado,
informando uma chave para cada informao. Por ltimo realizamos o commit, para
efetivamente escrever tudo no arquivo.
Storage Escrita
A opo do Storage nada mais que um espao em disco que cada aplicao tem onde
possvel salvar arquivos. Existe a opo do Internal Storage (espao na estrutura de
arquivos interna da aplicao, que o mesmo onde fica(m) o(s) arquivo(s) de Shared
Preferences) e do External Storage, que geralmente um espao no SDCard podendo
ser pblico (pastas de msica ou fotos por exemplo) ou da aplicao e nem sempre
estar disponvel (se o SDCard for removido, por exemplo). Os arquivos salvos dessa
forma possuem mais liberdade no que diz respeito ao QUE, QUANTO e DE QUE
FORMA os dados sero salvos, mas consequentemente se tem um pouco mais de trabalho
para manipul-los. Existem vrias maneiras (classes) disponveis de manipulao de
arquivos, mas vamos utilizar uma que acredito ser mais simples, principalmente por ter
mtodos que aceitam diretamente strings ao invs de apenas bytes.
1. private void salvarInternalStorage(String texto, long numero) {
2. FileWriter fileWriter = null;
3.
4. try {
5. // Cria o arquivo onde sero salvas as
informaes.
6. File file = new
File(getFilesDir().getPath()+"/arquivo_1.txt");
7. fileWriter = new FileWriter(file, true);
8.
9. fileWriter.append(texto);
10. fileWriter.append("n");// Quebra de
linha.
11.
fileWriter.append(String.valueOf(numero));
12.
13. // Escreve no arquivo.
14. fileWriter.flush();
15.
16. } catch (IOException e) {
17. Log.e("Erros", "Erro ao salvar usando
Internal Storage", e);
18. } finally {
19. // Fecha os recursos.
20. if (fileWriter != null) {
21. try {fileWriter.close();}
22. catch(Exception e){}
23. }
24. }
25. }
Primeiro criamos o arquivo no diretrio do Internal Storage (retornado pelo mtodo
getFilesDir()) e depois criamos uma instncia da classe auxiliar de escrita no arquivo,
informando que queremos usar o modo append (escreve a partir do fim do arquivo, sem
apagar ou sobrescrever o que j existia antes). Escrevemos uma informao em cada linha
(escrevendo a quebra de linha) para facilitar a leitura posteriormente, e efetivamos a
escrita das informaes no arquivo. O acesso a arquivos em disco pode gerar erros em
vrios pontos, por isso precisamos do tratamento de excees, mas por enquanto no
vamos abordar esse ponto.
1. private void salvarExternalStorage(String texto, long numero) {
2.
3. // Obtm o estado do storage.
4. String mediaState =
Environment.getExternalStorageState();
5.
6. // Testa se ele est disponvel.
7. if (mediaState.equals(Environment.MEDIA_MOUNTED)) {
8.
9. FileWriter fileWriter = null;
10. try {
11. // Cria o arquivo onde sero
salvas as informaes.
12. File file = new
File(getExternalFilesDir(null).getPath(), "/arquivo_2.txt");
13. fileWriter = new
FileWriter(file, true);
14.
15. fileWriter.append(texto);
16. fileWriter.append("n");// Quebra
de linha.
17.
fileWriter.append(String.valueOf(numero));
18.
19. // Escreve no arquivo.
20. fileWriter.flush();
21.
22. } catch (IOException e) {
23. Log.e("Erros", "Erro ao salvar
usando External Storage", e);
24. } finally {
25. // Fecha os recursos.
26. if (fileWriter != null) {
27. try {fileWriter.close();}
28. catch(Exception e){}
29. }
30. }
31. }
32. }
Para utilizar o External Storage, precisaramos apenas testar antes se ele est disponvel
e indicar o caminho correto na criao do arquivo. Para escrever nesse local ainda
precisamos adicionar uma permisso no Manifest da aplicao.
1. <uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-
permission>
Acessando O Que Foi Salvo
1. // Evento de clique do boto exibir.
2. public void botaoExibir(View view) {
3. // Instncia do elemento de opo
4. RadioButton opcaoSharedPreferences = (RadioButton)
findViewById(R.id.radioButton_SharedPref);
5.
6. // Cria o intent indicando qual a opo foi usada para
salvar os dados.
7. Intent intent = new Intent(this, SecondActivity.class);
8.
9. if (opcaoSharedPreferences.isChecked())
10. intent.putExtra("opcao", "shared_pref");
11. else
12. intent.putExtra("opcao", "int_storage");
13.
14. // Inicia a nova tela.
15. startActivity(intent);
16. }
De forma semelhante ao que fizemos para o boto Salvar (na verificao da opo) e para
passar informao para a prxima Activity (como utilizamos no post anterior), iniciamos
a nova tela passando a indicao de qual opo de armazenamento deve ser lida para
exibio dos dados:
1. @Override
2. protected void onCreate(Bundle savedInstanceState) {
3. super.onCreate(savedInstanceState);
4.
5. // Recupera o intent que iniciou a atividade e a
mensagem.
6. Intent intent = getIntent();
7. String opcao = intent.getStringExtra("opcao");
8.
9. String conteudoSalvo;
10. if (opcao.equalsIgnoreCase("shared_pref")) {
11. conteudoSalvo = acessaSharedPreferences();
12. } else {
13. conteudoSalvo = acessaInternalStorage();
14. }
15.
16. // Cria uma view para exibir as informaes salvas.
17. TextView textView = new TextView(this);
18. textView.setTextSize(30);
19. textView.setText(conteudoSalvo);
20.
21. // Define que o contedo exibido pela tela o
campo que
22. // ir exibir as informaes.
23. setContentView(textView);
24. }
Na criao da nova tela, vamos testar a opo passada e recuperar os dados da fonte
correspondente, exibindo em tela ao final.
Shared Preferences Leitura
1. private String acessaSharedPreferences() {
2. // Acesso s Shared Preferences usando o nome definido.
3. SharedPreferences prefs =
getSharedPreferences("preferencias_1", Context.MODE_PRIVATE);
4.
5. // Acesso s informaes de acordo com o tipo.
6. String texto = prefs.getString("TEXTO", "no
encontrado");
7. long numero = prefs.getLong("NUMERO", 0);
8.
9. // Formata um string com todo o contedo separado por
linha.
10. return (texto + "n" + numero);
11. }
Mais simples ainda que escrever no Shared Preferences ler as informaes dele. Basta
acess-lo da mesma forma e recuperar cada informao pela sua chave identificadora (o
seu nome), informando aps o que deve retornar caso nada seja encontrado para aquela
chave. Devolvemos tudo em um string s para simplificar.
Internal Storage Leitura
1. private String acessaInternalStorage() {
2.
3. String line;
4. String conteudo = "";
5.
6. BufferedReader br = null;
7. try {
8. // Acessa o arquivo.
9. br = new BufferedReader(new
FileReader(getFilesDir().getPath()+"/arquivo_1.txt"));
10.
11. // Faz a leitura, uma linha por vez, at
o fim do arquivo,
12. // gerando um string com todo o contedo
separado por linha.
13. while ((line = br.readLine()) != null) {
14. conteudo += line;
15. conteudo += "n";// Quebra de
linha.
16. }
17.
18. } catch (Exception e) {
19. Log.e("Erros", "Erro ao ler arquivo do
Internal Storage", e);
20. } finally {
21. if (br != null) {
22. try {br.close();}
23. catch(Exception e){}
24. }
25. }
26.
27. // Retorna o contedo do arquivo.
28. return conteudo;
29. }
Igualmente como ocorreu na escrita, vamos passar o caminho onde criamos o arquivo e
utilizar uma classe auxiliar (dessa vez de leitura de arquivos), alm de um buffer que vai
nos permitir fazer a leitura linha a linha (por isso salvamos separando por linhas) sem nos
preocuparmos com a quantidade que deve ser lida por vez.
Utilizamos ento um lao para ler o arquivo at o seu fim (quando o mtodo readLine()
retornar null).
No emulador ou em um dispositivo com root possvel ver o sistema de arquivos da
aplicao no Eclipse, atravs da perspectiva DDMS, na aba File Explorer. Cada aplicativo
possui uma pasta com o seu nome no caminho /data/data/. L voc vai encontrar os
arquivos que criamos e pode at export-los para o seu computador, utilizando o boto de
Salvar (cone de um disquete) no canto superior direito, podendo conferir o que foi salvo
pelo aplicativo.

A leitura do External Storage muito parecida com a que utilizamos no Internal, bastando
testar a disponibilidade e usar o caminho correspondente. A pasta onde os arquivos so
salvos nesse caso a /mnt/sdcard/Android/data//files/. Para testar o uso do External
Storage, apenas substitua os mtodos de escrita e leitura no cdigo da aplicao.

Para a maioria das aplicaes essas possibilidades de armazenamento so plenamente
suficientes, mas se for necessrio um mecanismo mais sofisticado, o Android possibilita
o uso de base de dados SQLite, mas isso j assunto para um outro post. At l!