Introdução ao Desenvolvimento Android



Autor: Fabio Mattes <fabiomattes2007 at gmail.com>
Data: 18/07/2011

O que é esse tal de Android?

Segundo a wikipédia:
“Android é um sistema operacional móvel que roda sobre o núcleo Linux, embora por enquanto seja ainda desenvolvido numa estrutura externa ao núcleo Linux. Foi inicialmente desenvolvido pela Google e posteriormente pela Open Handset Alliance, mas a Google é a responsável pela gerência do produto e engenharia de processos. O Android permite aos desenvolvedores escreverem software na linguagem de programação Java controlando o dispositivo via bibliotecas desenvolvidas pela Google. Existem atualmente mais de 100 mil aplicações disponíveis para Android. O sistema operativo Android consiste em 12 milhões de linhas de código, incluindo 3 milhões em XML, 2.8 milhões de linhas de C, 2.1 milhões de linhas de código Java e 1.75 milhões de linhas de código em C++.”
Fonte: http://pt.wikipedia.org/wiki/Android

Os Principais Sistemas Disponíveis

Symbian:
Atualmente rodando nos celulares da Nokia (esta sem previsão de portar seus celulares para Android), sucessor do Epoc, este sistema é agradável de se usar, mas a parte de desenvolvimento é complicada sendo só possível fazer aplicações em Java puro. Rápido e multitarefa, ele pode ser rodado em aparelhos mais antigos e com poucos recursos de processamento. Por exemplo o Psion 5 que tinha um processador de apenas 36MHZ, 10 vezes mais inferior que os atuais ARM’s.

Linux: Introdução ao Desenvolvimento Android

Windows Mobile:
O mais usado em Smartphones (Infelizmente), devido a sua interface idêntica ao sistema operacional Windows e pela integração com o MS-Outlook, MSN e outros. Por ser mais pesado (novidade), é mais usado em aparelhos com poder de processamento mais alto, isso sem contar o fato de que os aparelhos rodando o Windows Mobile são mais caros. Mas ainda é o mais usado por conter uma gama de aplicativos maior que os demais, por exemplo o Skype.

Linux: Introdução ao Desenvolvimento Android

PalmOS:
A dor de cabeça de quem tem um aparelho com este SO, é que ele está desatualizado e perdendo mercado para os concorrentes com maior poder de desenvolvimento. Ainda pode ser usado, mas em aparelhos antigos. Os aparelhos lançados até o momento ainda sofrem com a falta de desenvolvimento de aplicações novas.

Linux: Introdução ao Desenvolvimento Android

Em fim o Android:
O Android é a solução do Google para o problema. SO Open-Source, com Kernel Linux. Agrandando 4 setores diferentes:

  1. Os fabricantes de aparelhos;
  2. Os desenvolvedores;
  3. Os fabricantes de chips;
  4. Os próprios consumidores.

Agrada os fabricantes de aparelhos devido ao custo zero, aos desenvolvedores por que o mesmo já tem a sua SDK própria gratuita com emulador e tudo mais, agrada aos fabricantes de chips por adicionar novos recursos aos aparelhos, aumentando a demanda de aparelhos mais potentes e por último, mas não menos importante, agrada os consumidores, por ter um visual bonito e limpo, sem falar que tem muitas aplicações desenvolvidas (praticamente todo dia aparecem novas).
Palmas para o Google.

Linux: Introdução ao Desenvolvimento Android

Começando: Eclipse e AndroiSDK

Primeiramente antes de começa,r vou levar em conta que você já tenha a java SDK instalada e configurada no seu sistema.
A distribuição que estou usando é o Debian 6 Squeeze, mas pode ser usada em qualquer distribuição.
Os softwares necessários são:

Instalando o Eclipse Classic

Crie a seguinte pasta /home/seusuario/eclipse e descompacte o Eclipse e coloque dentro dela.
Execute o arquivo eclipse. Você também pode adicionar um atalho ao seu Desktop para ele. Lembrando novamente que estou levando em consideração que você já tenha a sdk do java instalado e configurado.
Ao inciar o Eclipse pela primeira vez, lhe será pergunta onde será o workspace, ou seja, onde ficarão armazenados os projetos, você pode deixar o padrão ou pode criar uma pasta a parte se você quiser.
Depois de aberto, lhe será mostrado a área de trabalho do Eclipse como na imagem abaixo:

Linux: Introdução ao Desenvolvimento Android

Instalando o AndroidSDK

Agora iremos instalar o emulador do Android, o AndroidSDK.
Depois de baixado, abra um terminal e acesse a pasta onde se encontra o arquivo compactado, em seguida descompacte o arquivo:
$ tar -xvzf android-sdk_r11-linux_x86.tgz
Ele irá descompactar a pasta android-sdk-linux_x86, entre nesta pasta e dê um ls.
$ cd android-sdk-linux_x86
$ ls
Resultado:
add-ons  platforms  platform-tools  SDK Readme.txt  temp  tools
A pasta tools é onde se encontra o emulador em si, acesse ela e execute o emulador:
$ cd tools
$ ./android
E isso ai, estamos prontos para instalar o Android em nosso emulador:

Linux: Introdução ao Desenvolvimento Android

Você também pode criar se quiser um atalho no Desktop para ele.
Agora iremos instalar o Android, primeiramente veja que temos 5 opções na lateral esquerda, clique em Available Packages, aguarde ele atualizar a lista de aplicativos:

Linux: Introdução ao Desenvolvimento Android

Clique na setinha que se encontra ao lado dehttps://dl-ssl.google.com/android/repository/repository.xml.
Será mostrado todas as aplicações disponíves para instalar no emulador. Para o nosso artigo iremos utilizar apenas a plataforma 2.2 do Android então marque:

Linux: Introdução ao Desenvolvimento Android

Marque apenas a opção SDK Platform Android 2.2, API 8, revision 2 e clique em Install Selected, será exibida uma janela para confirmação, clique em Accept e em seguida Install. Será iniciado o download do nosso Android 2.2.

Linux: Introdução ao Desenvolvimento Android

Após terminar o download a tela não irá fechar sozinha, clique em Close como na imagem abaixo e pronto.

Linux: Introdução ao Desenvolvimento Android

Criando o nosso Dispositivo Virtual

Agora criaremos o nosso AVD (Android Virtual Device) para que possamos rodar nosso Sistema Android.
Clique na opção Installed Packages na lateral esquerda e veja que apenas o nosso SDK Platform Android 2.2, API 8, revision 2 se encontra instalado.

Linux: Introdução ao Desenvolvimento Android

Vamos criar nosso dispositivo virtual, clique na aba Virtual Devices e em seguida clique em New, lhe será apresentada a seguinte tela:

Linux: Introdução ao Desenvolvimento Android

Onde os campos são:

  • Name: Nome que deseja dar para este Dispositivo Virtual;
  • Target: Você deve apontar para a API desejada. No meu caso, apontei para o Android 2.2 que instalei;
  • SD Card: Aqui você define o tamanho que deseja para o arquivo que será o Dispositivo Virtual;
  • Skin: Nesta opção você poderá definir a resolução que deseja utilizar ou tamanho de tela;
  • Hardware: Opções para abstração ou comunicação com o seu hardware.

Iremos usar a seguinte configuração:

  • Name: Android2.2
  • Target: Android 2.2 – API Level 8
  • SD Card: 2000 MiB
  • Skin: Built-in: HVGA
  • Hardware: Podem deixar o padrão que se encontra.

Após preenchermos todas as configurações clicamos em Create AVD, ele irá demorar um pouco, mas isso é totalmente normal.
Depois de criado podemos iniciar o nosso Android 2.2 clicando em Start, ele irá abrir a tela abaixo, clique em Launch e pronto, ele também demora para carregar, mas é só pra carregar, quando estivermos desenvolvendo, basta deixarmos ele aberto e nossa aplicação irá se atualizar, sem precisarmos fechar o emulador.

Linux: Introdução ao Desenvolvimento Android

Iniciando o Android 2.2

Linux: Introdução ao Desenvolvimento Android

Linux: Introdução ao Desenvolvimento Android

Depois de Iniciado:

Linux: Introdução ao Desenvolvimento Android

Agora podem brincar com seu Android, podem até navegar na internet usando o navegador dele:

Linux: Introdução ao Desenvolvimento Android

Plugin ADT e testando o Ambiente de Desenvolvimento

O Plugin ADT

O Plugin ADT é um plugin para Eclipse desenvolvido para agilizar no processo de desenvolvimento para a plataforma Android.
Basicamente existem duas maneiras de se instalar o ADT:

  1. Instalação online;
  2. Instalação offline.

Instalação Online:
Com o Eclipse aberto clique em Help > Install New Software, será aberta a tela de instalação de novos plugins:

Linux: Introdução ao Desenvolvimento Android

Em seguida clique em add no canto direito para adicionarmos o repositório para instalação:

Linux: Introdução ao Desenvolvimento Android

Serão mostrados dois campos:

  • Name;
  • Location.

Em Name coloque um nome para o plugin ADT, por exemplo ADT Plugin.
Em Location coloque: https://dl-ssl.google.com/android/eclipse/, caso não encontre a url troque o https por http, e clique em ok, ele irá carregar os plugins para o Eclipse, fazer o Download e Instalar, após isso será mostrado a seguinte tela:

Linux: Introdução ao Desenvolvimento Android

Marque a caixa Developer Tools e clique em next, lhe será mostrado:

Linux: Introdução ao Desenvolvimento Android

Clique em next na próxima janela, depois clique em Accept e Finish na próxima janela:

Linux: Introdução ao Desenvolvimento Android

Lhe será mostrada a seguinte janela, apenas clique em Ok e continue:

Linux: Introdução ao Desenvolvimento Android

Ele irá instalar o plugin:

Linux: Introdução ao Desenvolvimento Android

Em seguida será perguntado se você quer reiniciar o Eclipse, clique em Restart Now e pronto, plugin ADT instalado:

Linux: Introdução ao Desenvolvimento Android

Instalação Offline:
Para a instalação offline o único diferencial é que ao invés de você digitar a url na janela de adição de url’s, vc irá selecionar o zip do ADT em sua maquina clicando em Archive, o resto é idêntico ao método online.

Testando o Plugin e o Android SDK

Agora que temos tudo pronto, que tal testarmos o nosso ambiente de desenvolvimento.
Abra o Eclipse e clique em File > New > Other, lhe será exibida a seguinte imagem:

Linux: Introdução ao Desenvolvimento Android

Clique na seta Android e em Android Project, em seguida Next. Abrirá a tela de configuração do projeto:

Linux: Introdução ao Desenvolvimento Android

Preencha os campos conforme abaixo, os demais deixe padrão:

  • Project Name: TesteAndroid
  • Build Target: Marque a caixa Android 2.2
  • Application Name: Teste de Android
  • Package: br.com.teste
  • Create Activity: Marque a caixa Create Activity e preencha com actTeste
    Obs.: Activity é o que gerencia toda a interface com o usuário.
  •  
  • Min SDK Version: Reparem que esse campo é o mais interessante, notem que logo acima em Build Target no Android 2.2 tem um campo chamado API Level, esse é o nível das aplicações desenvolvidas nessa plataforma, no número que está nela é 8, se você digitar no campo Min SDK Version outro número, ele não aceitara, possibilitando assim não cometermos erro na hora de selecionar a plataforma desejada, seja ela 1.5, 2.2, 2.3, 3.0, etc. Sempre preencha este campo com o número igual ao da API Level da plataforma, como a gente está usando a 2.2 a sua a API Level é 8.

Ficando assim nossa configuração:

Linux: Introdução ao Desenvolvimento Android

Clique em Finish e ele irá criar o nosso projeto TesteAndroid e sua estrutura de arquivos e pastas:

Linux: Introdução ao Desenvolvimento Android

Agora reparem que ele montou a seguinte estrutura:

  • src -> br.com.teste -> actTeste.java
  • gen -> br.com.teste -> R.java
  • Android 2.2 -> android.jar
  • assets
  • res   
    • -> drawable-hdpi -> icon.png      
    • -> drawable-ldpi -> icon.png      
    • -> drawable-mdpi -> icon.png 
  • layout -> main.xml
  • values -> strings.xml
  • AndroidManifest.xml
  • default.properties
  • proguard.cfg

A pasta src é onde se encontra o nosso fonte em java, exemplo: a classe principal, classes auxiliares, etc.
A pasta gen é a mais interessante, é nela que fica o arquivo R.java, este arquivo é o que faz a comunicação das janelas, componentes e variáveis com o fonte java. Ele é gerado automaticamente, por recomendação não deve ser editado.
A pasta Android 2.2 é onde ficam as bibliotecas responsáveis para se trabalhar com o Android.
A pasta res é onde ficam nossos resources como imagens.
A pasta layout como o nome já diz, é onde ficam nossas interfaces gráficas, janelas com botões, etc.
A pasta values é onde se encontram as nossa variáveis de comunicação com componentes, explicarei com mais detalhes assim que começarmos a programar.
Estas são as pastas e arquivos mais importantes para começarmos a analisar nosso projeto.
Vamos testar nossa aplicação sem mexer em nada, clique com o botão direito do mouse em cima do nome da nossa aplicação, ou seja TesteAndroid e seguida em Run As e Android Application, se o emulador estiver fechado o eclipse abrirá o emulador, ele pode demorar um pouco como disse mais atrás, mas para evitar de ficar abrindo o emulador toda hora, deixe ele aberto, ele atualiza sua aplicação direto no emulador aberto:

Linux: Introdução ao Desenvolvimento Android

Legal né?
Se ele rodou e mostrou a seguinte tela para você, então está tudo pronto para começarmos a desenvolver.

Mãos a obra, uma calculadora simples

Bom vamos começar nosso desenvolvimento com uma calculadora simples.
Com o tempo eu irei criando mais artigos com mais exemplos de aplicações.
Primeiramente crie um novo projeto Android como mostrei na parte anterior, com as seguintes propriedades:

  • Project Name: calculadora
  • Build Target: Android 2.2
  • Application Name: Calculadora 1.0
  • Package Name: br.com.calculadora
  • CreateActivity: calcActivity
  • Min. SDK Version: 8

Primeiramente clique 2 vezes no arquivo main.xml na pasta res -> layout, esse arquivo é o responsável pela interface gráfica da nossa aplicação, como vocês podem ver na tela abaixo:

Linux: Introdução ao Desenvolvimento Android

Reparem que na parte de cima nós temos algumas propriedades:

  • A primeira que temos é a da resolução do dispositivo, clique nele e selecione 3.2in HVGA (ADAP2), que no caso é o padrão 320×480 px. Note que ele aumentou a janela para adicionarmos nossos widgets;
  • Ao lado da resolução temos a orientação: Portrait ou Landscape, ou seja, Retrato ou Paisagem, deixe como Portrait(Retrato);
  • Ao lado temos os temas, deixe como está. E por último temos a plataforma usada, ou seja, Android 2.2;
  • No lado esquerdo abaixo temos nossa paleta de widgets, é aqui que se encontram todos os nossos componentes visuais, basta como no Delphi, Lazarus ou NetBeans, clicar e arrastar para adicionar o nosso widget.

Muito prático, mas também é possível adicionar ou alterar nossos componentes via xml clicando logo abaixo em main.xml:

Linux: Introdução ao Desenvolvimento Android

Vejam que dos dois modos é muito fácil de se criar uma janela com xml, faça um teste, se você está no modo xml clique em Graphical Layout e apague todos os widgets que estão nele clicando em cima apertando a tecla DEL, adicione o primeiro widget chamado TextView, ele é o equivalente ao Label do Delphi/Lazarus, em seguida clique em main.xml e veja que ele automaticamente criou o código xml:

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android&#8221;
    android:layout_width=”fill_parent”
    android:layout_height=”fill_parent”
    android:orientation=”vertical”>
<TextView android:text=”TextView” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”>
</LinearLayout>

Agora no modo xml selecione a linha que começa por <TextView, copie com CTRL+C, dê um enter e cole com CTRL+V, agora volte ao modo gráfico, e veja que ele já adicionou um novo TextView, legal demais. Faça os testes, coloque um Button pelo modo gráfico e entre no modo xml e veja o código, notem que ele tem muitas propriedades. Tá! E pra alterar estas propriedades?
Simples, no modo gráfico olhe a aba outline dê 2 cliques no nome do widget e veja abaixo as propriedades:

Linux: Introdução ao Desenvolvimento Android

Mas, nada me impede de alterar as propriedades via xml, vamos conhecer algumas:
android:text – está propriedade altera o texto do widget, você pode colocar um texto normal ou uma variável criada no arquivo strings.xml. Exemplo 1: Altere a propriedade android:text do widget TextView:

<TextView android:text=”Olá Mundo” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>

Execute o emulador clicando com botão direito do mouse em cima do projeto e clique em Run As -> Android Application e veja o resultado.
Exemplo 2: Abra o arquivo strings.xml na pasta res -> values, clique em add, será mostrado a seguinte tela:

Linux: Introdução ao Desenvolvimento Android

Clique em String e de um ok, ele irá voltar para a tela de adição de variáveis, clique na variável String que acabamos de criar e olhem a direita, temos 2 propriedades para preencher: Name e Value. Preencha como “teste” e “Olá mundo2”.
Agora volte ao nosso main.xml e no modo xml altere a propriedade android:text para:

<TextView android:text=”@string/teste” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>

Execute novamente a aplicação, como eu já havia mostrado antes.
Com isto estamos referenciando o texto para pegar o valor da variável teste que criamos.
android:id
A propriedade android:id nada mais é do que um identificador para os widgets, ou seja, quando formos criar nossas aplicações no arquivo java, iremos referenciar no widgets ao código java por este ID.
Vamos a um exemplo pratico, volte ao modo gráfico e adicione um Button na tela, em seguida volte ao modo xml e altere as seguintes linhas:
<TextView android:text=”@string/teste” android:id=”@+id/textView1″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<Button android:text=”Button” android:id=”@+id/button1″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></Button>
Para:

<TextView android:text=”@string/teste” android:id=”@+teste/txtTexto” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
<Button android:text=”Trocar Texto” android:id=”@+teste/btnTroca” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></Button>

Veja que alteramos a propriedade id do TextView para @+teste/txtTexto, ou seja, trocamos o seu nome e seu identificador, a mesma coisa com o Button, essa propriedade é muito interessante caso você tenha uma aplicação com várias telas, você poderia identificar cada widget em suas respectivas telas.
Outra coisa interessante também seria você abrir o arquivo R.java na pasta gen e olhar seu conteúdo, mas lembre-se de não altera-lo:

Linux: Introdução ao Desenvolvimento Android

Notem que tudo o que foi criado se encontra nele, é ele que irá fazer a ponte entre o xml dos widgets e o código java em si.
Voltemos então ao nosso exemplo prático, abra o arquivo principal do nosso exemplo, o calcActivity.java:

Linux: Introdução ao Desenvolvimento Android

Nele iremos fazer acontecer a mágica. Eis o seu conteúdo:

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

Primeiramente vamos importar as bibliotecas necessárias. Na seção imports digite:

import android.widget.*; // Importando a classe widget
import android.view.*;     // importando a classe view

Sem essas classes não iremos conseguir manipular os widgets e nem criar seus eventos.
Agora vamos instanciar nossos widgets, antes de @override digite o seguinte código:

TextView txtTexto; // Cria um Objeto TextView
Button btnTroca;  // Cria um Objeto Button

Criado nossos widgets vamos referência-los ao nosso main.xml, logo abaixo a linha setContentView(R.layout.main); digite:

txtTexto = (TextView) findViewById(R.teste.txtTexto); // Aqui fazemos a referencia com o método findViewById(), muito fácil.
btnTroca = (Button) findViewById(R.teste.btnTroca);

Que tal agora criarmos um evento pra eles, logo abaixo a linha btnTroca = (Button) findViewById(R.teste.btnTroca); digite o seguinte código:

btnTroca.setOnClickListener(new View.OnClickListener() { // Criando o evento para o clique do botão
                  @Override
         public void onClick(View arg0) {
            txtTexto.setText(“Você trocou o texto!”);
                      }
});

Execute novamente e olhe o resultado. Muito simples não?
Eis o código completo:

package br.com.calculadora;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
public class calcActivity extends Activity {
/** Called when the activity is first created. */
   TextView txtTexto;
   Button btnTroca;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        txtTexto = (TextView) findViewById(R.teste.txtTexto);
        btnTroca = (Button) findViewById(R.teste.btnTroca);
        btnTroca.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View arg0) {
            txtTexto.setText(“Você trocou o texto!”);
         }
      });
    }
}

Calculadora simples, Layout…

Agora vamos finalmente criar a nossa calculadora. Apague todos os widgets que estão na tela, e remova os seguintes trechos de código da classe principal calcActivity.java:

package br.com.calculadora;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
public class calcActivity extends Activity {
/** Called when the activity is first created. */
   TextView txtTexto; // <- Remover
   Button btnTroca; // <- Remover
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
  txtTexto = (TextView) findViewById(R.teste.txtTexto); // <- Remover daqui
        btnTroca = (Button) findViewById(R.teste.btnTroca);
        btnTroca.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View arg0) {
            txtTexto.setText(“Você trocou o texto!”);
         }
      }); <- até aqui
    }
}

Vamos começar adicionando os widgets nesta sequência, lembrando sempre em colocar os valores das propriedades entre ” (aspas duplos):
*TextView
propriedade text: Calculadora 1.0
*TextView
propriedade text: Digite o primeiro número:
*EditText
propriedade text: em branco
propriedade layout_width: match_parent
propriedade id: @+calc/edtNum1
*TextView
propriedade text: Digite o segundo número:
*EditText
propriedade text: em branco
propriedade layout_width: match_parent
propriedade id: @+calc/edtNum2
*TextView
propriedade text: Resultado:
*EditText
propriedade text: em branco
propriedade layout_width: match_parent
propriedade id: @+calc/edtResultado
*LinearLayout
O LinearLayout organiza os componentes em ordem Horizontal e/ou Vertical, aqui deixaremos ele como Horizontal, clicando nos botões em destaque na imagem abaixo:

Linux: Introdução ao Desenvolvimento Android

E dentro deste LinearLayout vamos adicionar um Button com as seguintes propriedades:
propriedade text: Somar
propriedade id: calc/btnSomar
E pronto nosso layout está pronto, se quiser executar para ver como fica no emulador fica a seu critério:

Linux: Introdução ao Desenvolvimento Android

Segue o código xml, arquivo main.xml:

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android&#8221;
    android:orientation=”vertical”
    android:layout_width=”fill_parent”
    android:layout_height=”fill_parent”
    >
    <TextView android:text=”Calculadora 1.0″ android:id=”@+id/textView1″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
    <TextView android:text=”Digite o primeiro número:” android:id=”@+id/textView2″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
    <EditText android:layout_height=”wrap_content” android:id=”@+calc/edtNum1″ android:text=”” android:layout_width=”match_parent”></EditText>
    <TextView android:text=”Digite o segundo número:” android:id=”@+id/textView3″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
    <EditText android:layout_height=”wrap_content” android:id=”@+calc/edtNum2″ android:text=”” android:layout_width=”match_parent”></EditText>
    <TextView android:text=”Resultado:” android:id=”@+id/textView4″ android:layout_width=”wrap_content” android:layout_height=”wrap_content”></TextView>
    <EditText android:layout_height=”wrap_content” android:layout_width=”match_parent” android:id=”@+calc/edtResultado” android:text=””></EditText>
    <LinearLayout android:layout_height=”wrap_content” android:layout_width=”match_parent” android:id=”@+id/linearLayout1″>
        <Button android:text=”Somar” android:id=”@+calc/btnSomar” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></Button>
    </LinearLayout>
</LinearLayout>

Calculadora simples, Codificação

Agora vem a parte interessante, a codificação da nossa aplicação Calculadora.
Até agora o código do nosso calcActivity está assim:

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

Vamos começar fazendo uma soma simples, abra o arquivo calcActivity.java se não estiver aberto.
Instancie os widgets e crie as variáveis em formato double para armazenar os números, com o seguinte código acima de @override:

EditText edtNum1, edtNum2, edtResultado;
Button btnSomar;
double num1, num2, resultado;

Agora vamos referência-los, abaixo da linha setContentView(R.layout.main); digite:

// Casts para relacionar os widgets
edtNum1 = (EditText) findViewById(R.calc.edtNum1);
edtNum2 = (EditText) findViewById(R.calc.edtNum2);
edtResultado = (EditText) findViewById(R.calc.edtResultado);
btnSomar = (Button) findViewById(R.calc.btnSomar);

Vamos criar o evento do botão somar, abaixo do cast btnSomar digite:

btnSomar.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View v) {
            num1 = Double.parseDouble(edtNum1.getText().toString()); // Variavel num1 recebe o valor convertido em double do EditText edtNum1
            num2 = Double.parseDouble(edtNum2.getText().toString()); // Variavel num2 recebe o valor convertido em double do EditText edtNum2
            resultado = num1 + num2; // Variavel resultado recebe o valor da soma de num1 = num2
            edtResultado.setText(String.valueOf(resultado)); // Valor de resultado é convertido em string e passado para o edtResultado.
         }
});

Pronto, simples não, pode rodar e testar a aplicação:

Linux: Introdução ao Desenvolvimento Android

E é isso ai gente. Agora ficou fácil de implementar o resto das função como subtrair, multiplicar e dividir, fica ai então como exercício e divertimento de vocês fazerem estas funções.
Espero voltar com mais artigos sobre Android, pois achei muito interessante desenvolver nessa plataforma, espero que tenham gostado e muito obrigado.
Também quero deixar meu agradecimento ao Professor Neri Neitzk, sem o qual nunca teria conhecimento de como programar nesta fabulosa plataforma que é o Android.
Referências:


Anúncios

Publicado em 19 de julho de 2011, em Vivaolinux. Adicione o link aos favoritos. Deixe um comentário.

Um comentário começa grandes debates!

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: