Assista o Google IO 2013

Acompanhe por aqui as novidades do Google IO 2013 !!!

Android e XML em 4 passos

Olá pessoal, nesse tutorial aprenderemos a ler e interpretar arquivos XML no Android.
Antes de começarmos a fazer um exemplo, é preciso deixar claro que a plataforma disponibiliza mais de uma tecnologia(parser) para se trabalhar com XML, tais como, DOM, SAX, XMLPULLPARSER etc.
Usaremos o parser DOM, que não é o mais rápido, mas com certeza é o mais indicado para quem está iniciando, devido a sua facilidade de uso.
Caso você não conheça XML, aqui vai um bom local para começar a aprender... http://www.w3schools.com/xml/ e caso você já conheça... lá vamos nós... :)


Passo 1. Criando o projeto

Crie um projeto Android com o nome ProjetoXML.
(File > New > Other > Android > Android Application Project)


Passo 2. Criando o arquivo XML

Abra seu editor de textos(ou xml) preferido e crie um arquivo chamado conteudo.xml com a estrutura exemplificada.

<?xml version="1.0"?>
<contatos>
   <contato>
      <nome>StrangerDroidBlog</nome>
<apelido>StrangerDroid</apelido>
      <site>http://strangerdroid.blogspot.com.br/</site>
   </contato>
   <contato>
      <nome>SaiuDaGaragemBlog</nome>
      <apelido>SaiuDaGaragem</apelido>
      <site>http://www.saiudagaragem.com.br/</site>
   </contato>
</contatos>

Note que na estrutura temos:
- Uma lista de contatos (2 contatos)
- Cada contato possui uma série de características (nome, apelido e site)


Passo 3. Embarcando o arquivo

Copie o arquivo para a pasta assets do seu projeto


Passo 4. Lendo e interpretando o conteúdo XML

Coloque um botão na sua interface e no evento de clique, faça a chamada da função demonstrada.

private void processarConteudoXML() {

  try {

    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();    

    DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); 
    Document doc = dBuilder.parse(getAssets().open("conteudo.xml"));

    doc.getDocumentElement().normalize();

    NodeList nodeContatos = doc.getElementsByTagName("contato");

    int counter = nodeContatos.getLength();

    for (int i=0; i<counter; i++) {

        Node item = nodeContatos.item(i);

        if (item.getNodeType() == Node.ELEMENT_NODE) {

            Element element = (Element) item;

            Node nodeNome = element.getElementsByTagName("nome").item(0).getChildNodes().item(0);

            Toast.makeText(getApplicationContext(), nodeNome.getNodeValue(), Toast.LENGTH_LONG).show();

        }

    }

  }catch(Exception e){

     e.printStackTrace();

  }

}

Note que criamos instâncias de DocumentBuilderFactory e DocumentBuilder para preparar a entrada do conteúdo XML dentro de Document, onde parseamos as informações que estão no arquivo (conteudo.xml) na pasta assets.
Na parte final, antes de começarmos a ler, executamos o comando normalize que limpa eventuais informações desnecessárias a estrutura.
Carregamos todas as tags nomeadas "contato" e percorremos a lista de itens localizados.
Ao carregar cada tag localizada, verificamos se ela é do tipo Element para que possamos fazer a leitura da tag "nome" e por fim exibirmos seu valor em um Toast.
Bastante simples, não é mesmo?
É claro que estruturas mais complexas e extensas, tais como feeds RSS serão lidos mais rapidamente se usarem XMLPULLPARSER ao invés de DOM.
Caso você tenha interesse em saber como funciona o parser XMLPULLPARSER, verifique essa URL http://developer.android.com/training/basics/network-ops/xml.html
Caso tenha dúvidas, envie-nos um email em strangerdroid@gmail.com

Um grande um abraço e bons estudos. :)

StrangerDroid

Realidade Aumentada com Android e VUFORIA SDK

