sexta-feira, 1 de novembro de 2013

Conheça as novidades do Android 4.4 KitKat (english)


quarta-feira, 24 de julho de 2013

Implementando uma ActionBarActivity no Android




Antes de mais nada.... estamos de volta !
Caros amigos, nesse artigo estarei explicando como implementar uma ActionBar no Android.
Com certeza você já viu uma ActionBar em algum aplicativo que já usou.
Ela é aquela barra no topo da aplicação que dispõe de uma série de recursos que enriquecem seu aplicativo.
Se quiser saber mais a respeito consulte essa URL: http://developer.android.com/guide/topics/ui/actionbar.html
Esse recurso está disponivel nativamente desde a versão 3.0 (não há versão nativa para versões anteriores deste recurso).
A maioria das pessoas acaba usando uma biblioteca muito conhecida chamada ActionBar Sherlock.
É verdade que ela é muito boa, porém na última atualização de APIs temos uma ActionBar compatível com versões anteriores do Android, tornando desnecessário o uso dessa API.
Antes de começarmos o nosso exemplo, não esqueça de atualizar seu Android SDK para incrementar a versão 4.3 (que acabou de sair) através do Android SDK Manager (atualize os demais recursos também)... não esqueça de atualizar também o seu ADT (indo no eclipse em Help -> Check for Updates).




Passo 1. Importando o android.support.v7.appcompat

Para importar esse pacote que contém todo o necessário para o desenvolvimento desse exemplo vá em File -> New -> Other -> Android -> Application Project from Existing Code e clique no botão Next.
Para selecionar a pasta clique no botão Browse e direcione para o local onde você instalou o seu Android SDK (MeuDiretorioSDK/extras/android/support/v7/appcompat). Clique no botão OK e em seguida em Finish.
Talvez você se pergunte: - "Eu não posso jogar o .jar direto em libs ?"
Bom... nesse caso, você terá que importar todos os resources do projeto android.support.v7.appcompat para o nosso projeto.
Acredito que quando você ver a lista de coisas que você deverá trazer para o nosso projeto, vai concordar comigo que desse jeito que fizemos é muito mais fácil e prático. :)



Passo 2. Criando nosso projeto

Vá em File -> New -> Other -> Android -> Android Application Project e crie o projeto.
Não esqueça de marcar o Target SDK e Compile With com a API 18 (Android 4.3) !
Mantenha o item Minimum Required SDK para a API 8 (Android 2.2)




Passo 3. Inserindo o pacote android.support.v7.appcompat  ao nosso projeto

Clique com o botão direito no projeto e vá em Properties -> Android.
Na parte inferior da janela em Reference, clique no botão Add e escolha o pacote android.support.v7.appcompat e clique em OK.



Passo 4. Editando o tema do projeto

Para utilizar a ActionBar compatível temos que adequar o estilo do projeto.
Vá na pasta res -> values -> styles.xml.
Altere a linha <style name="AppBaseTheme" parent="android:Theme.Light"> para <style name="AppBaseTheme" parent="@style/Theme.AppCompat.Light.DarkActionBar">
Isso fará que a Actionbar fique escura e os demais recursos do projeto de cores claras.

Passo 5. Programando a ActionBar

Abra a classe da sua Activity (no meu caso... MainActivity) e faça as alterações demonstradas.
Tomem cuidado com os imports.


Esse é o resultado final (Android 2.3)...



Passo 6. Explicando

Ao criar a activity obtemos uma instância da ActionBar através do comando getSupportActionBar.
No método setObjects definimos um ícone para ela (pode ser qualquer outro que você importe no projeto).
Definimos um título. (lembrando que o melhor lugar para strings é no arquivo strings.xml e carregando através do comando getString)
Por último colocamos o parâmetro HomeAsUp que serve para voltar para a Activity anterior(sem utilidade implementada dessa forma. Coloquei apenas para mostrar a existência do recurso).
Nesse tutorial explicamos de forma simples e limitada a implementação da ActionBar.
Em artigos posteriores iremos aprofundar o assunto.
Espero que esse tutorial seja de ajuda para muitos de vocês.
Caso você não conheça, nós temos uma página no facebook com conteúdo exclusivo para programadores android, corre lá ! http://www.facebook.com/StrangerDroidBlog



domingo, 4 de novembro de 2012

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


domingo, 28 de outubro de 2012

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


quinta-feira, 25 de outubro de 2012

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




terça-feira, 23 de outubro de 2012

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


segunda-feira, 22 de outubro de 2012

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