Primeiros passos com Android: Criando um "Hello World"

Como desenvolverdor, você sabe que a primeira impressão sobre um determinado ambiente de desenvolvimento é tão fácil quanto escrever “Hello World”. Bem, no Android, é bem fácil. É particulamente fácil se você estiver usando o IDE Eclipse, porque é fornecido um bom plugin que ajuda na criação do projeto e gerencia de forma rápida os ciclos de desenvolvimento.

Antes de começar, você deve ter instalado o SDK, e se você estiver usando o Eclipse, deve ter instalado o plugin ADT também. Se ainda não instalou, veja esse tutorial antes e retorne aqui depois.

Instalar uma plataforma

Para executar uma aplicação. você precisa instalar ao menos uma das plataformas do Android no seu ambiente SDk. Se ainda não executou esse passo, precisa faze-lo agora.
Para instalar uma plataforma no Eclipse:

  1. No “Android SDK and AVD Manager”, escolha “Available Packages” à esquerda do painel.
  2. Clique na caixa de verificação do repositório para exibir os componentes disponiveis para instalação.
  3. Selecione ao menos uma plataforma para instalar, e clique “Install Selected”. Se não tiver certeza de qual plataforma instalar, escolha a última versão.

Criar uma AVD

Nesse tutorial, você executará sua aplicação em um emulador. Antes que você possa carregar o emulador, precisa criar um “Android Virtual Device” (AVD). Uma AVD define a imagem do sistema e as configurações do dispositivo emulado.
Para criar uma AVD:

    1. No Eclipse, escolha Window > Android SDK and AVD Manager.
    2. Selecione “Virtual Devices” no painel à esquerda.
    3. Clique em “New”.

A caixa de dialogo “Create New AVD” aparecerá.

    1. Digite uma nome para a AVD, como “my_avd”.
    2. Escolha um target. O target é a plataforma (isto é, a versão do SDK do Android, como 2.1) que você quer emular.

Você pode ignorar o restante dos campos nesse momento.

  1. Clique “Create AVD

Criar um Novo Projeto Android

Depois de ter criado uma AVD, o próximo passo é começar um novo projeto Android no Eclipse.

  1. No Eclipse, selecione File > New > Project. Se o ADT foi instalado com sucesso, a caixa de dialogo que aparece deverá ter uma pasta chamada “Android” que deve conter “Android Project” (Depois de ter criado um ou mais Projetos, uma entrada para “Android XML File” aparecerá também.)
  2. Selecione “Android Project” e clique Next.


Preencha os seguintes itens na caixa de dialogo “Project Details”:

  • Project name: HelloAndroid
  • Application name: Hello, Android
  • Package name: com.example.helloandroid
  • Create Activity: HelloAndroid

Clique em Finish.

Aqui está a descrição de cada campo:

Project Name
Este é o nome do projeto para o Eclipse – será o nome do diretório onde ficarão os arquivos do projeto.
Application Name
Esta e forma com que seu projeto será conhecido pelos usuários – o nome que aparecerá no dispositivo Android.
Package Name
Esse é o namespace do pacote (que segue as mesmas regras de nomenclatura de pacotes usada em Java) que você quer que encapsule o seu código. Também configura o nome do pacote onde a Activity principal será gerada. O nome do pacote deve ser único dentre todos os pacotes instalados em um sistema Android; por essa razão, é importante usar um nome padrão para sua aplicação. O exemplo acima usa o namespace “com.example”, que é um namespace reservado para os exemplos da documentação – quando você for desenvolver suas próprias aplicações, deve suar uma namespace apropriado à sua organização ou entidade.
Create Activity
Esse é o nome da classe base da aplicação, que é gerada pelo plugin, que será uma subclasse de Activity. Uma Actiity é simplesmente a classe que fará todo o trabalho da aplicação. Ela pode criar uma interface se quiser, mas não precisa faze-lo. Como a caixa de verificação sugere, isso é opcional, mas uma Activity é quase sempre usada como a base da aplicação.
Min SDK Version
Esse valor especifica o nivel minimo (e a versão) da API requerida por sua aplicação.

Sua aplicação Android está pronta agora. Deve estar visivel no “Package Explorer” a esquerda. Abra o arquivo HelloAndroid.java, localizado dentro de HelloAndroid > src > com.example.helloandroid. Deve parecer com isso:

package com.example.helloandroid;
import android.app.Activity;
import android.os.Bundle;
public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Observe que a classe é baseado na classe Activity. Uma Activity é uma entidade única da aplicação que tem a função de executar determinada ação. Uma aplicação pode ter várias activities, mas o usuário interage com uma de cada vez. O metódo onCreate() será chamado pelo sistema Android quando a Activity é iniciada – é onde você deve executar qualquer comando de inicialização e chamar a interface. Uma Activty não precisa ter uma interface com o usário, mas geralmente tem.

Construir a Interface

Dê uma olhada no código abaixo e faça as mesmas mudanças em sua classe HelloAndroid. As linhas em negrito foram adicionadas.

package com.example.helloandroid;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class HelloAndroid extends Activity {
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       TextView tv = new TextView(this);
       tv.setText("Hello, Android");
       setContentView(tv);
   }
}

Uma interface de usuário no Android é composta de hierarquias de objetos chamados View. Uma View é um objeto desenhavel usado como um elemento em seu layout, como um botão, imagem ou neste caso, uma caixa de texto. Cada um desses objetos é uma subclasse da classe View.
Nessa mudança, você criará um TextView com uma classe construtor, que aceita uma instância de Context como parametro. Um Context é atalho do sistema; ele forcene serviços como resolução de recursos, obtenção de acesso a banco de dados e preferências, e assim em diante. A classe Activity herda de Context, e por sua classe HelloAndroid ser uma subclasse de Activity, também é um Context. Então, você passa this como uma referência para o TextView.
No próximo passo, definimos o conteúdo da caixa de texto com setText().
Finalmente, passa o TextView para setContextView()  para mostar o objeto na interface. Se sua Activity não chamar esse metódo, a interface mostrada será uma tela em branco.

Executar a aplicação

O plugin para o Eclipse torna fácil executar suas aplicações:

  1. Selecione Run > Run.
  2. Selecione “Android Application”.

O plugin para o Eclipse automaticamente cria uma nova configuração para o seu projeto e então carrega o emulador. Dependendo do ambiente, o emulador por levar vários minutos para carregar completamente, então seja paciente. Quando o emulador terminar de carregar, o plugin instala sua aplicação e executa a Activity padrão. Deverá ser mostrado algo parecido com isso:

O “Hello, Android” que você vê na barra cinza é o titulo da aplicação. O plugin cria isso automaticamente (a string é definida no arquivo res/values/strings.xml e é referenciado pelo AndroidManifest.xml). O texto abaixo do titulo é aquele que você definiu ao criar o objeto TextView.

Atualize a interface para um layout XML

O exemplo que você acabou de completar usar o que chamamos interface programada. Significa que constroi sua aplicação diretamente do código fonte. Se você faz muitas programação de interfaces, está bem familiarizado em quanto isso pode ser dificil as vezes: pequenas mudanças no layout podem resultar em uma grande dor de cabeça. É  muito fácil esquecer de conectar Views, que podem resultar em erros em seu layout e gastar muito tempo de depuração do código.
Essa é a explicação para o Android fornecer um modelo alternativo para construir interfaces: arquivos XML. A maneira mais fácil de explicar esse conceito é mostrar um exemplo. Aqui está uma arquivo XML que tem um comportamente identico ao exemplo que nós acabamos de concluir:

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
  android:id="@+id/textview"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:text="@string/hello"/>

A estrutura geral de uma arquivo XML do Android é simples: é uma arvóre de elementos XML, onde cada nó é o nome de uma classe View (nesse exemplo, apenas um único elemento). Você pode o nome de qualquer classe que extende View como um elemento de seu layout, incluindo classe personalizadasque você definiu em seu código. Essa estrutura torna fácil criar rapidamente interfaces usando uma estrutura e sintaxe mais simples que a do esquema usado no layout programado. Esse modelo é inspirado no modelo de desenvolvimento web, onde você pode separar  a apresentação de sua aplicação (interface) da lógica usada para ler e escrever dados.
Os arquivos XML usados para descrever o layout da aplicação são localizados no diretório res/layouyt/directory de seu projeto. O “res” é umam abreviação de “resources”, e o diretório contém todos os recursos que não sejam código fonte necessários para sua aplicação. Além de arquivos de layout, recursos podem ser também imagens, sons, e arquivos de idioma.

Layout Paisagem

Se você quiser uma desenho diferente para o modo paisagem, coloca o arquivo XML de layout dentro de /res/layout-land. Android automaticamente olha aqui quando o layout muda. Sem esse layout especial, o Android irá adaptar o layout padrão.

O plugin para o Eclipse automaticamente cria um desses arquivos de layout para você: main.xml. Na aplicação “Hello World” desse tutorial, esse arquivo é ignorado já que o layout foi criado através de código. Isso foi feito para ensinar sobre o framework Android, mas você deverá quase sempre definir seu layout através de uma arquivo XML ao invés de código fonte. Os procedimentos seguintes instruirão vcoê a mudar a aplicação existente para usar um layout XML.

  1. No “Package Explorer” do Eclipse, expanda a pasta /res/layout/ e abra o arquivo main.xml. Troque o conteúdo dele pelos seguinte código XML: 
    <?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
  android:id="@+id/textview"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:text="@string/hello"/>

    Salve o arquivo.

  2. Dentro da pasta res/values/, abra o arquivo strings.xml. Este arquivo contem todas as strings de sua interface. Se você estiver usando o Eclipse, então o ADT terá criado duas strings, hello e app_name. Altere hello para outra coisa. Talves algo como “Hello Android! Eu sou uma string de recurso”. O arquivo deverá ficar parecido com isso: 
    <?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello, Android! I am a string resource!</string>
    <string name="app_name">Hello, Android</string>
</resources>
  3. Agora abra e modifique sua classe HelloAndroid para que ela use seu layout XML. Edite o arquivo para que ele se pareça com isso: 
    package com.example.helloandroid;
import android.app.Activity;
import android.os.Bundle;
public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

    Ao fazer essa mudança, digite à mão para testar o recurso de code-completion. Quando começa a digitar R.layout.main, o plugin lhe oferecerá sugestões. Você encontrará essa ajuda em várias situações.

Agora re-execute sua aplicação – por já ter sido criada uma configuração, tudo que se faz necessário é clicar no icone com uma seta verde para executar, ou selecione Run > Run History > Android Activity. Tirando a mudança no texto da caixa de texto, a aplicação parece a mesma. Tudo isso serve apenas para mostrar que essas duas abordagens produzem resultados idênticos.