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

Armazena dados primitivos em um conjunto de pares do tipo chave – valor;

• SQLite Databases

Armazena dados estruturados em um banco de dados privado;

• Network Connection

Armazena dados na web com o seu próprio servidor de rede.

• Internal Storage

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

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.

O segundo parâmetro indica um valor padrão caso a chave não seja encontrada.

6

SharedPreferences prefs = getSharedPreferences (nome , modo );

String someString = prefs.getString (chave , null );

int someInt = prefs.getInt ( outraChave , 0);

Utilizando o SharedPreferences para gravar

informações Para salvar os dados no SharedPreferences é necessário usar

um editor.

É necessário chamar o método commit() no final, senão as

alterações não serão salvas.

7

SharedPreferences prefs = getSharedPreferences (nome , modo );

Editor editor = prefs . edit ();

editor.putString ("curso", “android");

editor.commit ();

Métodos

ShardPreferences

8

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.

Usada para editar as preferências

SharedPreferences.Editor

9

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.

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

Usado para abrir ou criar banco de dados

name

nome do database; null para database na memória

factory

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 []=opcional

CREATE TABLE Tabela ( id INTEGER PRIMARY KEY AUTOINCREMENT, Campo1 Tipo1 [[UNIQUE] NOT NULL], Campo2 Tipo2 [NOT] NULL, ...);

DROP TABLE IF EXISTS Tabela

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)

www.softsland.com/sqlite_expert_personal.html

Usando SQL via linha de comando

Programa na pasta do SDK do Android

<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

20

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.

Resumo da Classe SQLiteDatabase

Representa o banco de dados e executa operações de consulta, inclusão,

alteração e exclusão de registros

21

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.

Equivalente a usar openDatabase(…) com

flags = CREATE_IF_NECESSARY

boolean isOpen() Verifica se está aberto

void close() Fecha banco de dados

void execSQL(String sql) Executa script SQL que não seja SELECT. Exemplo: CREATE

TABLE, INSERT, UPDATE, etc.

Resumo da Classe SQLiteDatabase

22

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:

SELECT <distinct> <columns>

FROM <table>

WHERE <selection+selectionArgs>

GROUP BY <groupBy>

HAVING <having>

ORDER BY <orderBy>

LIMIT <limit>

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>

Classes ContentValues e Cursor

ContentValues

Usado para armazenar o conteúdo de um registro para uma

operação

Equivalente a um HashMap

put(String key, valor)

Cursor

Equivalente a um ResultSet no JDBC

Lista 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

25

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

Exemplo

26

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

Usando DAO (encapsular acesso ao DB)

27

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

Usando DAO

28

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

Usando DAO

29

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