Vuforia SDK, guarde esse nome !
Há algum tempo estava pesquisando sobre SDKs de realidade aumentada e resolvi testar essa ferramenta fantástica de desenvolvimento.
Nesse tutorial vou ensinar como baixar todos os recursos necessários e preparar todo o ambiente para o desenvolvimento com esse SDK.
Vamos compilar o projeto desse aplicativo... http://www.youtube.com/watch?v=42MvJ1QgPz8 (ImageTargets).
Ele funciona de uma forma muito interessante.
Na programação dele existe código nativo(ndk), que faz reconhecimento de imagens e projeta no espaço reconhecido um modelo 3D e toda a movimentação da câmera física interfere na câmera do modelo 3D.
Assistam o vídeo... com certeza vai ser mais fácil de entender. :)
Vai encarar essa? Então aí vamos...

Passo 1. Baixando as ferramentas

1. Além do Android SDK, precisaremos do Android NDK que você pode encontrar no seguinte link http://developer.android.com/tools/sdk/ndk/index.html
Após baixá-lo descompacte em um local de sua preferência.

2. Entre no site da Qualcomm (quem desenvolveu o SDK) e crie uma conta. https://developer.qualcomm.com/user/register

3. Após criar a conta, baixe o SDK nessa URL https://ar.qualcomm.at/qdevnet/sdk/android (no meu caso baixei a versão para Windows) e faça a instalação a padrão.

4. Precisaremos do cygwin para compilar o projeto NDK. Faça o download nessa URL http://cygwin.com/install.html.
Durante a instalação, ao exibir os pacotes, selecione o pacote que fica em All -> Devel -> "make: The GNU version of the 'make' utility" clique em "SKIP" para tirar essa opção e a ferramenta ser instalada e siga a instalação.

Passo 2. Importando o projeto no eclipse

- Abra o eclipse e crie um projeto a partir de um código fonte existente. (File > New > Other > Android > Android Project from Existing Code)

- Em Root Directory aponte para o projeto ImageTargets que está dentro do diretório de instalação na pasta samples e clique em Finish. (no meu caso... \development\Android\vuforia-sdk-android-1-5-9\samples\ImageTargets)

- Você perceberá que o projeto contém um erro, para arrumá-lo clique com o botão direito no projeto e vá em Properties > Java Build Path > Libraries e remova a referência de QCAR.jar e depois clique em Add External Jars.
Esse arquivo poderá ser localizado na pasta de instalação em build > java > QCAR (no meu caso... \development\Android\vuforia-sdk-android-1-5-9\build\java\QCAR\QCAR.jar) e clique em OK.

- Abra a pasta que contém esse arquivo e copie para a pasta libs do seu projeto. (Ctrl+C e Ctrl+V)
Crie essa pasta caso não exista (botão direito no seu projeto > New > Folder) e então copie o arquivo.

Passo 3. Compilando o código NDK

Para compilar o código NDK criaremos um arquivo de lotes.
Crie um arquivo chamado build-project.bat e coloque o conteúdo demonstrado.


@echo on

@set BASHPATH="C:\cygwin\bin\bash"
@set PROJECTDIR="/cygdrive/c/Development/Android/vuforia-sdk-android-1-5-9/samples/ImageTargets"
@set NDKDIR="/cygdrive/c/Development/android-ndk-r8b/ndk-build"

%BASHPATH% --login -c "cd %PROJECTDIR% && %NDKDIR%

@pause:


Faça as seguintes alterações:
- Mude o valor de BASHPATH de acordo com o diretório que você fez a instalação do cygwin.
- Mude PROJECTDIR para o diretório do projeto ImageTargets
- Mude NKDIR para o diretório onde descompactou o NDK.

Salve o arquivo e dê dois cliques para abrir.
Caso ocorra algum erro, verifique se seguiu corretamente todos os passos descritos acima.


Passo 4. Limpando e rodando o projeto

Volte para o eclipse, clique no projeto ImageTargets e vá em Project > Clean e depois clique em Ok.
Abra a pasta chamada "media" do projeto e imprima o conteúdo do arquivo target_stones_A4.pdf.
Se você seguiu corretamente todos os passos, clique em Run e a aplicação será inicializada.
Aponte sua câmera para impressão e veja o que acontece.
Quer ver algo interessante? Mantenha seu aparelho parado e mova a folha.

É claro que desenvolver com essa ferramenta não é algo trivial como talvez já tenham notado, mas no site da Qualcomm é possível localizar muito material a respeito do desenvolvimento com o VUFORIA SDK.
Além disso é possível encontrar alguns projetos no Google Play que usa essa tecnologia.
Vejam o resultado de uma customização nesse sample. :)





