Persistência no Android

Persistência
...
Armazenamento de Dados

Diversas opções para armazenar dados da aplicação.

A escolha de acordo com a necessidade:
 dados
privados ou públicos,
 quantidade
de espaço necessário,
 etc.
2
Armazenamento de Dados

Shared Preferences


• SQLite Databases


Armazena dados na web com o seu próprio servidor de rede.
• Internal Storage


Armazena dados estruturados em um banco de dados privado;
• Network Connection


Armazena dados primitivos em um conjunto de pares do tipo
chave – valor;
Armazena dados privados na memória do dispositivo;
• External Storage

Armazena dados públicos na mídia externa de armazenamento;
3
Shared Preferences

Provê um framework para salvar e recuperar pares de
dados primitivos do tipo chave-valor.

Dados armazenados mesmo quando a aplicação é
finalizada.

obter instância de SharedPreferences:

getSharedPreferences()


se precisar de múltiplos arquivos de preferências identificados por um
nome que é passado como parâmetro;
getPreferences()

se precisar de um único arquivo de preferências para a Activity. Como
se trata de um único arquivo, não é necessário fornecer um nome.
4
Shared Preferences
5
Utilizando o SharedPreferences para ler
informações

Uma string, nome, que será a chave para indicar o SharedPreferences
SharedPreferences prefs = getSharedPreferences (nome , modo );

modo: indica a permissão



0 - modo privado.
É possível utilizar vários SharedPreferences por aplicação
Para ler os dados

chamar o método get correspondente ao tipo de informação que você quer.

Em SharedPreferences você só pode armazenar informações de tipo primitivo e Strings.
String someString = prefs.getString (chave , null );
int someInt = prefs.getInt ( outraChave , 0);

O segundo parâmetro indica um valor padrão caso a chave não seja encontrada.
6
Utilizando o SharedPreferences para gravar
informações

Para salvar os dados no SharedPreferences é necessário usar
um editor.
SharedPreferences prefs = getSharedPreferences (nome , modo );
Editor editor = prefs . edit ();
editor.putString ("curso", “android");
editor.commit ();

É necessário chamar o método commit() no final, senão as
alterações não serão salvas.
7
ShardPreferences

Métodos
boolean contains(String key)
Retorna true caso a chave key exista.
boolean getBoolean(String key, boolean)
float getFloat(String key, float)
int getInt(String key, int)
long getLong(String key, long)
String getString(String key, String)
Retorna o valor de uma chave.
O segundo parâmetro indica o valor default que deve ser retornado
caso a chave não exista.
Note que é necessário que o desenvolvedor saiba o tipo do dado
armazenado na chave. Caso a chave exista mas o tipo seja
diferente do especificado no método será lançado um
ClassCastException.
SharedPreferences.Edit edit()
Retorna um editor para as preferências que permite editar e salvar
informações.
8
SharedPreferences.Editor

Usada para editar as preferências
boolean commit()
Salva as preferências no objeto SharedPreferences associado e em disco.
Operação síncrona, ou seja, só retorna após ter salvo em disco retornando
true em caso de sucesso, ou false senão.
void apply()
Aplica os novos valores das preferências ao objeto em memória e retorna. O
armazenamento em disco será feito de forma assíncrona, ou seja, não é
possível saber se houve algum error durante o armazenamento.
clear()
Remove todos os valores de preferências do objeto.
putBoolean(String key, boolean)
putFloat(String key, float)
putInt(String key, int)
putLong(String key, long)
putString(String key, String)
Adiciona ou altera o valor de uma chave. O nome do método e o segundo
parâmetro indicam o tipo do valor da chave.
remove(String key)
Remove a chave definida por key e consequentemente o seu valor.
9
Exemplo
//Restaura as preferencias gravadas
SharedPreferences settings =
getSharedPreferences(PREFS_NAME, 0);
etUsuario.setText(settings.getString("PrefUsuario", ""));
/**Chamado quando a Activity é encerrada.*/
@Override
protected void onStop(){
super.onStop();
//Caso o checkbox esteja marcado gravamos o usuário
CheckBox chkSalvar = (CheckBox)findViewById(R.id.chkSalvar);
if (chkSalvar.isChecked()){
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
SharedPreferences.Editor editor = settings.edit();
editor.putString("PrefUsuario", etUsuario.getText().toString());
//Confirma a gravação dos dados
editor.commit();
}
}
Banco de Dados SQLite

Android provê suporte completo a bancos de dados
SQLite.

Os bancos criados serão acessíveis pelo nome para
qualquer classe da aplicação, mas não poderão ser
acessados externamente.
11
Criando um banco de dados

Para se criar um banco de dados, pode-se usar o método
openOrCreateDatabase() do contexto.

É recomendado criar uma subclasse de SQLiteOpenHelper e sobrescrever o
método onCreate() para a criação das tabelas.
12
SQLiteOpenHelper

O construtor de SQLiteOpenHelper recebe quatro
parâmetros.

context


name


nome do database; null para database na memória
factory


Usado para abrir ou criar banco de dados
usado para criar cursores, or null para o padrão
version
Número da versão do database (começando de 1);
 A versão do banco de dados é muito útil para o caso de o banco já
existir e precisar ser atualizado (através da adição de novas tabelas
e/ou colunas, por exemplo).

13
SQLiteOpenHelper
 Com
uma instância dessa subclasse obtida por
meio do construtor criado, tem-se acesso a dois
métodos que retornam um SQLiteDatabase:
 getWritableDatabase()
 inserção,
edição e remoção de dados, e
 getReadableDatabase()
 consulta
de dados.
14
Consultas

Pode-se executar consultas no SQLite usando o método
query() de SQLiteDatabase




que permite a passagem de diversos parâmetros, tais como:
tabela a ser consultada, projeção, seleção, colunas,
agrupamento e outros.
Para consultas complexas, pode-se usar uma instância de
SQLiteQueryBuilder.
Cada consulta retorna um objeto Cursor que aponta para
todos os registros encontrados pela query. Por meio do
objeto Cursor que se navega entre os resultados.
Usam-se os métodos insert() e delete() de
SQLiteDatabase para inserção e remoção de registros,
respectivamente.
15
SQLiteDatabase - query()

As consultas com query() retornam um Cursor para
navegação e recebem diversos parâmetros, cada qual com
sua utilidade para a consulta.
16
SQL - Structured Query Language
Linguagem padrão para consulta a bancos de dados
 Construções básicas



SELECT Campo1, Campo2, ... FROM Tabela1, Tabela2 WHERE <condição>
ORDERBY CampoX;

INSERT INTO Tabela(Campo1, Campo2, ...) VALUES (Valor1, Valor2,
...);

DELETE FROM Tabela WHERE <condição>;

UPDATE Tabela SET Campo1 = <expressao1>, Campo2 = <expressao2>
WHERE <condição>;
Criação e exclusão de tabelas

CREATE TABLE Tabela (
id INTEGER PRIMARY KEY AUTOINCREMENT,
Campo1 Tipo1 [[UNIQUE] NOT NULL],
Campo2 Tipo2 [NOT] NULL,
...);

DROP TABLE IF EXISTS Tabela
[]=opcional
17
SQL

Exemplos de <expressão>
Preço – Taxas
 LENGTH(Tabela.Nome)
 Tabela.Idade IS [NOT] NULL


Exemplos de <condição>
(Nome = “Maria” OR Nome = “João”) AND Idade <= 40 AND Idade
>= 18
 LENGTH(Nome) > 4
 Preço – Taxas > 10.0


Tipos

INTEGER, REAL, TEXT
18
Criação do banco de dados

API do Android (executar SQL)


Adotado aqui pois permite criar pela aplicação
Cliente gráfico do SQLite

SQLite Expert Personal (gratuito)


Usando SQL via linha de comando

Programa na pasta do SDK do Android


www.softsland.com/sqlite_expert_personal.html
<pasta_android>\android-sdk-windows\tools\sqlite3.exe
Nos 2 últimos, após criar, é preciso mover o arquivo para a
pasta /data/data/<pacote>/databases do emulator

No eclipse (com emulador aberto):

Window > Show view > Other... > FileExplorer
19
Resumo da Classe SQLiteOpenHelper

Auxilia abertura e criação de um banco de dados
SQLiteOpenHelper(Context, String name,
SQLiteDatabase.CursorFactory,
int version)
Cria um objeto para auxiliar no gerenciamento da base de dados.
SQLiteDatabase getReadableDatabase()
Cria ou abre um banco de dados apenas para leitura.
SQLiteDatabase getWritableDatabase()
Cria ou abre um banco de dados para leitura e escrita.
void onCreate(SQLiteDatabase db)
Chamado quando o banco de dados precisa ser criado, ou seja, não
existe.
void onOpen(SQLiteDatabase db)
Chamado quando o banco de dados é aberto.
void onUpgrade(SQLiteDatabase db,
int oldVersion, int newVersion)
Chamado quando a versão do banco de dados sendo aberto é
diferente da versão existente.
20
Resumo da Classe SQLiteDatabase

Representa o banco de dados e executa operações de consulta, inclusão,
alteração e exclusão de registros
static SQLiteDatabase
openDatabase(String path,
CursorFactory factory, flags)
Abre banco de dados de acordo com os flags:
OPEN_READWRITE, OPEN_READONLY, CREATE_IF_NECESSARY,
NO_LOCALIZED_COLLATORS.
static SQLiteDatabase
openOrCreateDatabase(String path,
CursorFactory factory)
static SQLiteDatabase
openOrCreateDatabase(File file,
CursorFactory factory)
Abre ou cria banco de dados.
boolean
Verifica se está aberto
isOpen()
Equivalente a usar openDatabase(…) com
flags = CREATE_IF_NECESSARY
void close()
Fecha banco de dados
void execSQL(String sql)
Executa script SQL que não seja SELECT. Exemplo: CREATE
TABLE, INSERT, UPDATE, etc.
21
Resumo da Classe SQLiteDatabase
Cursor query(String table, String[] columns,
String selection, String[] selectionArgs,
String groupBy, String having,
String orderBy)
Cursor query(table, columns, selection,
selectionArgs, groupBy, having,
orderBy, limit)
Cursor query(boolean distinct, table, columns,
selection, selectionArgs, groupBy,
having, orderBy, String limit)
Mostra e executa um SQL de consulta na forma:
long insert(table, null, ContentValues values)
Insere um registro e retorna o id.
INSERT INTO <table> (values) VALUES (values)
int update(table, ContentValues values,
whereClause, whereArgs)
Altera registro(s) e retorna quantidade de linhas modificadas.
UPDATE <table> SET <values>
WHERE <whereClause+whereArgs>
int delete(table, whereClause, whereArgs)
Deleta registro(s) e retorna quantidade de linhas modificadas.
DELETE FROM <table>
WHERE <whereClause+whereArgs>
SELECT <distinct> <columns>
FROM <table>
WHERE <selection+selectionArgs>
GROUP BY <groupBy>
HAVING <having>
ORDER BY <orderBy>
LIMIT <limit>
22
Classes ContentValues e Cursor

ContentValues
 Usado
para armazenar o conteúdo de um registro para uma
operação
 Equivalente
 put(String

a um HashMap
key, valor)
Cursor
 Equivalente
 Lista
a um ResultSet no JDBC
de resultados de uma consulta no banco
23
Usando o SQLite
Para utilizar o SQLite, é necessário que você crie uma
subclasse de SQLiteOpenHelper.
 Em seguida é necessário sobrescrever os métodos
OnCreate() e OnUpgrade().

O
primeiro é chamado quando ainda não existe um banco
de dados, nele você deve incluir os comandos para criar
tabelas e inicializar qualquer tipo de dados, se preciso.
 O segundo é chamado quando a versão da base de dados é
alterada, e nele você deve incluir quaisquer comandos
relacionados à alteração do esquema, como alterações em
tabelas e colunas.
24
Exemplo
public class CustomSQLiteOpenHelper extends SQLiteOpenHelper {
public static final String TABLE_NOTES = " notes ";
public static final String COLUMN_ID = " _id ";
public static final String COLUMN_NOTES = " note ";
private static final String DATABASE_NAME = " notes .db";
private static final int DATABASE_VERSION = 1;
// Database creation sql statement
private static final String DATABASE_CREATE = " create table "
+ TABLE_NOTES + "(" +
COLUMN_ID
+ " integer primary key
autoincrement , “
+COLUMN_NOTES + " text not
null );";
public CustomSQLiteOpenHelper ( Context context ) {
super ( context , DATABASE_NAME , null , DATABASE_VERSION );
}
25
Exemplo
@Override
public void onCreate ( SQLiteDatabase database ) {
database . execSQL ( DATABASE_CREATE );
}
@Override
public void onUpgrade ( SQLiteDatabase db , int oldVersion , int
newVersion ) {
db. execSQL (" DROP TABLE IF EXISTS " + TABLE_NOTES );
onCreate (db);
}
}
26
Usando DAO (encapsular acesso ao DB)
public class NotesDao {
private SQLiteDatabase database ;
private String [] columns = { CustomSQLiteOpenHelper . COLUMN_ID ,
CustomSQLiteOpenHelper . COLUMN_NOTES
};
private CustomSQLiteOpenHelper sqliteOpenHelper ;
public NotesDao ( Context context ) {
sqliteOpenHelper = new CustomSQLiteOpenHelper ( context );
}
public void open () throws SQLException {
database = sqliteOpenHelper . getWritableDatabase ();
}
public void close () {
sqliteOpenHelper . close ();
}
27
Usando DAO
public Note create ( String note ) {
ContentValues values = new ContentValues ();
// inserindo na tabela
values . put ( CustomSQLiteOpenHelper . COLUMN_NOTES , note );
long insertId = database . insert ( CustomSQLiteOpenHelper . TABLE_NOTES , null , values );
// realizando leitura da nota inserida
Cursor cursor = database . query ( CustomSQLiteOpenHelper . TABLE_NOTES ,
columns , CustomSQLiteOpenHelper . COLUMN_ID + " = " + insertId , null , null , null , null );
cursor . moveToFirst ();
// criando uma Note para retornar
Note newNote = new Note ();
newNote . setId ( cursor . getLong (0) );
newNote . setNote ( cursor . getString (1) );
cursor . close ();
return newNote ;
}
28
Usando DAO
public void delete ( Note note ) {
long id = note . getId ();
database . delete ( CustomSQLiteOpenHelper . TABLE_NOTES ,
CustomSQLiteOpenHelper .COLUMN_ID + " = " + id , null );
}
public List <Note > getAll () {
List <Note > notes = new ArrayList <Note >() ;
Cursor cursor = database . query ( CustomSQLiteOpenHelper.TABLE_NOTES ,
columns , null , null , null , null , null );
cursor . moveToFirst ();
while (! cursor . isAfterLast ()) {
Note note = new Note ();
note . setId ( cursor . getLong (0) );
note . setNote ( cursor . getString (1) );
notes . add ( note );
cursor . moveToNext ();
}
cursor . close ();
return notes ;
} }
29