Este documento resume os principais conceitos para desenvolvimento de aplicações Android, incluindo: 1) Android SDK, layouts XML, atividades e ciclo de vida, content providers, emulador; 2) Desenvolvimento de uma aplicação de anotações rápidas chamada Quick Notes utilizando estas ferramentas. 3) Integração da aplicação com banco de dados SQLite através de um content provider próprio.

1. Android Core
Felipe Silveira
felipesilveira.com.br Aula 6

2. Aplicações I

3. Desenvolvimento de Aplicações

4. Android SDK
SDK
https://developer.android.com/sdk

5. Android SDK
Android SDK:
● Eclipse +
● ADT plugin +
● Android platform-tools +
● A última versão das interfaces do application
framework +
● A última imagem para o emulador

6. Android SDK
Instalação: descompacte o arquivo e execute o executável
eclipse, localizado no diretório eclipse:

7. Hello World

8. Criando o projeto
Passo 1 – Criando o projeto no Eclipse
Abra o Eclipse, vá até File > New > Project
Na tela que aparecer, escolha “Android Project” e clique em “Next”.

9. Criando o projeto

10. Criando o projeto
Após isso, irá aparecer a tela
com as configurações de seu
projeto android.
Nesta tela, você irá inserir o
nome da sua aplicação, o
package e as versões de
android que ela irá suportar.
Após preencher os campos,
clique em Next

11. Criando o projeto
A próxima tela contém opções
para criação do ícone da
aplicação e a localização do
projeto.
Após preencher os campos,
clique em Next

12. Criando o projeto
Na próxima tela, é possível
configurar o ícone padrão da
aplicação.
Após preencher os campos,
clique em Next

13. Criando o projeto
A próxima tela contém as
opções da Activity a ser criada.
Após preencher os campos,
clique em Next

14. Criando o projeto
Por fim, a última tela do
assistente de criação permite
que seja alterado o nome da
Activity principal da aplicação a
ser criada.
Após preencher os campos,
clique em Finish

15. Criando o projeto
Após isso, será criado o projeto android já com a activity principal:

16. Criando o projeto
E com seu respectivo layout, escrito em XML:

17. Emulador
Uma ferramenta muito útil para teste das aplicações é o emulador, que é
parte do SDK Android.
Para usarmos o emulador, é preciso antes entender o conceito de AVD -
Android Virtual Device. O AVD serve para "representar" um dispositivo real, ou
seja, ele vai ter as suas características, como tamanho de tela, quantidade de
memória, etc.
Dessa forma, o primeiro passo para a execução do emulador é a criação de
um AVD, sobre o qual o emulador funcionará.
Para isso, vamos usar o Android Virtual Devices Manager.

18. Emulador

19. Emulador
Na tela para a criação do AVD, é necessário escolher um nome, que
representará o AVD, e o "target", que é versão de android que rodará nele. Só
são mostradas as versões de android instaladas na máquina local pelo SDK
Manager.
Também é necessário escolher o tamanho para o SD Card e o tamanho de
tela. essas opções podem ficar como no screenshot a seguir.

20. Emulador

21. Emulador
Depois de criado o AVD, basta selecioná-lo na lista e clicar em "Start..."

22. Emulador
Na próxima tela, existem opções para mudar a escala da tela do emulador e
para apagar os dados do usuário, gravados em uma execução anterior (Wipe
user data)

23. Emulador

24. Compilando/Executando
Para compilar e executar o projeto, clique com o botao direito no nome do
projeto, e clique em Run As > Android Application

25. Quick Notes

26. Quick Notes
Para estudarmos os principais componentes de uma aplicação Android,
faremos a partir de agora uma aplicação completa.
A aplicação será chamada de Quick Notes, e irá prover ao usuário uma
interface simples para entrada de textos que serão armazenados para
posterior visualização.
Em outras palavras, uma ferramenta de anotações rápidas.

27. Quick Notes
A interface da tela principal do QuickNotes será a seguinte:
Insira um texto... SALVAR
Texto 1
Texto 2
Texto 3
Texto 4
Texto 5
Texto 6
Texto 7

28. Layout
Em android, existem duas formas de se definir o layout de uma tela:
● Através do próprio código java da aplicação
● Através de arquivos XML que "descrevem" a tela
Seguir a segunda forma é uma boa prática, pois ajuda o desenvolvedor a
separar o código da UI da lógica do aplicativo.
Para armazenar os arquivos XML citados, já existe um folder dedicado no
projeto android, em res/layout. Desse diretório já contém um XML criado por
padrão, com o conteúdo a seguir

29. Layout

30. Layout
No arquivo activity_main.xml, temos contato com os primeiros elementos de
um arquivo de layout XML:
● LinearLayout, que é apenas um container.
● TextView, que é um elemento de texto. Nesse caso está imprimindo a
string cujo id é @string/hello.
Para criar um layout parecido com o que queremos, iremos inserir outros
dois elementos:
● EditText – uma caixa de texto onde o usuário irá entrar com as anotações;
● ListView – uma lista de anotações previamente submetidas.

