Android Core Aula 6 - Desenvolvimento de aplicações Android

Android Core

Felipe Silveirafelipesilveira.com.br Aula 6

Aplicações I

Desenvolvimento de Aplicações

Android SDKSDKhttps://developer.android.com/sdk

Android SDKAndroid SDK:

● Eclipse +● ADT plugin +● Android platform-tools +● A última versão das interfaces do application

framework +● A última imagem para o emulador

Android SDKInstalação: descompacte o arquivo e execute o executável eclipse, localizado no diretório eclipse:

Hello World

Criando o projeto

Passo 1 – Criando o projeto no Eclipse

Abra o Eclipse, vá até File > New > ProjectNa tela que aparecer, escolha “Android Project” e clique em “Next”.

Criando o projeto

Criando o projetoApó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

Criando o projetoA 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

Criando o projetoNa próxima tela, é possível configurar o ícone padrão da aplicação.

Após preencher os campos, clique em Next

Criando o projetoA próxima tela contém as opções da Activity a ser criada.

Após preencher os campos, clique em Next

Criando o projetoPor 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

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

Criando o projetoE com seu respectivo layout, escrito em XML:

EmuladorUma 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.

Emulador

EmuladorNa 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.

Emulador

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

EmuladorNa 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)

Emulador

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

Quick Notes

Quick NotesPara 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.

Quick NotesA 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

LayoutEm 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

Layout

LayoutNo 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.

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>

Layout - carregando o XMLPara 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)

ActivityAgora é 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:

Activity Lifecycle

Content ProvidersOs 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.

Content ProvidersE 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:

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.

Content ProvidersCom a construção do content provider, a arquitetura do quick notes ficará assim:

Estrutura das UrisUma 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.

Criando um Content ProviderPara 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.

Criando um Content ProviderAgora, 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"/>

Acessando o banco de dadosCom 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.

Acessando o banco de dadosApó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.

Acessando o content providerCom 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.

Acessando o content providerE 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. };

Acessando o content providerNo 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. }

ListActivityAgora, 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”.

ListActivityDepois 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.

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.

Adapters

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);

SimpleAdapterUm 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>

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

Bibliografia

Android 4 Application DevelopmentReto Meier