Introdução ao desenvolvimento de Android usando widgets Eclipse e Android

Este tutorial destina-se àqueles interessados em iniciar o desenvolvimento do Android em Eclipse usando os plug-ins de ferramentas de desenvolvimento do Android. Ele oferece insight sobre os recursos notáveis de um aplicativo Android, juntamente com uma breve explicação de seus componentes básicos. O processo do Android é introduzido para o desenvolvimento de UIs ricas para os aplicativos, como widgets. No final, ele mostra como é fácil testar o aplicativo de desenvolvimento implementando-o no simulador de dispositivo Android, incluído no SDK.

Ayushman Jain, Eclipse JDT/Core Committer, IBM China

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.



21/Dez/2010

Introdução

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 (a mais recente no terceiro trimestre de 2010), incluindo o potente Froyo (V2.2). 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). Demonstramos alguns widgets básicos com a ajuda de um aplicativo de amostra. Também falamos 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 tutorial 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. SelecioneVirtual 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, selecioneFile > 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 namecom.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
Screenshot creating the HelloWorld project in Eclipse with build target set to Android 2.1

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
Screenshot of the Hello Android Project layout in Eclipse
  • 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
Screenshot of the UI produced by main.xml, showing a black screen and the text

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.
Estrutura de diretório do projeto Android
Screenshot of the project structure showing the positions of classes.dex, HellowWorld.apk and resources.ap_ under bin/com with labels highlighting their purpose as defined in the preceding paragraph

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
Screenshot of Eclipse with main.xml in the properties view, showing code in the top-left section, an outline in the top-right section, and a heirarchy of properties in the bottom section

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: (a) 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; (b) 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. SelecioneOpen > 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
A screenshot of the Android Virtual Device, showing the emulated phone display on the left and virtual keys for all the phone buttons on the right

Widgets do Android

Agora que sabemos como criar e executar um aplicativo Android básico, vamos adicionar widgets nele (consulte a Figura 7):

  • textView consiste em widgets como editText, Button, etc. Botões podem ainda ser categorizados em:
    • CheckBox
    • RadioButton
    • ToggleButton etc.
  • ImageView consiste em widgets como o ImageButton.
  • ViewGroup consiste em layouts como:
    • Relative Layout
    • Table Layout
    • Frame Layout
    • Adapter View
    • Linear Layout

Para obter informações sobre widgets, "A Visual Guide to Android GUI Widgets" é o melhor guia. No entanto, tenha cuidado com inconsistências introduzidas nele por causa das rápidas mudanças na plataforma Android. Um exemplo evidente é o uso de id como um atributo Identificador para um widget em main.xml no guia mencionado acima. Na plataforma Android mais recente, o android:id totalmente qualificado deverá ser usado.

Figura 7. Hierarquia dos widgets Android
Figure showing the heirarchy of each widget in Android, with View at the top, followed by the types of views and the different widgets that apply to each view

Uma amostra de aplicativo usando widgets

Agora, modificaremos nosso aplicativo existente para que fique parecido com o mostrado na Figura 8. A finalidade deste exemplo é familiarizar o leitor com o uso de alguns widgets básicos, como textView, editText, Button e Toast em um aplicativo real.

Nosso aplicativo consistirá em uma barra de título com a mensagem "WELCOME!!!" Ele terá três widgets textView iniciados a partir da parte superior, dispostos verticalmente: um dizendo "Hello World, how're you?" na fonte padrão; o próximo dizendo "Welcome to my first Android app" em texto serif itálico, alinhado ao centro, com fundo branco e um terceiro dizendo "Type anything and press the button" em texto com espaço simples em negrito, com fundo vermelho. Esses três são seguidos por um widget editText para obter a entrada do usuário, seguido por um widget de botão (o botão tem a mensagem "Click Me!"). O que for digitado no widget editText aparecerá em um widget Toast na parte inferior central da tela quando o botão for pressionado.

Não há muitos códigos de implementação envolvidos. O leitor deverá prestar atenção em como os widgets são facilmente inseridos no aplicativo usando o editor da GUI do ADT para os arquivos XML e como as propriedades do widget são convenientemente definidas usando a visualização "properties" fornecida pelo Eclipse. Este exemplo também demonstrará como a UI e as partes de implementação podem ser codificadas de forma independente.

Figura 8. Android Virtual Device com widgets
Screenshot showing the Android Virtual Device running an application with various widgets, including text and buttons

string.xml

Vamos adicionar novas cadeias de caracteres no arquivo string.xml, alterar a cadeia de caracteres de boas-vindas existente e, finalmente, a cadeia de caracteres do título. Vamos também definir aqui as cores branco e vermelho para o fundo para dois textViews.

Listagem 2. O arquivo string.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, how\'re you?</string>
    <string name="app_name">Hello Android</string>
    <string name="title">WELCOME!!!</string>
    <string name="mainText">Welcome to my first android app</string>
    <string name="subText">Type anything and press the button</string>
    <color name="White">#FFFFFF</color>
    <color name="Red">#FF0000</color>
</resources>

Alteramos a cadeia de caracteres "hello" para conter "Hello World, how're you?" Note que o caractere de escape ('\') é necessário aqui para o apóstrofo. Também definimos duas novas cadeias de caracteres: mainText e subText, e as cores branco e vermelho.

main.xml

Vamos usar a guia Layout de main.xml para arrastar e soltar dois novos textViews: um widget editText e um widget de botão. A seguir, usaremos a guia properties no main.xml para editar atributos para cada widget.

Listagem 3. O arquivo main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello"
    />
<TextView 
    android:layout_height="wrap_content" 
    android:layout_width="fill_parent" 
    android:id="@+id/mainTextView" 
    android:gravity="center" 
    android:text="@string/mainText" 
    android:textStyle="italic" 
    android:typeface="serif" 
    android:background="@color/White">
</TextView>
<TextView 
    android:layout_height="wrap_content" 
    android:layout_width="fill_parent" 
    android:layout_margin="20sp" 
    android:gravity="left" 
    android:id="@+id/subTextView" 
    android:padding="10sp" 
    android:text="@string/subText" 
    android:textStyle="bold" 
    android:typeface="monospace" 
    android:background="@color/Red">
</TextView>
<EditText 
    android:text="Enter text here" 
    android:id="@+id/EditText01" 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content">
</EditText>
<Button 
    android:text="Click me!" 
    android:id="@+id/Button01" 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content">
</Button>
</LinearLayout>

Com isto, temos nossa UI definida. Agora temos que vincular nosso código de atividade a ela.

MainActivity.java

Este é o arquivo que vincula de fato a UI à implementação. Assim como no aplicativo HelloWorld, usamos o método Activity.onCreate(Bundle) para decorar todos os elementos da UI na tela. O método onClick(View) substituído conterá a funcionalidade do clique do botão, em que o texto de entrada do usuário será lido e exibido na tela em um widget toast.

Listagem 4. O arquivo MainActivity.java
package com.example.helloandroid;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

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);
        
        String title = getString(R.string.title);
        setTitle(title);    // done so that we can change the default title
        
        //get handles to editText and button widgets
        final EditText eText = (EditText) findViewById(R.id.EditText01);
        final Button button = (Button) findViewById(R.id.Button01);
        
        button.setOnClickListener(new Button.OnClickListener(){

            @Override
            public void onClick(View v) {
                //get the String entered into the editText widget
                CharSequence editText = eText.getText();
                
                //display the toast
                Toast.makeText(MainActivity.this, editText, Toast.LENGTH_LONG).show();
            }
        });
        
    }
}

Usando este código, obtemos o aplicativo mostrado na Figura 8.


Usando o widget listView : Um aplicativo de amostra

Nesta seção, criaremos um aplicativo de amostra (consulte as Figuras 9a, 9b) para exibir todos os contatos na Lista de contatos usando o widget listView . O objetivo deste exemplo é demonstrar não só o uso do widget listView , mas também mostrar como os dados do telefone podem ser recuperados usando as classes ContentProvider e ContentResolver. Preste atenção nos arquivos XML da UI, pois existem dois layouts de UI: um para especificar como a lista exibida pelo widget listView se encaixa na UI principal e outro para especificar como cada elemento da lista se parece. Outro ponto importante é a configuração das permissões para que o aplicativo seja capaz de ler os dados do telefone. Este exemplo é a primeira etapa para entender como intentos e filtros de intentos podem ser incorporados em um aplicativo. Apesar de intentos estarem fora do escopo deste artigo, o leitor poderá notar que para converter este aplicativo de exemplo em um aplicativo de Lista de contatos real, basta implementar ações de clicar nos itens da lista e criar um intento de chamada e filtro de intentos para iniciar uma chamada para o contato selecionado.

Neste exemplo, os contatos serão exibidos de forma linear na vertical e o contato selecionado aparecerá no topo da lista com uma fonte grande em itálico e um fundo azul. Também temos uma caixa de opções na parte inferior esquerda da tela que, ao ser marcada, exibe somente contatos com estrelas (ou favoritos). O título do aplicativo, neste caso, é "Contact Manager." Aqui, usamos três tipos de widgets: textView, listViewe checkBox. Usamos o widget textView para exibir o contato selecionado. É possível presumir que o widget listView seja uma lista de widgets textView . Um listView usa padrões de design de adaptadores para conectar os dados (neste caso, os contatos) e uma visualização de dados (um textView, neste caso) para listView. Quaisquer cliques em listView podem ser capturados implementando AdapterView.OnItemClickListener().

Antes de continuar, devemos ter alguns contatos armazenados na seção Contacts do emulador do Android (AVD). Isto pode ser feito ao clicar em Contacts na tela principal do AVD e, a seguir, em Menu para obter a opção Add Contacts . A seção Favorites mostra como marcar um contato como favorito/com estrela.

Figura 9a. O aplicativo Contacts mostrando todos os contatos em um widget listView
Screenshot of the contacts application running in the Android Virtual Device displaying a list of contacts with the author's entry highlighted
Figura 9b. O aplicativo Contacts mostrando todos os contatos com estrelas em um widget listView quando a caixa de opção show-starred contacts estiver selecionada
Screenshot of the Contacts application running in AVD with the 'show-starred contacts only' option checked and a reduced set of entries

Agora, definiremos algumas cadeias de caracteres.

Listagem 5. Cadeias de caracteres definidas no arquivo strings.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="hello">Hello World, Manager!</string> 
  <string name="app_name">Contact Manager</string> 
  <string name="selectedEntry" /> 
  <color name="White">#FFFFFF</color> 
  <color name="Black">#000000</color> 
  <color name="Blue">#0000FF</color> 
 <string name="showStarred">Show starred contacts only</string>
</resources>

main.xml

Vamos definir o layout principal para nosso aplicativo. O widget listView acomodará a lista de todos os contatos na lista de contatos. O listView exibe cada item dentro de um widget textView , que definiremos a seguir.

Listagem 6. main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:gravity="center" 
    android:id="@+id/selectedContact" 
    android:padding="10dp" 
    android:textSize="20sp" 
    android:textStyle="italic" 
    android:typeface="serif" 
    android:background="@color/Blue" 
    android:textColor="@color/White" 
    android:text="@string/selectedEntry"/>
<ListView 
    android:id="@+id/contactsListView" 
    android:layout_width="fill_parent" 
    android:layout_height="fill_parent" 
    android:layout_weight="1">
    </ListView>
<CheckBox android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/showStarred"
    android:text="@string/showStarred"/>
</LinearLayout>

Note que atribuir um layout_weight de 1 a listView assegura que a lista abrangerá o máximo possível da tela principal até que um novo widget seja definido.

contactItem.xml

Além do layout principal, precisamos definir aqui outro layout. Ele servirá para representar cada elemento no listView. Usamos um textView simples aqui.

Listagem 7. Código para o widget textView , que constitui cada elemento do widget listView
<?xml version="1.0" encoding="utf-8"?>
<TextView
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:padding="5dp" 
  android:textStyle="bold" 
  android:id="@+id/contactItem">
</TextView>

Note que, por padrão, o Android fornece um layout simples que pode ser usado, em vez de definir o seu próprio layout. Ele pode ser referenciado por meio do android.R.layout.simple_list_item_1.

ManageContacts.java

A Listagem 8 mostra como a atividade principal é implementada. O método populateContactList() é o que usaremos para consultar o banco de dados de contatos e exibi-los no listView.

Listagem 8. Implementação da atividade principal
public class ManageContacts extends Activity {
    private ListView mContactList;
    private CheckBox mCheckBox;
    private boolean mShowStarred;
    private TextView selectedText;
     /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        mContactList = (ListView) findViewById(R.id.contactsListView);
        mCheckBox = (CheckBox) findViewById(R.id.showStarred);
        selectedText = (TextView) findViewById(R.id.selectedContact);
        mShowStarred = false;
        
        mCheckBox.setOnCheckedChangeListener(new CheckChangedListener());
        
        mContactList.setOnItemClickListener(new ClickListener());
        
        populateContactList();
       
    }
    
    public void populateContactList() {
         Uri uri = ContactsContract.Contacts.CONTENT_URI;
         String[] projection = new String[] {
                 ContactsContract.Contacts._ID,
                 ContactsContract.Contacts.DISPLAY_NAME,
         };
         String[] selectionArgs = null;
         String sortOrder = ContactsContract.Contacts.DISPLAY_NAME + 
" COLLATE LOCALIZED ASC";
         String selection = mShowStarred? ContactsContract.Contacts.STARRED + 
" ='1'" : null;
         Cursor c = getContentResolver().query(uri, projection, selection, selectionArgs, 
sortOrder);
         
         String[] fields = new String[] {
                 ContactsContract.Data.DISPLAY_NAME
         };
         SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, R.layout.contactitem,
c, fields, new int[] {R.id.contactItem});
         mContactList.setAdapter(adapter);
         
    }
    
    private class ClickListener implements OnItemClickListener {

        @Override
        public void onItemClick(AdapterView<?> arg0, View textView, int pos, long arg3) {
            if(textView instanceof TextView)
                selectedText.setText(((TextView) textView).getText());
         }
     }
    
    private class CheckChangedListener implements OnCheckedChangeListener {

        @Override
        public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
             mShowStarred = isChecked;
             selectedText.setText("");
             populateContactList();
            
        }
        
    }
}

O que deve ser observado:

  • Temos dois listeners — um para manipular cliques em um item da lista e um para manipular cliques na caixa de opção. O primeiro simplesmente define o texto na caixa textView azul para exibir o nome do contato selecionado. O segundo define o campo mShowStarred e preenche a lista novamente.
  • Para ler os contatos do banco de dados do telefone, precisamos consultá-lo para obter um cursor. A consulta tem os seguintes parâmetros:
    1. uri— O URI usando o esquema content:// para o conteúdo a ser recuperado.
    2. projection— Uma lista de quais colunas deverão ser retornadas. Passar null retornará todas as colunas, o que não é recomendado para evitar a leitura de dados de um armazenamento que não será usado.
    3. selection— Um filtro assegurando quais linhas deverão ser retornadas, formatado como uma cláusula SQL WHERE (excluindo o WHERE em si). Passar null retornará todas as linhas para o URI dado.
    4. selectionArgs— É possível incluir ?s, que serão substituídos pelos valores de selectionArgs, na ordem em que aparecem na seleção. Os valores serão vinculados como Strings.
    5. sortOrder— Como ordenar as linhas, formatadas como uma cláusula SQL ORDER BY (excluindo o ORDER BY em si). Passar null usará a ordem de classificação padrão, que poderá ser não ordenada.

O cursor do conjunto de resultados obtido desta forma deve ser vinculado à UI por meio de um adaptador. Usamos um SimpleCursorAdapter aqui, apesar de o Android também fornecer um ListAdapter. Quando o adaptador for obtido, precisaremos conectá-lo ao listView e teremos concluído.

Permissões

Uma etapa final necessária antes que nosso aplicativo seja executado com sucesso em um dispositivo Android é a definição de permissões. Sem permissões que possibilitem a leitura do banco de dados de contatos, o kernel Linux no dispositivo não permitirá que a aplicação o faça. Portanto, vamos acessar a guia AndroidManifest.xml>Permissions e definir as seguintes permissões:

  1. android.permission.GET_ACCOUNTS
  2. android.permission.READ_CONTACTS

Elas podem ser definidas ao clicar no ícone U e definir a permissão. A Figura 10 mostra como a guia Permissions deverá se parecer.

Figura 10. Manifesto de permissões do Android
Screenshot showing the permissions tab with entries for android.permission.GET_ACCOUNTS(Uses Permission) and android.permission.READ_CONTACTS (Uses Permission)

Widget listView usando ListActivity

Este exemplo destina-se a demonstrar outra forma de implementar um listView. No aplicativo acima, note que nossa atividade principal implementa a classe activity. Ao lidar com widgets listView , algumas vezes a classe ListActivity é melhor, pois tem APIs públicas para manipular cliques em itens de listas, definir adaptadores de listas, obter a posição do clique, etc.

Podemos modificar nossa atividade para implementar ListActivity como mostra a Listagem 9.

Listagem 9. Implementação usando ListActivity
public class ManageContacts extends ListActivity {
    @Override
    protected void onListItemClick(ListView l, View v, 
int position, long id) {
// TODO Auto-generated method stub
super.onListItemClick(l, v, position, id);
if(v instanceof TextView)
selectedText.setText(((TextView) v).getText());
}
private CheckBox mCheckBox;
private boolean mShowStarred;
private TextView selectedText;
/** Called when the activity is first created. */
@Override
public void 
onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

mCheckBox = (CheckBox) findViewById(R.id.showStarred);
selectedText = (TextView) 
findViewById(R.id.selectedContact);
mShowStarred = false;

mCheckBox.setOnCheckedChangeListener(new 
CheckChangedListener());

populateContactList();

}

public void populateContactList() {
Uri uri = ContactsContract.Contacts.CONTENT_URI;
String[] projection = new String[] {
ContactsContract.Contacts._ID,
ContactsContract.Contacts.DISPLAY_NAME,
};
String[] selectionArgs = null;
String sortOrder = 
ContactsContract.Contacts.DISPLAY_NAME +      
" COLLATE LOCALIZED ASC";
String selection = mShowStarred?
ContactsContract.Contacts.STARRED + " ='1'" : null;
Cursor c = 
getContentResolver().query(uri, projection, 
selection, selectionArgs, sortOrder);

String[] fields = new String[] {
ContactsContract.Data.DISPLAY_NAME
};
ListAdapter adapter = new 
SimpleCursorAdapter(this, 
R.layout.contactitem, c, fields, new 
int[]{R.id.contactItem});
setListAdapter(adapter);

}

private class CheckChangedListener 
implements OnCheckedChangeListener {

@Override
public void onCheckedChanged(CompoundButton 
buttonView, boolean isChecked) {
mShowStarred = isChecked;
selectedText.setText("");
populateContactList();
   }
        
    }
}

Note que, aqui, simplesmente implementamos o método onListItemClick de ListActivity, em vez de declarar uma classe anônima para manipular cliques. Também não precisamos nos referir ao widget listView definido em main.xml porque ListActivity presume que o widget listView é definido com um ID de @android:id/list. Isto é importante de se observar. Sempre que usarmos ListActivity, teremos que definir o widget listView em main.xml para ter um ID de @android:id/list. Caso contrário, o ListActivity não saberá a qual listView se referir.


Conclusão

Neste tutorial, aprendemos como configurar o Eclipse para desenvolvimento de Android e como os valiosos recursos do Eclipse ajudam em cada etapa ao escrever aplicativos do Android. Também aprendemos como os aplicativos podem ser facilmente implementados e testados no emulador do Android — AVD. Abordamos os notáveis recursos de um aplicativo do Android usando um exemplo Hello World e aprendemos sobre os arquivos que compõem um aplicativo Android. Falamos sobre alguns dos widgets fornecidos pelo Android e vimos seu uso em alguns exemplos reais. Agora você deverá estar bem encaminhado para criar um excelente aplicativo com uma UI organizada. Como primeira etapa, estenda o aplicativo contacts para implementar a ação de clique em um item de lista a fim de exibir o número do telefone e os detalhes do contato, e um botão para chamar o contato selecionado. Um intento de chamada também deverá ser definido, juntamente com um filtro de intento, que deverá implementar a funcionalidade de realização da chamada.

O Android é uma plataforma eficiente para aplicativos remotos e codificação em tecnologia Java. Juntamente com o Android Development Tools para Eclipse, ele se torna fácil de ser adotado por iniciantes. Sua ampla variedade de widgets, juntamente com sua capacidade de vincular dinamicamente os elementos da UI à implementação, fornece uma grande flexibilidade e torna o aplicativo leve, apesar da UI sofisticada. Os conceitos de atividades, intentos, provedores de conteúdo, etc., tornam fácil de gerenciar a UI e os elementos de dados, e de controlar a vinculação entre eles. Ele também tem um grande conjunto de APIs de rede a explorar. Além disso, as APIs do Google fornecem funcionalidade para mapas, pesquisa e correio, entre outras coisas, que podem ser facilmente adotadas em um aplicativo do Android. Portanto, aprofunde-se no maravilhoso mundo do Android e solte sua imaginação.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

  • O Newsgroup da Plataforma Eclipse deverá ser sua primeira parada para discussão das questões relacionadas ao Eclipse. (A seleção deste link ativará seu aplicativo leitor de notícias Usenet padrão e abrirá eclipse.platform.)
  • O Newsgroup do Eclipse tem muitos recursos para pessoas interessadas no uso e na extensão do Eclipse.
  • Participe dos Blogs do developerWorks e participe da comunidade do developerWorks.

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=604439
ArticleTitle=Introdução ao desenvolvimento de Android usando widgets Eclipse e Android
publish-date=12212010