31. Layout
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical"
>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
>
<EditText
android:id="@+id/edit_box"
android:layout_width="330px"
android:layout_height="wrap_content"
android:text=""
>
</EditText>
<Button
android:id="@+id/insert_button"
android:layout_width="150px"
android:layout_height="wrap_content"
android:text="Inserir"
>
</Button>
</LinearLayout>
<ListView
android:id="@android:id/list"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
</ListView>
</LinearLayout>

32. Layout - carregando o XML
Para que a nossa aplicação tenha o layout definido pelo arquivo XML, é
preciso carregá-lo.
Isso é feito através da função setContentView(), como no código abaixo:
1. public void onCreate(Bundle savedInstanceState) {
2. super.onCreate(savedInstanceState);
3. setContentView(R.layout.main);
4. }
O parâmetro R.layout.main indica que o arquivo de layout a ser carregado é o
main.xml. (Se o se arquivo se chamar abobrinha.xml, o parâmetro deverá ser
R.layout.abobrinha)

33. Activity
Agora é a hora de conhecer uma das mais importantes classes de uma
aplicação Android: A classe Activity.
Uma Activity é basicamente uma classe gerenciadora de UI (Interface com o
usuário). Todo aplicativo android começa por uma Activity.
Ou seja, quando uma aplicação android é executada, na verdade é a sua
Activity principal que é lançada.
A primeira coisa que deve-se conhecer sobre a Activity é o seu ciclo de vida,
ilustrado no diagrama a seguir:

34. Activity Lifecycle

35. Content Providers
Os Content Providers são parte importantíssima da arquitetura de um
sistema android. É responsabilidade deles prover às aplicações o conteúdo
que elas precisam para funcionar, ou seja, os dados.
Mas por que são realmente necessários?
As aplicações poderiam muito bem acessar diretamente um banco de dados,
por exemplo. Porém, é uma boa prática tornar o modo como os dados são
gravados transparente à aplicação. Dessa forma, a aplicação pode manter o
foco nas interações com o usuário.
Além disso, essa técnica permite a criação de Shared Content Providers, que
são providers “públicos” que podem ser acessados por várias aplicações. Por
exemplo, existe o content provider de SMS/MMS que permite a qualquer
aplicação ler as mensagens recebidas por um telefone celular.

36. Content Providers
E como é feita a comunicação entre Content Providers e Aplicações?
Através de uma Uri
Toda a comunicação entre aplicações e providers é feita através dos métodos
da interface ContentProvider, que sempre recebem um objeto Uri como
parâmetro. O formato da Uri é definido pelo content provider.
Por exemplo, a Uri content://sms/inbox acessa as mensagens de inbox no
Content Provider de SMS. Falaremos um pouco mais sobre as Uris a seguir,
mas primeiro, vamos conhecer os métodos que usaremos para enviá-las para
o provider:

37. Content Providers
● query(Uri, String[], String, String[], String)- usado para recuperar dados.
● insert(Uri, ContentValues) – usado para inserir dados.
● update(Uri, ContentValues, String, String[]) – usado para atualizar dados.
● delete(Uri, String, String[]) – usado para deletar dados.
● getType(Uri) – usado para obter o MIME type de certo dado.

38. Content Providers
Com a construção do content provider, a arquitetura do quick notes ficará
assim:

39. Estrutura das Uris
Uma Uri usada para acessar Content Provider segue o formato:
content://<authority>/<parametros>
Onde authority é o “nome” do provider, e os parâmetros são aqueles
definidos pelo provider. Por exemplo, a seguinte Uri:
content://sms/conversations/10
Acessa o Content Provider de SMS, e seleciona a conversation de Id número
10.

40. Criando um Content Provider
Para criar seu próprio content provider, é preciso fazer 2 coisas:
1. Criar uma sub-classe da ContentProvider, implementando os
métodos públicos que eu citei no começo do artigo;
2. Registrar o provider no AndroidManifest.xml
Vamos começar criando a classe QuickNotesProvider.

41. Criando um Content Provider
Agora, vamos registrar o nosso provider no AndroidManifest, adicionando a
seguinte linha dentro da tag application:
<provider android:authorities="android.helloworld.
quicknotesprovider" android:name="android.helloworld.
QuickNotesProvider"/>

42. Acessando o banco de dados
Com o Content Provider criado, vamos implementar os métodos de acesso e
gravação de dados usando o SQLite.
Para isso, usaremos a classe SQLiteOpenHelper para gerenciar a conexão com o
banco de dados. Para usá-la, é preciso criar uma subclasse implementando os
métodos abaixo:
■ onCreate() – Este método é chamado quando a conexão com o banco de
dados for aberta pela primeira vez. É aqui que criaremos o banco de dados,
com o comando sql CREATE.
■ onUpdate() – Este método é chamado quando a versão do banco de dados
muda. Por exemplo, digamos que você criou uma nova versão de seu
aplicativo que usa uma tabela a mais no banco de dados. Quando esta nova
versão for instalada (em um telefone que já possuir a primeira versão) este
método será chamado, então você poderá criar apenas a nova tabela,
mantendo os dados do usuário.

43. Acessando o banco de dados
Após implementar os métodos onCreate e onUpdate, deve-se implementar os
métodos query, insert e delete, responsáveis por gerenciar os dados do DB.

44. Acessando o content provider
Com o Provider pronto, vamos começar a interagir com ele a partir de nossa
UI.
Vamos começar inserindo uma anotação do usuário no banco de dados. Para
fazer isso, o primeiro passo é adicionar um Listener ao botão ‘Inserir’, da
seguinte forma:
Button insertButton = (Button)findViewById(R.id.insert_button);
insertButton.setOnClickListener(mInsertListener);
Este código deve ser colocado dentro do método onCreate.

45. Acessando o content provider
E agora, criando o objeto mInsertListener. Ele precisa ser um objeto que
implementa a interface OnClickListener,. Assim, precisamos implementar o
método onClick(), que será chamado assim que o usuário pressionar o
botão.
1. // Definindo um OnClickListener para o botão "Inserir"
2. private OnClickListener mInsertListener = new OnClickListener() {
3. public void onClick(View v) {
4. EditText editBox = (EditText)findViewById(R.id.edit_box);
5. addNote(editBox.getText().toString());
6. editBox.setText("");
7. }
8. };

46. Acessando o content provider
No código anterior, fizemos uma chamada a um método que ainda não está
implementado – o método addNote(), que recebe um String que será inserida
no banco de dados. Ele será o método responsável por acessar o content
provider. Vamos implementá-lo:
1. /*
2. * Método responsável por inserir um registro no content provider
3. */
4. protected void addNote(String text) {
5. ContentValues values = new ContentValues();
6. values.put(QuickNotesProvider.Notes.TEXT, text);
7.
8. getContentResolver().insert(
9. QuickNotesProvider.Notes.CONTENT_URI, values);
10. }

47. ListActivity
Agora, aprenderemos a usar uma ListActivity para mostrar ao usuario uma
lista com as anotações que ele inseriu em nossa aplicação QuickNotes.
A ListActivity é uma classe filha da Activity cujo objetivo é mostrar ao usuário
uma Lista (uma ListView). Em suma, é uma Activity com alguns métodos para
gerenciamento de listas, criada com o intuito de facilitar a criação de telas
com essa configuração, muito comuns nas aplicações android.
O primeiro passo para criar uma Activity desse tipo é assegurar que o layout
XML a ser usado por ela possui um elemento ListView (afinal, estamos
criando uma ListActivity!). Além disso, é preciso que seu id seja “@android:
id/list”.

48. ListActivity
Depois disso, o próximo é fazer a nossa classe MainActivity ser uma classe
filha da ListActivity:
public class MainActivity extends ListActivity
E então, inicializar a ListView no método onCreate. Mas para isso
precisaremos de um Adapter.

49. Adapters
Adapters são classes responsáveis por fazer o que é chamado de “bind“:
Receber os dados de um Cursor (ou de alguma outra fonte de dados) e
colocá-los nos seus respectivos lugares no layout da Activity.
Para Activity’s complexas, tipicamente são criadas subclasses da classe
CursorAdapter (Adapter dedicado a tratar cursores). No nosso caso, em que
temos um layout bastante simples, é suficiente o uso do
SimpleCursorAdapter.

50. Adapters

51. SimpleAdapter
1. ListAdapter adapter = new SimpleCursorAdapter(
2. // O primeiro parametro eh o context.
3. this,
4. // O segundo, o layout de cada item.
5. R.layout.list_item,
6. // O terceiro parametro eh o cursor que contem os
dados
7. // a serem mostrados
8. mCursor,
9. // o quarto parametro eh um array com as colunas do
10. // cursor que serao mostradas
11. new String[] {QuickNotesProvider.Notes.TEXT},
12. // o quinto parametro eh um array (com o mesmo
13. // tamanho do anterior) com os elementos que
14. // receberao os dados.
15. new int[] {R.id.text});
16.
17. setListAdapter(adapter);

52. SimpleAdapter
Um dos parâmetros recebidos pelo contrutor da SimpleCursorAdapter é o
layout dos itens da lista, que definimos da seguinte forma:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:
layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="vertical" >
<TextView android:id="@+id/text"
android:textSize="16sp"
android:textStyle="bold"
android:textColor="#FFFFFF"
android:layout_width="fill_parent"
android:layout_height="wrap_content" />
</LinearLayout>

53. Integração com content providers
Integrando a Activity com o content provider, passamos a ter uma aplicação
totalmente funcional.

54. Bibliografia
Android 4 Application Development
Reto Meier