Artigos Android Desenvolvendo um programa de cadastro usando SQLite e Adapters
Por que eu devo ler este artigo:

Construiremos um aplicativo completo para gerenciamento de artigos publicados. Nesta aplicação iremos considerar as quatro operações básicas no banco de dados, chamadas conceitualmente de CRUD (Create, Read, Update e Delete).

O leitor deste artigo estará apto a fornecer uma arquitetura correta de persistência de dados através de banco de dados relacionais no Android. Este é um quesito muito importante para qualquer profissional que deseje ser visto com bons olhos pelo exigente mercado mobile.

O uso dos smartphones cresceu muitos nos últimos anos. Isso acarretou em um grande esforço das fabricantes em melhorias no hardware e das gigantes de software um reposicionamento quanto aos sistemas operacionais para estes tipos de dispositivos. E isso gerou uma bola de neve que trouxe grandes e constantes inovações no setor, refletindo cada vez mais em usuários e desenvolvedores mais satisfeitos com as novas tecnologias, que os permitem ficar mais tempo conectados.

Isso também teve outra consequência direta: os usuários passaram a armazenar seus dados não só nos computadores Desktop, mas também em seus smartphones. Logo, estes dispositivos passaram a receber uma quantidade maior e crescente de dados. Principalmente dados de áudio e mídia.

Logicamente, as plataformas móveis perceberam que teriam que fornecer métodos de persistência de dados mais sofisticados que o tradicional armazenamento baseado em arquivos, como acontecia com o RMS (Record Management System), este utilizado pelos programadores Java ME/MIDP para a persistência dos dados. Hoje em dia, todas as principais plataformas oferecem mais de uma maneira de salvar e recuperar informações produzidas por nossos aplicativos.

Com a plataforma Android não poderia ser diferente. Este fornece diferentes métodos de persistência. Alguns deles são através de armazenamento interno (no smartphone) e externo (cartão de memória). Ambos podem ser muito úteis para fazer armazenamento de imagens, por exemplo. No caso de armazenamento em cartão, deve-se atentar para não utilizá-los no armazenamento de informações essenciais para o correto funcionamento do aplicativo, pois a mídia pode ser removida a qualquer momento, e o aplicativo deixará de ser executado.

Além disso, a plataforma também fornece as classes chamadas SharedPreferences, sendo esta uma forma de persistir pares de chave/valor para todos os tipos primitivos Java e mais o tipo String. Algo semelhante à utilização de Properties na programação Java tradicional. Seu uso e funcionamento são muito simples, podendo ser muito útil para persistências simples, como a pontuação de um jogo, por exemplo.

Porém, o SharedPrefererences não é indicado para grande quantidade de dados ou conjunto de informações com grande complexidade. Nesse momento entram em ação os bancos de dados relacionais, utilizados há alguns anos em outros ambientes, como web e desktop, por exemplo. No Android o banco de dados mais utilizado é o SQLite.

Uma característica interessante da plataforma é que o SQLite já está disponível na plataforma Android, não havendo necessidade de instalá-lo. Além disso, o Android oferece suporte completo ao banco, através de uma API com um rico conjunto de classes e métodos que abstraem as complexidades dos códigos SQL. Assim, não precisamos montar a cláusula SQL inteira para atualizar uma linha na tabela, ou ainda, para fazer uma pesquisa na mesma. O Android nos fornece um método, onde passando alguns parâmetros obtemos um apontador para os dados retornados, podendo navegar pelo resultado como se estivéssemos escolhendo uma folha em um arquivo.

Assim, o objetivo deste artigo é apresentar uma forma simples de utilizar o banco de dados SQLite na plataforma Android. Aqui apresentaremos as principais classes do Android no uso do SQLite: SQLiteOpenHelper e SQLiteDatabase e como utilizá-las dentro de um Activity.

Para uma compreensão melhor, o leitor construirá um aplicativo completo para gerenciamento de artigos publicados. Desta forma, veremos como fazer as quatro operações básicas no banco de dados, chamadas conceitualmente de CRUD (Create, Read, Update e Delete) e ao final do artigo serão apresentadas as transações exclusivas.

O projeto

Todo escritor gosta de arquivar suas publicações e organizar quais estão pendentes, quais estão sendo revisados, quais estão prontos para publicações e quais já estão nas bancas. Então, o projeto que vamos criar neste estudo de caso é um gerenciador de artigos, este chamado de “ManagerArticles”.

O funcionamento é bem simples. Na primeira tela teremos uma lista com os artigos cadastrados e a opção de inserir um novo registro, conforme Figura 1. Tanto o botão adicionar como a opção de editar apresentará a tela mostrada na Figura 2. A diferença é que no caso da edição os campos são preenchidos com o conteúdo armazenado no banco de dados.

Tela principal do aplicativo
Figura 1. Tela principal do aplicativo
Tela para cadastro/edição de artigos
Figura 2. Tela para cadastro/edição de artigos

Construindo a aplicação sem o banco de dados

Inicialmente vamos construir os elementos e as telas da aplicação, sem nos preocuparmos com o banco de dados

A classe utilitária Artigo

O primeiro passo será a construção de uma classe Artigo. Ela será utilizada em diferentes pontos do nosso aplicativo. Isso porque o nosso banco de dados terá as ações CRUD (Create, Read, Update e Delete) que envolvem os mesmos atributos, relacionados a mesma entidade. Desta forma, a classe Artigo será uma “visão” da tabela Artigo em um banco de dados relacional tradicional. Veja a Listagem 1.


  01.  import java.io.Serializable;
  02.  
  03.  public class Artigo implements Serializable {
  04.   private static final long serialVersionUID = 1633833011084400384L;
  05.   int id;
  06.   String revista;
  07.   String nome;
  08.   String edicao;
  09.   int status;
  10.   int pago;   
  11.  }
Listagem 1. Artigo.java – Classe responsável pelo armazenamento dos campos da tabela

Perceba que os atributos desta classe são os mesmos apresentados na Figura 2. Isso porque ao inserir um novo artigo temos que definir o nome, a revista e edição onde foi/serão publicados, seu status e se o mesmo já foi pago ou não ao autor.

O atributo serialVersionUID é utilizado porque a classe implementa a interface Serializable, assim, se fez necessário este atributo para que possamos enviar uma instância da mesma como um extra de uma Intent.

Layouts das telas

O segundo passo é criar os arquivos XML que representam as duas telas da aplicação, estas apresentadas nas Figura 1 e 2. A Listagem 2 apresenta o código da tela responsável para inclusão e alteração de um registro.


  01.<?xml version="1.0" encoding="utf-8"?>
  02.<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  03.    android:layout_width="match_parent"
  04.    android:layout_height="match_parent"
  05.    android:orientation="vertical" >
  06.
  07.    <TextView
  08.        android:id="@+id/textView1"
  09.        android:layout_width="wrap_content"
  10.       android:layout_height="wrap_content"
  11.      android:text="Nome:" />
  12.
  13.    <EditText
  14.        android:id="@+id/edtNome"
  15.        android:layout_width="match_parent"
  16.        android:layout_height="wrap_content"
  17.        android:ems="10" >
  18.    </EditText>
  19.
  20.    <TextView
  21.        android:id="@+id/textView2"
  22.        android:layout_width="wrap_content"
  23.        android:layout_height="wrap_content"
  24.        android:text="Revista:" />
   
  25.    <EditText
  26.        android:id="@+id/edtRevista"
  27.        android:layout_width="match_parent"
  28.        android:layout_height="wrap_content"
  29.        android:ems="10" />
  30.
  31.    <TextView
  32.        android:id="@+id/textView3"
  33.        android:layout_width="wrap_content"
  34.        android:layout_height="wrap_content"
  35.        android:text="Edição:" />
  36.
  37.    <EditText
  38.        android:id="@+id/edtEdicao"
  39.        android:layout_width="match_parent"
  40.        android:layout_height="wrap_content"
  41.        android:ems="10"
  42.        android:inputType="number" />
  43.
  44.    <TextView
  45.        android:id="@+id/textView4"
  46.        android:layout_width="wrap_content"
  47.        android:layout_height="wrap_content"
  48.        android:text="Status:" />
  49.
  50.    <Spinner
  51.        android:id="@+id/spEstado"
  52.        android:layout_width="match_parent"
  53.        android:layout_height="wrap_content"
  54.        android:entries="@array/status" />
  55.
  56.    <CheckBox
  57.        android:id="@+id/cbPago"
  58.        android:layout_width="wrap_content"
  59.        android:layout_height="wrap_content"
  60.        android:text="Pago" />
  61.
  62.    <Button
  63.        android:id="@+id/button1"
  64.        android:layout_width="wrap_content"
  65.        android:layout_height="wrap_content"
  66.        android:text="Salvar"
  67.        android:onClick="salvar"
  68.        android:layout_gravity="center_horizontal" />
  69. </LinearLayout>
Listagem 2. novo_edicao.xml – Tela para incluir ou alterar um registro

Na primeira linha temos o cabeçalho XML. Na linha 2 temos o TextView que servirá de contêiner a todos os outros elementos de UI que serão apresentados na tela. Como desejamos um layout onde um componente é posicionado abaixo do outro, utilizamos o ...

Quer ler esse conteúdo completo? Tenha acesso completo