Bom.. por hoje é só pessoal, espero que tenham gostado. :)
Qualquer problema ou dificuldade, entrem em contato através do email strangerdroid@gmail.com

Nos vemos na próxima.

StrangerDroid

Android: Acessando banco de dados fácil e rápido com ORM ! (Avançado)

Olá amigos, vamos a mais um artigo sobre como trabalhar com Android e banco de dados.
Caso você não tenha lido a primeira parte, sobre como criar a camada de acesso a dados, aí vai o link http://strangerdroid.blogspot.com.br/2012/10/android-acessando-banco-de-dados-facil.html.
Nessa segunda postagem, vamos falar sobre conceitos mais avançados a respeito da ferramenta ORMLite.
Se você fez o exemplo do primeiro artigo, imagino que você tenha se perguntado: "OK, mas como uso uma clausula 'where', 'order' ou 'join'?".
Sem dúvida, essa é uma pergunta muito pertinente !
Na maioria das ferramentas ORM é possível executar todos esses comandos sem escrever nenhuma linha de código sql, no ORMLite não é diferente.
Para exemplificar, usaremos o projeto do artigo anterior, ok?
Vamos fazer mais exemplos?

Passo 1. Usando WHERE para filtrar suas consultas

Abra o arquivo ClientesDAO no package dao. (no meu caso está no package br.com.exemplo.db.dao)
Vamos escrever um método que filtre os resultados apenas dos clientes com sobrenome iguais a "Silva".
Faça a implementação como no exemplo.



public List<Clientes> getBySobreNomeSilva() {
List<Clientes> clientes = new ArrayList<Clientes>();

try{
QueryBuilder<Clientes, Integer> queryBuilder = dao.queryBuilder();
queryBuilder.where().eq("sobrenome", "Silva");
clientes = dao.query(queryBuilder.prepare());
}catch(Exception e){
e.printStackTrace();
}

return clientes;
}

Nesse método retornamos uma lista de Clientes.
Criamos um objeto do tipo QueryBuilder onde trabalharemos com o tipo Clientes e a PK dele é do tipo integer.
Este objeto é responsável pela clausula 'where sobrenome seja igual (eq) "Silva"'.
O último passo é enviar essas informações para a classe dao do ORMLite processar a query.
Simples, não é? Nenhuma linha SQL. :) Próximoooooo.....


Passo 2. Ordenando a sua consulta

No próximo exemplo vamos ordenar o resultado da nossa consulta trazendo todos os registros de clientes ordenando pelo primeiro nome.


public List<Clientes> getByNome() {
List<Clientes> clientes = new ArrayList<Clientes>();

try{
QueryBuilder<Clientes, Integer> queryBuilder = dao.queryBuilder();
queryBuilder.orderBy("nome", false);
clientes = dao.query(queryBuilder.prepare());
}catch(Exception e){
e.printStackTrace();
}

return clientes;
}




A única coisa que muda nesse caso é que chamamos o método "orderBy" que recebe os parâmetros do campo que será ordenado e se ele será "asc" ou "desc". (crescente ou decrescente).


Passo 3. Misturando as coisas

Digamos agora que eu quero o último registro da tabela clientes, como faço?
Notem a facilidade.


public Clientes getLast() {
Clientes cliente = new Clientes();

try{
QueryBuilder<Clientes, Integer> queryBuilder = dao.queryBuilder();
queryBuilder.orderBy("id", true);
cliente = dao.queryForFirst(queryBuilder.prepare());
}catch(Exception e){
e.printStackTrace();
}

return cliente;
}


Fazemos uma query que ordena pelo campo id de forma invertida(trazendo o último até o primeiro) e por fim pegamos o primeiro registro disponível que seria o último inserido.
Pouco código e tudo o que precisamos na mão.


Passo 4. Criando a classe para fazer o join

Vamos supôr que nosso cliente tenha vários endereços que estão armazenados em outra tabela.
Crie no seu package entities a classe Enderecos. (no meu caso, br.com.exemplo.db.entities)


@Entity(name="enderecos")
public class Enderecos {

@Id @GeneratedValue
private int id;

@Column(name="endereco", nullable=false)
private String endereco;

@Column(name="cep", nullable=false)
private String cep;

@DatabaseField(foreign=true)
private Clientes clientes;

public Enderecos() {

}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getCep() {
return cep;
}

public void setCep(String cep) {
this.cep = cep;
}

public Clientes getClientes() {
return clientes;
}

public void setClientes(Clientes clientes) {
this.clientes = clientes;
}

public String getEndereco() {
return endereco;
}

public void setEndereco(String endereco) {
this.endereco = endereco;
}

}


Notem que temos um campo diferente dessa vez !
O campo DataBaseField indica uma FK para a tabela Clientes.
Atenção, a notação DataBaseField é do componente ORMLite e não da JPA.
Se você me perguntar o por que, tenho uma boa resposta.
Nem todas as notações JPA estão disponíveis na ferramenta ORMLite.  =(


Passo 5. Inserindo a tabela na criação da database

Abra o arquivo DataBaseHelper no package connection. (no meu caso br.com.exemplo.db.connection).
Iremos acrescentar a tabela Enderecos como mostrado abaixo.


public class DataBaseHelper<E> extends OrmLiteSqliteOpenHelper {

public DataBaseHelper(Context context) {
super(context, "sistema.db", null, 1);
}

@Override
public void onCreate(SQLiteDatabase db, ConnectionSource src) {
try{
TableUtils.createTable(src, Clientes.class);
TableUtils.createTable(src, Enderecos.class);
}catch(Exception e){
e.printStackTrace();
}
}

@Override
public void onUpgrade(SQLiteDatabase db, ConnectionSource src, int oldVersion, int newVersion) {
try{
TableUtils.dropTable(src, Clientes.class, true);
TableUtils.dropTable(src, Enderecos.class, true);
onCreate(db, src);
}catch(Exception e){
e.printStackTrace();
}
}

@Override
public void close() {
super.close();
}

}

Inserimos uma linha para Create e outra para Upgrade. Nenhum segredo. :)



Passo 6. Criando um DAO para Enderecos

Crie uma classe chamada EnderecosDAO no seu package dao (no meu caso, br.com.exemplo.db.dao)
Faça a implementação como exemplificado.


public class EnderecosDAO extends GenericDao<Enderecos> {

public EnderecosDAO(Context context) {
super(context, Enderecos.class);
}

}



Segue o mesmo modelo de implementação que fizemos no artigo anterior.



Passo 7. Inserindo a referência em Clientes

Precisamos agora inserir a referência no objeto Clientes, ou seja, quando carregarmos um cliente, automaticamente ele deverá carregar uma lista de enderecos. (join)
Abra o arquivo Clientes na pasta entities (no meu caso, br.com.exemplo.db.entities) e faça a modificação conforme demonstrado.


@Entity(name="clientes")
public class Clientes {

    @Id @GeneratedValue
private int id;

    @Column(name="nome", nullable=false)
private String nome;

    @Column(name="sobrenome", nullable=false)
private String sobrenome;

    @Column(name="email", nullable=false)
private String email;
    
    @ForeignCollectionField(eager=false)
    private Collection<Enderecos> enderecos;

public Clientes() {

}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getNome() {
return nome;
}

public void setNome(String nome) {
this.nome = nome;
}

public String getSobrenome() {
return sobrenome;
}

public void setSobrenome(String sobrenome) {
this.sobrenome = sobrenome;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public Collection<Enderecos> getEnderecos() {
return enderecos;
}

public void setEnderecos(Collection<Enderecos> enderecos) {
this.enderecos = enderecos;
}
}

A notação ForeignCollectionField (também da ORMLite e não JPA) faz todo o trabalho.
Ela indica que uma coleção de Enderecos será carregado de forma síncrona(eager=false) toda vez que o objeto Clientes for carregado.


Passo 8. Testando tudo



Antes de testar esse exemplo, remova completamente o aplicativo usado no artigo anterior, ok?
Abra a sua Activity e crie um método como o demonstrado.


    private void testarDB() {
    ClientesDAO daoCli = new ClientesDAO(getApplicationContext());
    Clientes cliente = new Clientes();
    cliente.setNome("StrangerDroid");
    cliente.setSobrenome("Blog");
    cliente.setEmail("strangerdroid@gmail.com");
   
    daoCli.insert(cliente);
    cliente = daoCli.getById(1);
   
    EnderecosDAO daoEnd = new EnderecosDAO(getApplicationContext());
    Enderecos endereco1 = new Enderecos();
    endereco1.setEndereco("Rua da casa");
    endereco1.setCep("234324");
    endereco1.setClientes(cliente);
   
    Enderecos endereco2 = new Enderecos();
    endereco2.setEndereco("Rua da outra casa");
    endereco2.setCep("454545");
    endereco2.setClientes(cliente);
   
    daoEnd.insert(endereco1);
    daoEnd.insert(endereco2);
   
    Clientes clientes = daoCli.getLast();
   
    if (clientes.getEnderecos() != null) {
    Toast.makeText(getApplicationContext(), Integer.toString(clientes.getEnderecos().size()), Toast.LENGTH_LONG).show();
    }

Esse método é responsável por:
- Inserir um cliente chamado "StrangerDroid"
- Inserir dois endereços para esse cliente
- Carregar novamente esse cliente.

E por último ele exibe o número de endereços do usuário.
Se tudo correu bem, ele deve exibir o numero 2 ! :) (dois endereços para o cliente "StrangerDroid")
Quando carregamos o cliente, ele trouxe os endereços. (join)
Talvez você esteja se perguntando: "Legal, mas como uso uma Collection?".
Muito simples, List<Enderecos> enderecos = new ArrayList<SuaCollection>() ; e seja feliz. rs

Aos que tiverem dúvidas, entrem em contato no endereço strangerdroid@gmail.com
Um abraço a todos e nos vemos na próxima.

StrangerDroid

Android e JSON simples e descomplicado

O formato JSON além de ser o mais leve para o intercâmbio de dados computacionais, também é suportado pelas bibliotecas nativas do Android.
Para aplicativos que fazem troca de dados online, com certeza esse é o formato mais indicado, pois sua aplicação irá transferir apenas os dados realmente necessários com uma quantidade muito pequena de bytes.
Caso você não conheça o formato JSON, aí vai uma boa referência... http://www.w3schools.com/json/default.asp.
Desenvolvedores que conhecem a linguagem XML sentirão muita facilidade em entender.
Mas vamos fazer um exemplo ?

Passo 1. O conteúdo JSON

{
"employees": [
{ "firstName":"John" , "lastName":"Doe", age:20 }, 
{ "firstName":"Anna" , "lastName":"Smith", age: 30 }, 
{ "firstName":"Peter" , "lastName":"Jones", age: 40 }
]
}

Note que na estrutura temos:
- Um array com o nome employees.
- Uma lista de três objetos.
- Propriedades de cada objeto.


Passo 2. Escrevendo uma classe employee

Crie uma classe no seu projeto com o nome Employee e faça a implementação demonstrada.


public class Employee {

private String firstName;
private String lastName;
private int age;

public Employee() {

}

public String getFirstName() {
return firstName;
}

public Employee setFirstName(String firstName) {
this.firstName = firstName;
return this;
}

public String getLastName() {
return lastName;
}

public Employee setLastName(String lastName) {
this.lastName = lastName;
return this;
}

public int getAge() {
return age;
}

public Employee setAge(int age) {
this.age = age;
return this;
}

}

Usamos na implementação dessa classe o padrão Fluent Interface.

Caso não conheça, aí vai uma referência... http://en.wikipedia.org/wiki/Fluent_interface.

Passo 3. Embarcando o conteúdo

Vá no seu projeto em: res/values e abra o arquivo strings.xml.
Abra mais uma tag string (com o nome "employeesjson") e coloque o conteúdo do passo 1 como exemplificado abaixo.


<string name="employeesjson">{
"employees": [
{ "firstName":"John" , "lastName":"Doe", age:20 }, 
{ "firstName":"Anna" , "lastName":"Smith", age: 30 }, 
{ "firstName":"Peter" , "lastName":"Jones", age: 40 }
]
}</string>



Passo 4. Escrevendo uma função que leia o JSON

Na sua Activity faça a implementação da função demonstrada.


private List<Employee> getEmployees() {
    List<Employee> employees = new ArrayList<Employee>();
   
    try{
    String conteudo = getString(R.string.employeesjson);
    JSONArray arrayOfEmployees = new JSONObject(conteudo).getJSONArray("employees");
   
    for (int i=0; i<arrayOfEmployees.length(); i++) {
    JSONObject employeeObject = arrayOfEmployees.getJSONObject(i);
    employees.add(new Employee().setAge(employeeObject.getInt("age"))                                             .setFirstName(employeeObject.getString("firstName"))                     .setLastName(employeeObject.getString("lastName")));
    }
    }catch(Exception e){
    e.printStackTrace();
    }
   
    return employees;
    }


Nessa função retornamos uma lista de employees.
Carregamos o conteúdo do strings.xml através do comando getString e parseamos com o objeto JSONArray para percorrer todos os itens, lendo seus parâmetros e adicionando na lista.
Esse método faz o mapeamento de todo o conteúdo JSON e o transforma em objetos.
Mais uma dica simples e descomplicada de ser feita. :)
Caso tenha dúvidas, entre em contato conosco através do email strangerdroid@gmail.com
Nos vemos na próxima.

StrangerDroid

Android: Acessando banco de dados fácil e rápido com ORM !

Ainda me lembro quando comecei a desenvolver Android e me deparei com documentações informando como acessar um banco de dados. (SQLite)

A primeira impressão foi: "Uau, parece ser bem simples".

E foi ! O único problema é que toda a camada de acesso a dados fica na responsabilidade do desenvolvedor e com isso muito código precisaria ser escrito para ter uma camada de dados consistente e de fácil entendimento e manutenção.

Por conta desse tipo de situação resolvi pesquisar há algum tempo, alguma ferramenta que desse ao desenvolvedor a facilidade de programar usando ORM.... ferramentas como o Linq da linguagem C#, Hibernate (e suas muitas variações).

No fim das contas acabei encontrando uma ferramenta muito boa, com portabilidade para Android e que simplifica toda a escrita da camada de dados de um projeto.

A ferramenta que encontrei se chama ORMLite. http://ormlite.com/

Ela funciona de forma muito simples ! Em resumo são esses os passos:

1. Você cria o seu DataBaseHelper (classe responsável para criar o banco de dados, informando o nome da database, as tabelas e ações de upgrade do banco de dados).

2. Você cria suas classes (que serão as tabelas) usando anotações da própria ferramenta ou a parte mais legal da ferramenta... ELA ACEITA JPA ! (caso não saiba o que é jpa aí vai uma boa referência... http://imasters.com.br/artigo/21505/java/utilizando-hibernate-jpa-no-desenvolvimento-em-java--mysql)

3. Você cria suas classes Dao e passa a fazer todo o CRUD em poucas linhas.

E pronto é só usar ! rs

Mas bom... não vamos ficar só nisso, vamos fazer um exemplo !

Passo 1. Baixando as ferramentas

Faça o download dos arquivos ormlite-android-4.41.jar e ormlite-core-4.41.jar no site

http://ormlite.com/releases/  (se houver alguma versão mais recente não tem problemas)

Faça o download do arquivo hibernate-jpa-2.0-api-1.0.1.Final.jar que você encontra

no pacotes de instalação do hibernate para java.http://www.hibernate.org/downloads (também não tem problemas se você pegar uma versão mais nova)

Passo 2. Reconhecendo no projeto

Copie esses arquivos para a pasta libs do seu projeto e faça a referência a elas clicando com o botão  direito no seu projeto e logo após Properties.

Clique no item Java Build Path e depois clique em Libraries.

Clique no botão Add JARs...

Abra a pasta libs do seu projeto e selecione os arquivos.

Passo 3. Escrevendo as entidades

Crie um package no seu projeto para criar as entidades que serão as tabelas da database. (coloque o nome que preferir. No meu caso ficou assim: br.com.exemplo.db.entities)

Crie uma classe chamada Clientes como a descrita abaixo:

@Entity(name="clientes")

public class Clientes {

 @Id @GeneratedValue

private int id;

 @Column(name="nome", nullable=false)

private String nome;

 @Column(name="sobrenome", nullable=false)

private String sobrenome;

 @Column(name="email", nullable=false)

private String email;

public Clientes() {

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getNome() {

return nome;

}

public void setNome(String nome) {

this.nome = nome;

}

public String getSobrenome() {

return sobrenome;

}

public void setSobrenome(String sobrenome) {

this.sobrenome = sobrenome;

}

public String getEmail() {

return email;

}

public void setEmail(String email) {

this.email = email;

}

}

Note a simplicidade na implementação da classe. Usamos:

- Entity para definir a classe como tabela.

- Id e GeneratedValue para criar a PK e dizer que ela é auto-incremento.

- Column e Nullable para dizer que se trata de uma coluna que não pode ser nula.

Simples não?

Passo 4. Escrevendo a classe helper

Crie um package para armazenar a classe responsável por criar o banco de dados. (no meu caso ficou assim... br.com.exemplo.db.connection)

Crie uma classe com o nome DataBaseHelper e faça a implementação como o exemplo.

public class DataBaseHelper<E> extends OrmLiteSqliteOpenHelper {

public DataBaseHelper(Context context) {

super(context, "sistema.db", null, 1);

}

@Override

public void onCreate(SQLiteDatabase db, ConnectionSource src) {

try{

TableUtils.createTable(src, Clientes.class);

}catch(Exception e){

e.printStackTrace();

}

}

@Override

public void onUpgrade(SQLiteDatabase db, ConnectionSource src, int oldVersion, int newVersion) {

try{

TableUtils.dropTable(src, Clientes.class, true);

onCreate(db, src);

}catch(Exception e){

e.printStackTrace();

}

}

@Override

public void close() {

super.close();

}

}

Note que criamos a classe herdando de OrmLiteSqliteOpenHelper e criamos o banco de dados("sistema.db") com a tabela Clientes. 

Passo 5. Escrevendo a classe dao

Crie um package para armazenar suas classes dao. (no meu caso ficou assim... br.com.exemplo.db.dao)

Crie uma classe chamada GenericDao que será nossa classe base e faça a implementação demonstrada.

public abstract class GenericDao<E> extends DataBaseHelper<E> {

protected Dao<E, Integer> dao;

private Class<E> type;

public GenericDao(Context context, Class<E> type) {

super(context);

this.type = type;

setDao();

}

protected void setDao() {

try{

dao = DaoManager.createDao(getConnectionSource(), type);

}catch(Exception e){

e.printStackTrace();

}

}

public List<E> getAll() {

try{

List<E> result = dao.queryForAll();

return result;

}catch(Exception e){

e.printStackTrace();

return null;

}

}

public E getById(int id) {

try{

E obj = dao.queryForId(id);

return obj;

}catch(Exception e){

e.printStackTrace();

return null;

}

}

public void insert(E obj) {

try{

dao.create(obj);

}catch(Exception e){

e.printStackTrace();

}

}

public void delete(E obj) {

try{

dao.delete(obj);

}catch(Exception e){

e.printStackTrace();

}

}

public void update(E obj) {

try{

dao.update(obj); 

}catch(Exception e){

e.printStackTrace();

}

}

}

Note que essa classe já deixa pronta todos os métodos básicos para acesso ao banco de dados. (só precisamos escrever uma vez)

Agora vamos implementar a nossa classe dao.

Crie uma classe chamada ClientesDAO e faça a implementação como demonstrado.

public class ClientesDAO extends GenericDao<Clientes> {

public ClientesDAO(Context context) {

super(context, Clientes.class);

}

}

Note a quantidade pequena de linhas que precisamos para escrever a classe dao de clientes.

Passo 6. Inserindo um cliente

Coloque um botão no seu projeto e faça a implementação demonstrada no evento de clique.

     ClientesDAO dao = new ClientesDAO(getApplicationContext());

    Clientes cliente = new Clientes();

    cliente.setEmail("strangerdroid@gmail.com");

    cliente.setNome("Stranger");

    cliente.setSobrenome("Droid");

    dao.insert(cliente);

Ao fazer isso o banco de dados é criado na pasta "databases", as tabelas são criadas e você acabou de inserir um registro.

Se você pedir o comando "dao.getAll()" ele retornará uma List<Clientes>. :)

Fora isso, agora você tem métodos para fazer delete, update, select todos prontos.

Espero que esse artigo possa ajudá-lo a iniciar o desenvolvimento com a ferramenta OrmLite.

Além do que demonstramos podemos fazer diversas outras coisas sem escrever nem uma linha sequer de código sql.

Aos que tiverem problemas me enviem emails no strangerdroid@gmail.com que terei prazer em ajudá-lo.

Até a próxima. :)

StrangerDroid