DESENVOLVIMENTO DE APLICAÇÕES SIMPLES

Transcrição

1 Linguagens e Suas Tecnologias Unidade C Caro(a) Aluno(a), até agora nos detivemos basicamente em conhecer a arquitetura utilizada pelo Android, alguns conceitos iniciais relacionados a essa plataforma e também instalação e configuração do ambiente de desenvolvimento padrão. A partir desse capítulo em diante iremos começar a entrar na programação propriamente dita. Prepare seu ambiente para começarmos o desenvolvimento e tenha um bom estudo. Activities, Classe R e criação de Views Como já comentado na unidade anterior, existem duas formas de se criar interfaces gráficas para uma aplicação Android: UNIDADEC DESENVOLVIMENTO DE APLICAÇÕES SIMPLES Através de arquivos XML, onde definimos o conjunto de elementos que farão parte de nossas telas; Ou utilizando classes Java, com um estilo de programação similar ao desenvolvimento de aplicações Swing do Java, em que instanciamos os objetos que queremos utilizar diretamente nas classes do projeto. Também vimos que uma Activity é algo único, que foca em alguma atividade que o usuário pode fazer. Uma Activity funciona como uma classe gerenciadora de UI (User Interface). Já sabemos que todo aplicativo Android começa por uma Activity. Ela pode ser comparada com a classe JFrame do Swing, representando uma tela da aplicação. Uma tela (Activity) geralmente será composta por um conjunto de objetos ou elementos visuais (componentes), tais como textos, botões, imagens, comboboxes, etc.. No Android, esse conjunto de objetos são representados por subclasses que estendem a superclasse android.view.view, ou seja, cada um desses elementos de tela é filho da classe View. Sob essa perspectiva, Activity e View podem ser vistas como classes complementares, onde a Activity é responsável por definir uma tela, controlar o estado desta tela, gerenciar a passagem de parâmetros e definir qual método será executado em resposta a algum comando do usuário. Já a classe View, tem a responsabilidade de literalmente desenhar os elementos dentro da tela. E como essas duas classes são interligadas? Bom, como já vimos na unidade anterior o elemento que cola essas duas classes é o método setcontentview(), o qual pode receber como parâmetro tanto um inteiro (que será uma referência a um arquivo XML na classe R) quanto uma instância da classe View. Para uma melhor compreensão desses conceitos, vamos dar uma olhada no código gerado por nossa aplicação HelloWorld desenvolvida no capítulo anterior: public class HelloWorldActivity extends Activity public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); 39

2 Observando esse trecho de código, podemos notar que passamos como parâmetro para o método setcontentview(), uma constante (R.layout.main), que está definida dentro da classe R. O que isso quer dizer? Significa que estamos carregando o arquivo XML (que está na pasta layout) referenciado pela constante R.layout.main, estará sendo carregado como a estrutura de view de nossa Activity. Mas afinal, o que é essa classe R que volta e meia comentamos? Para entender um pouco melhor o que está sendo feito, vamos dar uma olhada na classe R. Classe R A classe R já foi por diversas vezes mencionada ao longo das unidades que estamos estudando. Esta classe é gerada automaticamente quando criamos um projeto Android pelo Eclipse. Basicamente ela funciona como um meio de campo entre a tela e o código de negócio da sua aplicação. Essa classe é gerenciada diretamente pelo Eclipse, o qual se responsabiliza de criar automaticamente referências (identificadores únicos) a todos os recursos que você coloque na sua aplicação. Esses recursos podem ser imagens, arquivos XML de layout, botões que aparecem em uma tela, campos de texto de outra tela, etc. Todos os recursos presentes em nossa aplicação serão mapeados na classe R. Isso permite que você tenha uma forma de referenciar todo e qualquer recurso que faz parte da sua aplicação a partir do código Java. Atenção: Novamente vale ressaltar que não devemos alterar classe R diretamente. O Eclipse irá alterá-la sempre que houver uma modificação qualquer no projeto. Recursos como imagens, arquivos de layouts e arquivos de internacionalização ficam dentro de subpastas da pasta res do projeto. Cada um desses recursos será identificado unicamente por meio de um número na classe R do projeto. Por exemplo, quando adicionarmos uma nova imagem à nossa aplicação, automaticamente o Eclipse detectará essa inserção, e criará uma constante única que identifica essa imagem. Além de recursos como imagens e arquivos de layout, cada componente adicionado a um arquivo de layout, também terá um identificador único criado para permitir que ele também seja referenciado. Como Fazer: Importante lembrar que todos os recursos externos (arquivos XML, imagens, etc) adicionados ao projeto Android devem possuir nomes compostos por letras minúsculas e sem espaços em branco no nome. Caso esses princípios não sejam seguidos, ao executarmos o projeto, o Eclipse irá nos mostrar uma mensagem de erro. Bom, dentro dessa unidade você já viu que precisamos ter uma Activity para programar as regras de negócio e responder a eventos de tela. Sabe também que quem faz o meio de campo entre as regras de negócio e a tela é a classe R. Falta agora você começar a desenvolver as telas da sua aplicação. As próximas seções dessa unidade visam exatamente isso: criação de views usando XML e por código Java. Criando uma View via XML: Utilizar XML para montar a View tem como grande vantagem a separação clara do código de view do código que contém a lógica de negócios de uma aplicação. Isso deixa o código bem claro e limpo, tornando a tarefa de 40

3 manutenção e entendimento do código, bem mais simplificada. Para usar um XML para criação da view, basta clicar com o botão direito do mouse sobre a pasta destino (res/ layout) e selecionar a opção New->Android XML File, escolher um nome para esse arquivo e pronto, você acabou de criar um arquivo de layout de tela. Ao fazer essa ação, o Eclipse automaticamente detecta que um novo arquivo foi inserido nos recursos do projeto e altera a classe R para refletir essa mudança. Para verificar se isso ocorreu, basta abrir a classe R do seu projeto para procurar uma referência ao arquivo XML que você acabou de criar. Para referenciar esse novo recurso como sendo a view de uma Activity, basta que você crie uma classe que estenda Activity e passe como parâmetro do método setcontentview(view), a referência para a nova constante criada na classe R. O código abaixo mostra como poderia ser feita essa implementação: package br.edu.ifsul.tsi.lt; import android.app.activity; import android.os.bundle; public class Layout_exemplo2Activity extends Activity public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.exemplo2); A linha de código que faz a ligação entre a Activity e a View que queremos renderizar é a que segue: setcontentview(r.layout.exemplo2); Note que a constante R.layout.exemplo2 nada mais é do que uma constante que identifica unicamente o recurso exemplo2.xml, que adicionamos ao projeto. Note ainda que o nome da variável é basicamente o nome do recurso que criamos sem a extensão do tipo de arquivo criado. Se você passar o mouse sobre essa linha de código, pressionando a tecla Ctrl e clicar com o mouse sobre o link que aparece, o Eclipse abrirá o arquivo fonte que contém a definição dessa constante. No caso, o Eclipse abrirá a classe R do nosso projeto que conterá algo parecido com o código abaixo: /* AUTO-GENERATED FILE. DO NOT MODIFY. * * This class was automatically generated by the * aapt tool from the resource data it found. It should not be modified by hand. */ package br.edu.ifsul.tsi.lt; public final class R { 41

4 public static final class attr { public static final class drawable { public static final int icon=0x7f020000; public static final class layout { public static final int layout_exemplo2=0x7f030000; public static final int main=0x7f030001; public static final class string { public static final int app_name=0x7f040001; public static final int hello=0x7f040000; Perceba que cada recurso presente no projeto recebe um valor inteiro único que será utilizado para referenciar o recurso ao longo da nossa aplicação. Outro ponto interessante de se notar, ao visualizar o código acima, é que a classe R agrupa (por meio de classes internas) os diferentes tipos de recursos, separando os arquivos de layout, dos arquivos de imagens, dos arquivos de strings e assim por diante. Para finalizar essa modificação e fazer com que o programa execute corretamente, não se esqueça de adicionar essa nova Activity no seu arquivo descritor AndroidManifest.xml. Caso você não tenha declarado sua nova Activity no descritor, um erro deverá ser lançado do console de Eclipse. A declaração da sua nova Activity dentro do AndroidManifest.xml deverá ter aparência semelhante ao código abaixo. <activity android:name= Exemplo2 > <intent-filter> <action android:name= android.intent.action.main ></action> </intent-filter> </activity> Ao inserir a tag <intent-filter> com a ação MAIN, o Android fica sabendo que essa Activity pode ser executada diretamente como ponto inicial de uma aplicação. Funciona de forma análoga ao método public static void main (String args) de uma aplicação Java comum. Agora, para executar seu projeto, basta criar no Eclipse uma configuração de execução, usando o menu Run >> Configurations, e setando a sua nova Activity como a principal a ser executada, conforme mostrado na figura C.1. 42

5 Figura C.1 Modificando a Activity principal do projeto. Pronto, você acaba de executar outra aplicação Java, agora setando uma nova Activity como sendo principal, e utilizando um arquivo XML para definição de sua View, como mostra a figura C.2: Figura C.2 Execução da nova aplicação Android. Lembrando ainda que... Outra forma que realizar a execução é por meio do botão Run do Eclipse. Ao clicar sobre esse botão o Eclipse abrirá uma janela de conversação solicitando que você escolha que tipo de aplicação deseja executar. Selecione Android Application e clique em OK. Ambas as formas permitirão que você rode suas aplicações Android. Criando uma View via código Java: Além de criar layouts, utilizando arquivos XML, podemos também criar um layout de aplicação utilizando apenas código Java. A seguir mostramos um trecho de código onde criamos o layout de nossa aplicação diretamente no código Java. Crie um novo projeto, e digite o seguinte trecho de código: 43

6 public class Exemplo2 extends Activity public void oncreate(bundle bundle){ super.oncreate(bundle); TextView tv = new TextView(this); tv.settext( Criando uma view através de código Java! ); setcontentview(tv); Como podemos ver no código acima, simplesmente saímos criando objetos das classes que queremos utilizar e depois alteramos os atributos desses objetos. No caso, instanciamos um objeto da classe TextView, setamos o atributo Text desse objeto e depois definimos como parâmetro do método setcontentview(tv) o objeto instanciado. Esse desenvolvimento de aplicação, utilizando somente o código Java para definição do layout, resultaria na geraria a aplicação apresentada na figura C.3. Figura C.3 Execução da aplicação utilizando view gerada por código Java. Como vimos, podemos criar Views utilizando ambos os métodos (XML ou Java puro). No entanto, os exemplos de aplicativos e documentação do Android apontam como uma tendência a utilização de XML para definir as telas dos aplicativos, valorizando a separação total das camadas de lógica do sistema da camada de apresentação do mesmo. As aplicações mostradas nos próximos exemplos serão gerados por meio do modelo de programação que utiliza as definições XML. Acessando elementos da Tela Em um dado ponto de desenvolvimento das nossas telas utilizando arquivos XML, precisaremos ter alguma forma que nos possibilite acessar um determinado elemento que faz parte da nossa tela (um botão, um texto ou qualquer outro componente que esteja na tela). Precisamos possuir uma maneira que nos permita acessar esses elementos como se fosse um objeto Java. Imagine que em dado momento estejamos criando um formulário, com alguns campos para preenchimento, e 44

7 um botão para enviar os dados cadastrados. É necessária alguma forma de acessar esses elementos como eles fossem objetos Java. Bom, você já sabe que podemos utilizar as constantes de referência da classe R, certo? No entanto, mesmo assim, precisamos de algum meio que nos permita recuperar o objeto baseado nos IDs gerados pela classe R, de forma que consigamos executar os métodos dos objetos. Então... Como fazer para recuperar os elementos que estão na tela, de forma que possamos trabalhar com eles como se fossem legítimos objetos? A resposta para isso é o método da classe Activity: findviewbyid(id). Esse método irá buscar o elemento da tela que queremos utilizar baseado no id que será passado como argumento. Esse id nada mais é que o identificador único utilizado na classe R. A linha abaixo segue um exemplo de código que pode ser utilizado para recuperar um componente TextView da tela. TextView tv = (TextView) findviewbyid(r.id.campotexto); O que o código acima faz é buscar o componente TextView que está na tela, cujo o id é R.id.campoTexto. Esse componente é recuperado e jogado para dentro do objeto (tv) instanciado dentro de nossa Activity. A partir desse momento podemos usar quaisquer métodos associados ao objeto TextView recuperado de dentro do código Java. Note que é preciso sempre fazer o cast para o tipo de objeto que vamos trabalhar. Iremos ver diversos exemplos que utilizam esse método na sequência do nosso estudo. Componentes (Widgets) A medida que nos aprofundamos no mundo do Android, percebemos que as suas aplicações são constituídas por pequenos componentes de software, também denominados widgets. Widgets são elementos gráficos que formam uma aplicação. Existe um conjunto básico de Widgets que fazem parte da plataforma de desenvolvimento do Android que precisamos conhecer. A partir de agora vamos explorar alguns desses widgets mais básicos de forma que possamos começar a aplicá-los no de desenvolvimento de aplicações propriamente ditas. Vamos lá! TextView O primeiro componente que iremos nos familiarizar, já é um pouco conhecido, uma vez que já foi citado em alguns trechos das unidades anteriores. Essa widget é uma subclasse de View, que representa um texto (label) na tela. Se você já trabalhou com Swing pode comparar essa classe com a JLabel. Essa widget permite mostrar alguma informação na tela (mensagem). A widget EditText Essa widget também é uma subclasse de View. Utilizada para apresentar um campo de texto onde o usuário possa digitar informações. Pode ser usada para entrada de texto normal, apenas números ou então para campos de senha. A widget Button e ImageButton Componente que representa botões de comando que, quando clicados, disparam uma ação, um evento. A diferença entre ambos é que o componente ImageButton permite usar uma imagem para desenhar o botão. O Button apresenta um botão padrão do componente. 45

8 Conhecendo o utilitário de desenvolvimento de layout Com os componentes até agora vistos, já é possível desenvolver uma pequena aplicação. Crie um novo projeto Android com a seguinte configuração: Project Name: MultiplicaNumeros Build Target Android 2.2 Package Name: br.edu.ifsul.tsi.lt.android Create Activity: AppMultiplica Application Name: Multiplica Números Min SDK Version: 8 Atenção: Nos exemplos demonstrados no projeto vamos utilizar como padrão o Target Name Google APIs, Plataform 2.2 e API Level 8. Pelo nome do projeto, podemos ver que essa é uma aplicação de cálculo. Esse nosso programa vai ler dois números inteiros e, no final, deverá mostrar o produto resultante da multiplicação desses números. Vamos começar o desenvolvimento. Vá ao arquivo main.xml (localizado na pasta res\layout do nosso projeto) para fazer uso da interface utilitária que nos auxiliará a construir a aplicação de forma rápida, por meio de seleção de componentes. Para abrir o arquivo, dê um duplo clique sobre o arquivo main.xml. A tela, que deverá ser aberta, é a apresentada na figura C.4. A figura C.4 nos mostra o utilitário de desenvolvimento de layouts provido pelo plugin instalado ao Eclipse. Este editor visual permite que você vá criando aplicações tanto no estilo WYSIWYG (What You See Is What You Get) quando diretamente via edição de arquivo XML. Vamos dar uma olhada nas principais partes dele. Figura C.4 Utilitário de desenvolvimento de layout. 1. Área demarcada por vermelho: é o local onde será apresentado como sua aplicação está visualmente ficando. Os componentes que você selecionar deverão ser arrastados e depois renderizados nessa área. 46

9 2. Área demarcada por azul: contêm diversas pastas, as quais agrupam vários tipos de componentes que podem ser utilizados dentro da suas aplicações. 3. Área demarcada por verde: abas que permitem a troca do tipo de visualização. O desenvolvedor pode desejar ver ou o layout gráfico que a aplicação está ficando, ou a apresentação do mesmo código na linguagem XML. 4. 4) Área demarcada por amarelo: esta região apresenta alguns comboboxes com diversas opções que permitem ao desenvolvedor customizar o simulador que ele está utilizando. Agora que você já está um pouco mais familiarizado com o nosso utilitário de desenvolvimento, voltemos à criação da aplicação propriamente dita. Desenvolvendo o layout da aplicação Observe que, por padrão, nossa aplicação já apresenta o texto Hello World, MultNumActivity! no componente TextView, conforme detalhado na figura C.5: Figura C.5 - Editor visual no Eclipse. Clique na frase default para selecioná-la a fim que possamos modificar seu conteúdo. Se você observar abaixo, existe uma guia chamada Properties. Esta aba apresenta a lista de propriedades do componente que está sendo editado atualmente, conforme mostra a figura C.6. 47

10 Figura C.6 - Aba properties no Eclipse. Dica: Se a aba de properties não estiver aparecendo em seu Eclipse, você deve habilitá-la por meio do seguinte menu Window -> Show View -> Other -> General -> Properties. Ao clicarmos no componente, a aba de Properties apresentará uma série de atributos-valores do componente selecionado. Para alterar o texto, vá até aba Properties e procure por uma propriedade chamada Text. Essa propriedade armazena o conteúdo assumido pelo componente TextView. Após encontrar a propriedade Text, substitua o valor atual por algo como Número A:, por exemplo, e pressione a tecla ENTER. O resultado você confere na figura C.7. 48

11 Figura C.7 - Editando propriedades dos componentes no Eclipse. Você pode também modificar o valor da propriedade de um componente, selecionando o componente com o botão direito do mouse e editando a propriedade Text. Uma nova janela será aberta. Clique no botão New String. Uma janela será aberta, conforme mostrado na figura C.8. Nessa segunda janela. você preenche as informações da nova string que será adicionada: String: preencha com o texto que irá aparecer na tela. New R. String: preencha com o valor do identificador que será dado a essa string dentro do arquivo Strings.xml. Figura C.8 - Adicionando uma nova String a aplicação Android. Dica: Você também pode realizar a edição dos valores das propriedades dos componentes do layout diretamente no arquivo XML, se achar mais conveniente. 49

12 Continuando a criação do nosso pequeno programa, temos de inserir um componente do tipo EditText que, como vimos anteriormente, funciona como um campo de texto que aceita valores alfanuméricos. Para adicionar um novo componente a esse layout, vamos escolher o componente. Vá na paleta apresentada à esquerda do Eclipse. À medida que selecionamos qual o grupo de componente que queremos acessar (Text fields, Layouts, Images, etc...), uma gama de opções pertencentes à categoria selecionada é apresentado. Para verificar o que cada um desses componentes faz, basta passar o mouse sobre um componente que uma breve descrição é apresentada pelo Eclipse. Navegue pelas categorias da paleta e veja quais componentes poderemos usar futuramente no desenvolvimento de aplicações Android. Após se divertir navegando por entre os componentes, encontre o componente EditText e arraste-o para a área de edição do editor visual, como resultado você deve obter algo como a imagem apresentada na figura C.9. Figura C.9 - Resultado da inserção dos primeiros componentes na interface. Podemos agora verificar/modificar algumas propriedades desse componente. Fazemos isso ou pela aba properties do editor visual, ou pelo editor XML. Nesse componente até agora podemos verificar a existência algumas propriedades já setadas: id, layout_width e layout_height. Agora vamos adicionar mais dois componentes a nossa interface, um novo TextView e um outro EditText, os quais armazenarão informações referentes aos nossos outros valores para entrada de dados. Feito isso teremos que inserir um último componente de botão (Button) em nossa aplicação. Modifique as propriedades de texto desses componentes de forma que tenhamos uma interface mais amigável, como mostrado na figura C.10: 50

13 Figura C.10 - Inteface com diversos componentes adicionados. Dica: Lembre-se! A propriedade ID dos componentes será o meio de referenciar os componentes dentro da nossa aplicação Android. Portanto é sempre interessante que você coloque nomes de identificadores significativos, que facilitem saber com qual elemento estamos trabalhando.> Desenvolvendo a parte de negócio da aplicação Após termos criado a view de nossa aplicação, vamos agora partir para a programação, utilizando a linguagem Java. Abra o código da nossa Activity principal do seu projeto e digite o código parecido com o que é apresentado a seguir: package br.edu.ifsul.tsi.lt; import android.app.activity; import android.os.bundle; import android.widget.*; import android.view.*; import android.app.*; public class MultNumActivity extends Activity { EditText numa, numb; 51

14 @Override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); numa = (EditText) findviewbyid(r.id.edittext1); numa = (EditText) findviewbyid(r.id.edittext2); Button botao = (Button) findviewbyid(r.id.button1); botao.setonclicklistener(new View.OnClickListener() public void onclick(view v) { double num_a = Double.parseDouble(numA.getText().toString()); double num_b = Double.parseDouble(numB.getText().toString()); double res = num_a * num_b; (MultNumActivity.this); AlertDialog.Builder alerta = new AlertDialog.Builder alerta.settitle( Alerta ); alerta.setmessage( Multiplicação: + res); alerta.setneutralbutton( OK, null); alerta.show(); ); Vamos detalhar alguns pontos interessantes desse código... A linha: numa = (EditText) findviewbyid(r.id.edittext1); Faz referência ao primeiro EditText que colocamos em nosso editor visual. Como já discutimos, o método findviewbyid(id) com o parâmetro R.id.editText1 faz referência ao componente EditText de nosso XML, que possui o ID edittext1. Importante ressaltar que estamos utilizando a classe R para colar o que temos no nosso arquivo de definição de tela (main.xml) com o código Java que estamos trabalhando (Activity principal do nosso projeto). Na linha seguinte fazemos referência à segunda EditText usando novamente o método findviewbyid(), passando como parâmetro dessa vez, o identificador do segundo componente EditText presente em nossa tela (R.id. edittext2). O procedimento é o mesmo para os demais componentes de tela. Outra coisa importante a se fazer, é o cast do tipo de dado, que não pode ser esquecido. No caso de ambos exemplos, estamos fazendo o cast para 52

15 a classe EditText. Seguindo o código, podemos ver um evento onclick que foi adicionado ao nosso componente Button. Dessa forma, quando o usuário clicar sobre o botão, o código existente nesse trecho, deverá ser executado. No caso acima, o programa efetuará a multiplicação dos números de entrada e mostrar o resultado. Atenção: Se você tem conhecimento prévio de Java, entenderá que estamos realizando a programação através de uma classe interna. Por isso que temos essa sintaxe no mínimo diferente em nosso código. Por hora, basta entender que estamos criando um comportamento que será realizado sempre que o botão for clicado. O método setonclicklisneter define um evento de Click a um componente. Esse método leva como parâmetro uma instância de OnClickListener e dentro dessa instância existe o método chamado onclick, que será disparado toda vez que o botão for clicado. O código interno desse método já é bastante conhecido de quem trabalhou com Java. A linha: double num_a = Double.parseDouble(editText1.getText().toString()); Cria uma variável denominada num_a e atribui a ela o valor que está contido no campo edittext. É preciso utilizar o método parsedouble da classe Double pois o conteúdo que está dentro do campo vem como sendo do tipo String. Ainda temos que chamar o método gettext() de edittext1 para retornar o conteúdo do campo. Diferente de muitos métodos de retorno String, o método gettext() retorna objeto Editable. Isso faz com que ainda precisemos chamar o método tostring() de gettext() para que conseguíssemos uma string, que será então convertida em um Double. Tal procedimento é feito também nas demais linhas, nas quais buscamos dados de componentes EditText. Depois de realizadas essas conversões de tipos de dados, o código a seguir realiza o cálculo e depois exibe o resultado na tela: AlertDialog.Builder dialogo = new AlertDialog.Builder(AppSoma.this); dialogo.settitle( Aviso ); dialogo.setmessage( Soma: + res); dialogo.setneutralbutton( OK, null); dialogo.show(); A classe AlertDialog.Builder basicamente cria caixas de diálogo e as exibe. A figura C.10 apresenta como nossa aplicação deverá ficar quando for executada. 53

16 Figura C.10 - Aplicação de multiplicação sendo executada no emulador. Pronto, desenvolvemos nossa primeira aplicação utilizando Android. A partir de agora começaremos a explorar mais componentes de tela que podem ser utilizados para criar aplicações mais robustas, além é claro de ir agregando conhecimentos que nos permitirão desenvolver aplicações cada vez mais interessantes. Na próxima etapa do nosso trabalho, você ampliará ainda mais seus conhecimentos nessa tecnologia. Atividades 1. Utilize o fórum da disciplina para gerar dúvidas sobre os conteúdos estudados nesse capítulo e também debater temas relativos ao desenvolvimento na plataforma Android. 2. Exercício: Adicione botões a nossa aplicação de cálculo para as demais aritméticas básicas, e crie métodos similares ao que foi visto que executem as funções de adicionar, subtrair e dividir. Referências: LECHETA, Ricardo R. Google Android: Aprenda a criar aplicações para dispositivos móveis com o Android SDK. 2ª Ed São Paulo: Novatec, SILVA, Luciano Alves da. Apostila de Android: Programando passo a passo. 4ª Ed. Disponível em: < ueuo.com> Acesso em: 26 ago Widgets, você sabe o que é isso? Disponível em: < -que-e-isso/> Acesso em: 26 ago