Artigos Mobile Utilizando SQLite em aplicativos Android
Por que eu devo ler este artigo:O armazenamento de informações é útil em diferentes tipos de aplicações e vem ganhando cada vez mais força em aplicativos mobile. A plataforma mobile traz diferentes opções de recursos que podem ser utilizados para realizar a persistência dos dados. Neste artigo conheceremos em detalhes como podemos trabalhar com o SQLite. Veremos através de um estudo de caso como utilizar seus recursos.

O uso dos smartphones cresceu muitos nos últimos anos. Isso acarretou em um grande esforço dos fabricantes em melhorias no hardware e, das gigantes de software em um reposicionamento quanto aos sistemas operacionais para estes tipos de dispositivos. Esse cenário gerou uma bola de neve que trouxe grandes e constantes inovações no setor, refletindo cada vez mais em usuários e desenvolvedores 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 (na memória do smartphone) e externo (cartão de memória). Ambos podem ser muito úteis para fazer armazenamento de imagens, por exemplo. No caso do uso do 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 estas 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. No Android o banco de dados mais utilizado é o SQLite.

SQLite

O SQLite é um banco de dados simples e poderoso, formatado para ser executado na plataforma móvel. Este é um repositório de dados que simula um banco de dados relacional. Na prática, os dados são armazenados de forma binária, entretanto, isto funciona de forma transparente ao usuário. Ela é a principal forma de persistência para aplicativos Android.

O SQLite é formado por um conjunto de bibliotecas escritas em C, podendo ser integrado a programas escritos em diferentes linguagens com o intuito de possibilitar a manipulação de dados através de instruções SQL. A diferença para os outros bancos é que tudo isso pode ser feito sem que seja preciso acessar um SGBD (Sistema de Gerenciamento de Banco de Dados), ou seja, todas as instruções podem ser executadas diretamente via código fonte, como criação do banco e de tabelas, sendo por este motivo adotado como o banco de dados nativo da plataforma Android.

Na prática, o SQLite é um mini-SGBD, capaz de criar um arquivo, ler e escrever diretamente nele. O SQLite já está disponível na plataforma Android, não necessitando de instalação, configuração ou administração, suporta commit e rollback, além de ser um banco de dados gratuito.

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. Para exemplificar o uso do SQLite, um aplicativo de cadastro de notas será desenvolvido.

O projeto

Para apresentar o SQLite, foi desenvolvido um projeto com nome UsandoSQLite. Como classe principal do projeto, foi criado o PrincipalActivity.java, com a interface activity_principal.xml. Também foi criada uma Activity para apresentar as informações do banco em uma lista, este chamado de ListaActivity.java, com tela activity_lista.xml, conforme a Figura 1.

Figura 1. Tela principal do aplicativo.

A tela principal do aplicativo será formada por três campos: código, nome da disciplina e nota, além de cinco botões: incluir, alterar, excluir, pesquisar e listar.

O campo chave primária do nosso aplicativo é o campo código, sendo este obrigatório para as operações de alterar, excluir e pesquisar. Já para a operação de incluir este campo não é necessário, já que este será AUTOINCREMENT na tabela, ou seja, será incrementado a cada execução. Por fim, como a opção de listar apresenta todos os dados dentro do banco, para esta operação o campo código não precisa ser preenchido.

O aplicativo procura apresentar as funcionalidades do banco de dados SQL, sendo este executado a partir de métodos específicos para inclusão, alteração, e assim por diante. Existe uma maneira mais elaborada para usar o SQLite, a partir da classe SQLiteOpenHelper, que será vista ao final do artigo. A Listagem 1 apresenta o código da tela principal do aplicativo.

Listagem 1. activity_principal.xml – Interface gráfica do tela principal do aplicativo.


  01.       <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  02.           xmlns:tools="http://schemas.android.com/tools"
  03.           android:layout_width="match_parent"
  04.           android:layout_height="match_parent"
  05.           android:orientation="vertical"
  06.           tools:context=".PrincipalActivity" >
  07.        
  08.           <TextView
  09.               android:layout_width="wrap_content"
  10.               android:layout_height="wrap_content"
  11.               android:text="Cód.:" />
  12.           
  13.           <EditText
  14.               android:id="@+id/etCod"
  15.               android:layout_width="fill_parent"
  16.               android:layout_height="wrap_content"
  17.               android:inputType="number"/> 
  18.               
  19.           <TextView
  20.               android:layout_width="wrap_content"
  21.               android:layout_height="wrap_content"
  22.               android:text="Nome Disciplina:" />
  23.           
  24.           <EditText
  25.               android:id="@+id/etNomeDisciplina"
  26.               android:layout_width="fill_parent"
  27.               android:layout_height="wrap_content"
  28.               android:inputType="textCapWords"/>  
  29.               
  30.           <TextView
  31.               android:layout_width="wrap_content"
  32.               android:layout_height="wrap_content"
  33.               android:text="Nota:" />
  34.           
  35.           <EditText
  36.               android:id="@+id/etNota"
  37.               android:layout_width="fill_parent"
  38.               android:layout_height="wrap_content"
  39.               android:inputType="numberDecimal"/>      
  40.           
  41.           <LinearLayout 
  42.               android:layout_width="wrap_content"
  43.               android:layout_height="wrap_content"
  44.               android:orientation="horizontal">
  45.          
  46.                <Button
  47.                    android:id="@+id/btIncluir"
  48.                    android:layout_width="wrap_content"
  49.                    android:layout_height="wrap_content"
  50.                    android:text="Incluir" 
  51.                    android:onClick="btIncluirOnClick"/>
  52.                
  53.                <Button
  54.                    android:id="@+id/btAlterar"
  55.                    android:layout_width="wrap_content"
  56.                    android:layout_height="wrap_content"
  57.                    android:text="Alterar" 
  58.                    android:onClick="btAlterarOnClick"/>
  59.                
  60.                <Button
  61.                    android:id="@+id/btExcluir"
  62.                    android:layout_width="wrap_content"
  63.                    android:layout_height="wrap_content"
  64.                    android:text="Excluir" 
  65.                    android:onClick="btExclui ...

Quer ler esse conteúdo completo? Tenha acesso completo