O Android é um sistema operacional de dispositivo remoto, similar ao
Symbian, iOS, Windows
Mobile e outros. Ele foi inicialmente desenvolvido pela
Android Inc., uma empresa posteriormente adquirida pela
Google. Ela agora é de propriedade da Open Handset Alliance
e é totalmente de software livre, responsável por sua
própria popularidade crescente.

A Google liberou a maioria do código Android sob a
licença do Apache. Com esta licença, os fornecedores podem adicionar
extensões proprietárias sem enviá-las novamente para a comunidade de
software livre.

Muitas versões do Android chegaram ao mercado desde sua
concepção. O Android não é mais apenas uma plataforma para
dispositivos remotos, pois a nova
Google TV também é executada nele.

O Android usa um kernel Linux modificado e permite que
aplicativos sejam desenvolvidos em tecnologia Java usando bibliotecas
Java (algumas das quais desenvolvidas pela Google para o Android).

Apesar de aplicativos Android serem escritos na linguagem Java, não há
um código na plataforma, e o código de byte Java não é executado. As
classes Java são recompiladas em executáveis Dalvik e executados em uma
máquina virtual
Dalvik. Dalvik é uma VM modificada para Android, com
dispositivos otimizados que são executados com energia proveniente de
uma bateria e com CPU de baixa capacidade.

Para desenvolvedores, o Android SDK fornece um conjunto
rico de ferramentas, incluindo depurador, bibliotecas, emulador de
telefone portátil, documentação, código de amostra e tutoriais.

Aplicativos Android podem ser facilmente desenvolvidos usando Eclipse
(a plataforma oficial de desenvolvimento do Android) com
a ajuda de um plug-in chamado
Android Development Tools (ADT). Isto ajuda no
aproveitamento dos recursos ricos do Eclipse, como assistente de
conteúdo, recursos abertos, integração com JUnit e diferentes
visualizações e perspectivas para desenvolver um aplicativo Android.

Uma
ampla variedade de widgets, que são similares a widgets do Java
swing, facilita a criação de uma UI rica para os
aplicativos. Um
Javadoc detalhado torna o processo de desenvolvimento
bem fácil.

Aqui, começamos com um guia de preparação do sistema para
desenvolvimento do Android. A seguir, falamos brevemente sobre os
recursos notáveis de um aplicativo Android
usando um aplicativo Hello World básico do Android.
Também falamos sobre os arquivos que compõem um aplicativo
Android e como a UI é separada da implementação.

Depois de passar pelo
processo de criar, desenvolver e iniciar um aplicativo Android a partir
do Eclipse, prosseguimos para uma discussão sobre alguns widgets Android
que ajudam na construção de uma UI rica (uma parte muito importante de
aplicativos para dispositivos remotos). Vamos demonstrar alguns widgets
básicos com a ajuda de um aplicativo de amostra.

Também falaremos sobre o
uso do widget listView
em um aplicativo do tipo lista de contatos e as formas como ele pode ser
implementado. Ao mesmo tempo, também falamos sobre permissões que
precisam ser definidas para que um aplicativo possa acessar alguns dados
a partir do sistema operacional. De forma geral, algumas horas de
leitura do artigo deverão possibilitar a criação de um aplicativo que
implemente uma funcionalidade básica com uma UI.

Requisitos do sistema

Antes de começar a desenvolver o Android, assegure-se de ter instalado:

• Eclipse SDK: V3.5 é a versão sugerida para uso com o SDK mais recente do
  Android. O download pode ser feito na página de download do Galileo.
• Android SDK
• Android Development Tools (ADT): Este é um plug-in do Eclipse. Ele é equivalente ao JDT (Java Development Tools) para Android
  Development. Siga as instruções detalhadas para a instalação do plug-in
  ADT e para a configuração da localização do SKD do Android no
  Eclipse.

Terminologia do Android

Um aplicativo Android típico tem os componentes a seguir. Também são apresentadas abaixo as definições fornecidas pelo
site Android Developer
:

• Atividade: Uma atividade apresenta uma
  UI visual para um esforço concentrado que o usuário poderá realizar. Por
  exemplo, uma atividade poderá apresentar uma lista de itens de menu a
  partir da qual o usuário poderá fazer uma seleção ou exibir fotografias
  juntamente com suas legendas. Um aplicativo de mensagens de texto poderá
  ter uma atividade que exibe uma lista de contatos para os quais enviar
  mensagens, uma segunda atividade para escrever a mensagem ao contato
  selecionado e outras atividades para revisar mensagens antigas ou
  alterar configurações. Apesar de trabalharem juntas para formar uma UI
  coesa, cada atividade é independente das outras.
• Provedores de conteúdo: Um provedor de conteúdo
  compõe um conjunto específico dos dados do aplicativo disponíveis a
  outros aplicativos. Os dados podem ser armazenados no sistema de
  arquivos, em um banco de dados SQLite ou de qualquer outra maneira
  lógica.
• Serviço: Um serviço não tem uma UI visual,
  mas é executado em segundo plano por um período indefinido de tempo. Por
  exemplo, um serviço poderá tocar música em segundo plano à medida que o
  usuário cuida de outras questões, ou poderá recuperar dados pela rede
  ou calcular algo e fornecer o resultado para atividades que precisem
  dele.
• Receptores de transmissões: Um receptor de transmissão é um componente que não faz nada além de receber e reagir a comunicados de transmissão.
  Muitas transmissões se originam no código do sistema –
  de comunicados de alteração de fuso horário, comunicados de bateria fraca, alterações de preferência de idioma, etc.

Alguns outros termos que vale a pena conhecer:

• Intento: Atividades, serviços e receptores de transmissão são ativados por mensagens assíncronas chamadas de intentos. Um intento é um objeto
  Intent que retém o conteúdo da
  mensagem. Por exemplo, ele poderá transmitir uma solicitação para uma
  atividade a fim de apresentar uma imagem para o usuário ou deixar que o
  usuário edite um texto.
• Filtro de intento: Um objeto Intent pode nomear
  explicitamente um componente de destino. Se o fizer, o Android busca um
  componente (com base nas declarações no arquivo de manifesto) e o ativa.
  Se, no entanto, um destino não for nomeado explicitamente, o
  Android deverá localizar o melhor componente para responder ao intento.
  Isto é feito comparando o objeto Intent aos
  filtros de intento de destinos potenciais. Os filtros de intento de um componente informam ao
  Android sobre os tipos de intentos que o componente é capaz de tratar.

Para obter um entendimento destes componentes, consulte “Desenvolva aplicativos Android com Eclipse” e o Hello, World.

Criar um dispositivo virtual Android

Esta etapa é necessária ao criar um emulador de telefone
Android/Android Virtual
Device (AVD) no qual os aplicativos podem ser executados
e testados. Note que leva algum tempo para que um
AVD inicie.

A boa notícia é que não são necessários AVDs separados para
que cada aplicativo seja implementado e testado. Quando o
AVD é iniciado, qualquer número de aplicativos pode ser
implementado enquanto ele estiver em execução, podendo até mesmo ser
usado para depurar aplicativos. Para criar um AVD:

1. No Eclipse, selecione Window > Android SDK e
   AVD Manager.
2. Selecione Virtual Devices no painel esquerdo.
3. Clique em New. O diálogo
   Create New AVD
   será exibido.
4. Digite o nome do AVD, como “myPhone”.
5. Escolha um destino. O destino é a plataforma (ou seja, a versão do
   Android SDK, como 2.1) a ser executada no emulador. Também haverá a opção de escolher as APIs do
   Google, mas isto não será necessário, a não ser que queiramos ter alguma API do
   Google no aplicativo especificamente. O restante dos campos pode ser ignorado por enquanto.
6. Clique em Create AVD.

Quando o AVD for iniciado, será possível ver como ele
oferece a aparência de um telefone celular real com base em Android,
completo com teclado e suporte a toque. Ele também poderá ser usado em
uma variedade de configurações para testar seu aplicativo, como modo
retrato/paisagem, intensidade da rede e rede em roaming network, etc.

Todas essas opções podem ser configuradas usando o gerenciador do AVD.
O AVD é autossuficiente para emular diferentes dispositivos disponíveis.
É possível criar diferentes AVDs para diferentes configurações e testar
seu aplicativo em cada um deles, para garantir que seja compatível em
diferentes tipos de dispositivos.

Criar um novo projeto Android

Veja como um novo projeto Android project é criado no Eclipse (consulte a Figura 1):

1. No Eclipse, selecione File > New > Project. Uma pasta chamada
   Android deverá estar presente no diálogo se o plug-in
   ADT para Eclipse houver sido instalado com sucesso.
   Ao expandir esta pasta será oferecida a opção para um novo
   Android
   project. Selecione-o e clique em Next..
2. Agora, será solicitado que você preencha os seguintes detalhes em um formulário:

• Project name: Este é o nome de seu projeto e poderá ser algo como “HelloWorld.”
• Application name: Este é o nome que
  aparecerá em todos os locais de seu dispositivo Android, juntamente com
  os ícones no menu, nos atalhos e na barra de título ao executar seu
  aplicativo.
  Isto poderá ser algo como “Hello Android.”
• Package name: com.example.helloandroid ou seu próprio namespace privado.
  O nome do pacote segue as mesmas regras que aquelas da linguagem Java.
• Create activity: Para o propósito deste artigo, podemos chamá-la de SaySomething. Este é o nome do stub da classe que será gerado pelo
  ADT. Isto será uma subclasse da Activity
  do Android. Uma atividade é simplesmente uma classe que pode ser
  executada e fazer algum trabalho. Ela poderá ter, opcionalmente, uma UI.
  Um aplicativo poderá conter uma ou mais atividades. Elas são
  tipicamente um relacionamento 1:1 como as telas encontradas em um
  aplicativo. Um aplicativo passa de uma atividade para a outra chamando
  um método conhecido como
  startActivity() ou startSubActivity().
• Min SDK version: Isto especifica o nível mínimo da API necessário para seu aplicativo. O mais recente é 7.

Figura 1. Criar um novo projeto Android

Detalhes do projeto Hello Android

O Hello Android é um projeto Android básico, que simplesmente exibe Hello
World na tela. Ele tem as seguintes funções neste artigo:

• Demonstrar o processo de criação de um novo projeto Android.
• Dar uma visão geral dos arquivos em um projeto Android e seus propósitos.
• Demonstrar como implementar um aplicativo no AVD e testá-lo.

Visualizar os arquivos e outros recursos que fazem parte
do projeto Android e usar a visualização Package Explorer dentro do
Eclipse (Window > Show View
> Package Explorer). O projeto Android recém-criado consistirá do seguinte
(consulte a Figura 2):

• Há duas pastas que contêm o código de origem:

1. src contém todas as classes especificadas pelo usuário, incluindo a classe padrão activity.
2. gen contém os arquivos automaticamente gerados pelo
   ADT. R.java dentro desta pasta consiste em referências estáticas para todos os recursos presentes na pasta res
   para que possam ser referenciadas de forma fácil e dinâmica a partir
   do código Java. Recomenda-se não modificar o conteúdo de R.java
   manualmente.

Figura 2. Conteúdo do projeto Hello Android

• Uma pasta res contém todos os
  recursos do projeto: ícones, imagens, cadeias de caracteres e layouts.
  Ter uma pasta de recursos separada mantém recursos de código não fonte
  externos ao código e os recursos podem ser dinamicamente selecionados
  com base em hardware,
  idioma, orientação e localização.

Ela consiste em:

1. Pasta drawable: Destinada a todos os arquivos de imagem.
2. Pasta layout: Destinada aos
   layouts que especificam as telas de UI para as atividades, na forma de
   código XML.
   Main.xml é gerado automaticamente. Esta pasta
   refere-se ao layout vertical padrão. Para representar uma UI no layout
   horizontal (quando um dispositivo Android é girado 90 graus), crie uma
   pasta
   layout-land e coloque seu arquivo XML de layout
   nela. O arquivo
   main.xml possui uma representação de UI
   apropriada, como mostra a Figura 3.
   É possível arrastar e soltar diferentes layouts
   em uma tela vazia para construir os componentes de UI para a atividade.
3. Pasta values: Destina-se a todos os pares nome-valor
   (as cadeias de caracteres que seu aplicativo definirá).

• AndroidManifest.xml também é uma
  parte importante do projeto. É o equivalente de um arquivo plugin.xml
  para plug-ins. Basicamente, ele define as atividades nos aplicativos e
  especifica as ações que foram definidas para cada uma. Ele também lista
  as permissões necessárias para realizar várias ações.
  Novamente, ele tem uma UI apropriada.

Figura 3. UI para main.xml

Vamos dar uma olhada no conteúdo real da pasta do projeto no disco. Abra a
Navigator View no Eclipse (Window > Show
View > Navigator). Você verá a estrutura
do projeto
HelloWorld, como mostra a Figura 4. Além dos arquivos
compilados da classe, você obterá os seguintes três arquivos em uma
pasta bin:

1. classes.dex: Executável gerado a partir das classes compiladas.
2. HelloWorld.apk: Archive compactado que será enviado ao dispositivo
   Android. O aplicativo poderá ser instalado em qualquer dispositivo Android por meio deste
   archive.
3. resources.ap_: Recursos de aplicativos compactados.

Figura 4. Estrutura de diretório do projeto Android

A ‘Activity’ principal do aplicativo

Vamos examinar MainActivity.java.

Listagem 1. MainActivity.java

package com.example.helloandroid;

import android.app.Activity;
import android.os.Bundle;

public class MainActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

O que deve ser observado sobre este arquivo:

• MainActivity estende uma classe base do Android chamada
  Activity, que está localizada em
  android.app.
• O método
  onCreate() é o ponto de entrada padrão
  para esta atividade e deverá ser implementado para cada nova atividade.
  Ele recebe um argumento do tipo Bundle. As opções e parâmetros necessários para a criação da atividade são passados neste parâmetro.
• O método
  setContentView() é responsável por criar a UI principal usando o argumento
  R.layout.main. É uma constante definida em
  R.java e representa o layout principal encontrado em recursos do aplicativo.

Main.xml

Este arquivo XML descreve a UI do aplicativo. Uma atividade pode
referenciar esta UI. Esta UI, no entanto, não se vincula a nenhuma
atividade. Uma UI é construída usando layouts e widgets.

O
main.xml que o Eclipse constrói por padrão consiste em um único
LinearLayout, o que significa que todos os elementos são dispostos em uma única coluna.

A seguir, ele define um textView, que é usado para exibir um texto estático não editável. Neste caso, a cadeia de caracteres “hello” definida no arquivo
strings.xml (o sinal ‘@’ refere-se a um arquivo definido em
res). Cada elemento de visualização adicional possui atributos como
layout_height
e layout_width etc. 

Figura 5. Main.xml e a visualização de propriedades

Uma maneira fácil de trabalhar com o arquivo main.xml é por meio da visualização de propriedades
Window > Show
View > Other > General > Properties.
Quando uma visualização particular for selecionada na visualização da
estrutura de tópicos, a guia properties será preenchida com todos os
atributos possíveis da visualização, como mostra a Figura 5.

A maioria
desses atributos só têm valores fixos dentre os quais escolher, que
podem ser selecionados a partir de um menu suspenso adjacente a cada
atributo na guia properties. Por exemplo, para definir layout_height, é possível ver a caixa suspensa e descobrir que ela só tem dois valores permitidos: wrap_content e fill_parent. (wrap_content desenhará somente a visualização em seu tamanho original, enquanto que fill_parent a aumentará para abranger a altura ou largura completa ou ambas.)

Nota: Para layout_height e layout_width,
também é possível especificar o tamanho nas seguintes duas unidades:

• Density-independent pixels (dp): Este tamanho permite que o layout
  tenha a mesma aparência quando visualizado em dispositivos de tamanhos
  de tela diferentes. Por exemplo: layout_width = 10dp;
• Scale-independent
  pixels (sp): Similar a dp, mas este é o padrão recomendado para telefones celulares. Por exemplo: layout_width
  = 10sp. 

Outra coisa importante a ser observada é que, se você quiser
referenciar alguma visualização/widget a partir do código Java, é
necessário ter um ID exclusivo. Se você usar a guia Layout de main.xml para arrastar e soltar um widget, o ADT criará automaticamente um ID para o
widget, que estará na forma
“@+id/someView.” No código Java, então, é possível referenciá-lo como R.id.someView. 

Executando o aplicativo no emulador

Para implementar e executar o aplicativo, é preciso definir uma configuração de execução.
Selecione Open > Run > Dialog ou o atalho na barra de ferramentas dentro do
Eclipse e selecione Android application. Clique em New
e preencha o nome da configuração de execução.
Especifique o nome de seu projeto e a atividade padrão.

A seguir, na
guia Target, escolha as configurações desejadas do emulador e
especifique um AVD que deseja iniciar. Clique em Run.
Você obterá um AVD como mostrado na Figura
6.

A tela do dispositivo é exibida à esquerda,
juntamente com um teclado QWERTY na parte inferior esquerda, e botões
comuns de dispositivos remotos, como discar, desligar, silenciar, volume
e página inicial na parte superior esquerda.

Figura 6. O dispositivo virtual do Android

Você acompanhou um insight sobre os recursos notáveis de um aplicativo Android e também uma breve explicação de seus componentes básicos. Agora na segunda parte, o
processo do
Android vai ser introduzido para o desenvolvimento de UIs ricas para
os aplicativos, como widgets.
Acompanhe a próxima etapa onde mostramos como é fácil testar o aplicativo de desenvolvimento,
implementando-o no simulador de dispositivo Android, incluído no SDK.

***

artigo publicado originalmente no developerWorks Brasil, por Ayushman Jain

Ayushman Jain trabalha na equipe Eclipse no IBM India Software Labs,
Bangalore, como JDT/Core committer. Ele lidera a iniciativa
Eclipse@campus para propagar o Eclipse em universidades indianas. É
muito interessado no Android como plataforma e encoraja seu uso, devido à
facilidade de desenvolvimento em ambientes familiares do Eclipse. E
também é editor técnico de uma revista para jovens, chamada NOW, em
circulação em Deli, Índia. Para a NOW, ele revisou telefones HTC com
base em Android.