Utilizar o Debug do Android Studio num aparelho Android desconhecido

Olá pessoal!

Já faz um tempo que não posto por aqui e hoje vou deixar uma remodelada dica a respeito do que peguei neste blog sobre como colocar determinado tablet para entrar em modo debug no Android Studio.

Pois bem, o meu caso foi que precisei colocar o tablet Dell Vennue 8 para ser reconhecido no Android Studio porque só testar no meu aparelho celular não tava dando muito certo. Porém, precisei colocar também outro dispositivo desconhecido, um aparelho chamado Garmin Monterra e tive de fazer uma (pequena) alteração no procedimento ensinado pelo blog que peguei a informação.  “Mastiguei” ao máximo que pude o procedimento.

Vamos lá?

Ok!

Pré requisitos:

  • Entrar em modo desenvolvedor (vá em configurações  > sobre o dispositivo > clique 7 vezes no número de versão;
  • Verifique se o modo foi habilitado no Android;
  • Se estiver, habilite a depuração USB (em configuração>modo desenvolvedor > depuração USB);
  • No Pc, instale pelo Android SDK Manager o pacote Google USB Drivers;
  • Conecte seu dispositivo.

– Vamos até o Gerenciador de Dispositivos do Windows e localizamos o aparelho que queremos que nosso Android Studio reconheça para que possamos fazer Debug de nossas apps.

Garmin Monterra no Gerenciador de Dispositivos.

– Clicamos com o botão direito no dispositivo desejado e em seguida siga em Propriedades.

Garmin Monterra propriedades no Gerenciador de Dispositivos.

– Vá até a guia Detalhes e na caixa de Propriedade escolheremos IDs de Hardware.

ID de Hardware

– Copiamos os dois valores contidos na caixa Valor.

Valor de ID de hardware

– Na próxima estapa devemos procurar pelo arquivo android_winusb.inf e editá-lo. Em meu Windows 7 estava localizado em C:\Users\nome_do_meu_usuario\cminstaller\resources\drivers\usb_driver, mas este caminho pode variar de sistema para sistema.

Em seguida, procure a sessão onde está definida a configuração de ;Google Nexus (generic) e abaixo desta configuração (não do título da sessão) é que você deverá colocar o código parecido com o que está abaixo, porém com as informações de hardware do seu aparelho e não do meu.  Por isso lembre-se, essa aí abaixo é minha configuração e não a sua.


;Garmin Monterra
%SingleAdbInterface%     = USB_Install, USB\VID_091E&PID_2585&REV_0216&MI_01
%CompositeAdbInterface%  = USB_Install, USB\VID_091E&PID_2585&MI_01

Observe acima que existem duas variáveis (%SingleAdbInterface% e %CompositeAdbInterface%) que você terá de colocar para armazenar os valores que você copiou do seu ID de Hardware no Gerenciador de Dispositivos, na ordem que estavam. Repare bem o screenshot um pouco mais acima e o código logo abaixo dele, estão bem mastigados.

O que fazer quando você já fez este procedimento com outro dispositivo desconhecido?

Bem, quando você faz este procedimento somente em um dispositivo é tranquilo, mas quando você quer colocar um outro dispositivo desconhecido? Também é tranquilo, mas deve ser feita uma alteração no arquivo.

Repare (na figura abaixo) que já existiam duas variáveis com os mesmos nomes que usamos anteriormente (%SingleAdbInterface% e %CompositeAdbInterface%). E para resolver isso é simples, comente o código que apontava para o dispositivo que foi introduzido antes e adicione a linha que formatamos um pouco mais acima. Não se preocupe que o seu dispositivo anterior não irá perder o driver, pois ele já foi instalado no sistema operacional assim que foi dado o refresh do Gerenciador de Dispositivos.

android_winusb.inf

– Agora, volte no Gerenciador de Dispositivos, clique novamente com o botão direito no dispositivo desconhecido e em seguida em Atualizar Driver.

atualizar driver dispositivo

– Feito o procedimento acima, na caixa que se abrirá escolha o arquivo que foi inserida a informação do driver que deseja instalar.

atualizar driver de android_winusb.inf

– Aqui um detalhe importante de quando você for escolher qual será o driver utilizado. No blog que eu disse ter pegado a informação é dito que foi escolhido o driver com o nome ADB Interface e no meu caso escolhi Android Composite ADB Interface, portanto é bom que você perceba que podem ocorrer variações.

garmin novo driver

– E sim, no meio da instalação podem também acontecer avisos do Windows dizendo que não pôde verificar o driver. Sinceramente eu não tinha muito o que fazer, então deixei seguir.

driver não confiável

10º – Depois disso, clique em Fechar e finalize a instalação.

instalação driver finalizada.

11º – Quando voltar para o Gerenciador de Dispositivos pode ser que já esteja lá o dispositivo instaladinho e bonitinho ou o sistema operacional pode pedir para ser reiniciado assim como foi comigo e por aí vai. Se não funcionar de primeira refaça o procedimento com (mais) cuidado e (mais) carinho.  Outra observação que faço é que se você tiver plugado os dois dispositivos desconhecidos ao mesmo tempo, no Gerenciador de Dispositivos irá aparecer dois nomes iguais, portanto não temas.

dispositivo desconhecido reconhecido.

12º – E por fim, abra o Android Studio, ligue o Debug ou dê o Run. Eu pluguei os dois dispositivos desconhecidos (agora reconhecidos) para que todos vejam que não importa o número de dispositivos que você coloque, ele irá reconhecer todos após ter feito o procedimento correto.

garmin monterra on androi studio

Moral da história

Se você comprou aquele celular chinês de marca Android e quer usá-lo no Android Studio não temas! Existe uma esperança.

fonte: https://mastigado.wordpress.com

E claro, mais uma vez não poderia deixar de citar a fonte que inspirou este post:

fonte: http://cadnunsdimirdev.blogspot.com.br/2015/03/como-usar-seu-dell-venue-8-paratestar.html

Delimitar o tempo do Progress Dialog no Android

Olá pessoal!

Hoje eu vou deixar uma dica básica para quem precisa definir um tempo para exibição do Progress Dialog.

 progress = new ProgressDialog(this.context);
 progress.setTitle("AVISO!");
 progress.setMessage("Servidor Offline ou Aparelho com Wifi Desligado.");
 progress.show();

 Runnable progressRunnable = new Runnable() {
    @Override
    public void run() {
       progress.cancel();
    }
 };

 Handler pdCanceller = new Handler();
 pdCanceller.postDelayed(progressRunnable, 4000);

 progress.setOnCancelListener(new DialogInterface.OnCancelListener() {
    @Override
    public void onCancel(DialogInterface dialog) {
       progress.dismiss();
    }
 });

Eu naõ tenho muito o que dizer, o negócio tá mastigado. Para alterar o tempo basta alterar o valor onde está escrito 4000.

fonte: https://mastigado.wordpress.com

Outras refererências:

fonte: http://briandolhansky.com/blog/2013/7/11/snippets-android-async-progress
fonte: http://www.tutorialspoint.com/android/android_progress_circle.htm

Apagar histórico de uma Activity

Olá pessoal!

Essa dica vai para quem não quer que a próxima Activity ao ser chamada pela anterior, permita que você volte para a anterior utilizando a tecla “Voltar” do seu smarthphone.

fonte: https://mastigado.wordpress.com

O recurso é simples e (que eu conheça) existem duas maneiras para se fazer isso.

A primeira é você ir até a sua Activity chamada por uma anterior e sobreescrever o método onBackPressed() deste jeito:


@Override
public void onBackPressed() {

}

A segunda maneira é você ir até o seu arquivo AndroidManifest.xml e dentro da área onde sua Acitivity está identificada e inserir a instrução para que o histórico não seja gravado (android:noHistory=”true”). Algo assim:


<activity android:name=".ClassName" android:noHistory="true" ... />

Então tá aí, mastigado.

fonte: https://mastigado.wordpress.com

fonte: http://stackoverflow.com/questions/11308198/start-new-activity-and-finish-current-one-in-android

Banco de dados avançado fácil e rápido com ORM no Android

Olá pessoal!

Bem, dando continuidade ao trabalho do blog Mobsource, darei continuidade ao seu trabalho (re) publicando o post referente a banco de dados 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://blog.mobsource.com.br/2014/07/banco-de-dados-facil-e-rapido-com-orm.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>() ;

fonte: https://mastigado.wordpress.com

fonte: http://blog.mobsource.com.br/2014/07/banco-de-dados-avancado-facil-e-rapido.html

Banco de dados fácil e rápido com ORM no Android

Olá pessoal!

Hoje irei reproduzir um post na íntegra de um blog  que me ajudou muito chamado “mobsource”, mas que saiu do ar recentemente. E para compartilhar o conhecimento, vou deixar o post que fala sobre ORM Lite aqui (porém ainda assim deixarei o link no final da página).

fonte: https://mastigado.wordpress.com

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.

fonte: https://mastigado.wordpress.com

fonte: http://blog.mobsource.com.br/2014/07/banco-de-dados-avancado-facil-e-rapido.html

Android Studio: Background task running indefinitely

Olá pessoal!

fonte: https://mastigado.wordpress.com

 

Esta dica vai para quem está programando utilizando o Android Studio e vez ou outra tem problema com a rotina de background task da IDE que fica “agarrada”, principalmente quando você insere novas librarys.

 

Vá até o menu arquivo e clique em:

Invalidate Caches / Restart option

 

fonte: http://stackoverflow.com/questions/17834821/android-studio-background-task-running-indefinitely

fonte: https://mastigado.wordpress.com

Acessando seu banco de dados no Android com aSQLite Manager

Olá pessoal! Boi noite 🙂

Esta vai para quem está trabalhando com Android e tá afim de saber como as coisas estão sendo gravadas no sqlite.

fonte: https://mastigado.wordpress.com

Você deverá baixar o aplicativo aSQLite Manager no Google Play, aqui vai o link:

https://play.google.com/store/apps/details?id=com.xuecs.sqlitemanager&hl=pt_BR

Ele funciona muito bem, mas a surpresa que é você vai precisar habilitar o modo root do celular para poder acessar o diretório /data/data que é onde ficam as bases de dados dos aplicativos que você desenvolve.

Pois bem, aí vai um jogo rápido de como como colocar em rooted o Samsung Galaxy S3 Mini GT-I8200L (que é o mais problemático):

Root no Samsung Galaxy S3 Mini GT-I8200L de forma linda, maravilhosa e descomplicada!

  1. Primeiro baixe o aplicativo Vroot na versão 1.79 ou superior para PC;
  2. Habilite o modo de desenvolvedor no Android (Entrando na opção Sobre o dispositivo e em seguida clicando freneticamente na opção Nº de compilação);
  3. No modo desenvolvedor que se abrirá, habilite a depuração (modo debug);
  4. E instale o aplicativo que você baixou (Vroot) no seu computador  e com o celular ligado no cabo usb;
  5. Daí você instala no pc e manda bala até ele escrever alguma coisa tipo “complete” e reiniciar o seu celular (você pode tentar ver se esta opção de download te server: http://chinagadgetsreviews.blogspot.com.br/2014/09/download-vroot-latest-version-179.html).

Bem, voltando ao nosso foco, baixe o aplicativo SuperSU do Android e instale logo após o procedimento acima. Aqui vai o link:

https://play.google.com/store/apps/details?id=eu.chainfire.supersu&hl=pt_BR

Depois de ter instalado o SuperSu, execute o aplicativo SQLite Manager que você poderá abrir as pastinhas onde estão os bancos de dados e ver algo tipo isso (quando tentar acessar um tabela):

sqlitemanagerShow!

fonte: https://mastigado.wordpress.com

%d blogueiros gostam disto: