Baixe o app para aproveitar ainda mais
Prévia do material em texto
Android: Desenvolvimento para Dispositivos Móveis 1 Android: Desenvolvimento para Dispositivos Móveis 2 Apresentação 5 Módulo 1 – Introdução ao Android e XML 6 Aula 1 – Fundamentos do Sistema Operacional Android 6 1.1 Características do Sistema Operacional Android 6 1.2 Os Dispositivos Móveis Android 8 Aula 2 – Introdução ao XML 11 2.1 Conceitos básicos de XML (eXtensible Markup Language) 11 2.2 Manipulação de documentos XML 12 2.3 APIs: DOM, SAX e TrAX 14 Exercício do Módulo 1 15 Módulo 2 – Ambiente de Desenvolvimento Android 16 Aula 3 – SDK Android, Eclipse e Integração ADT 16 3.1 Baixando e instalando o SDK Android 16 3.2 Utilizando o Eclipse como IDE para Android (ADT: Android Developer Tools) 20 3.3 Criando um dispositivo virtual para testar no emulador 26 3.4 Seu primeiro aplicativo Android no Eclipse 30 Exercícios do Módulo 2 42 Módulo 3 – View e Activity 43 Aula 4 – Widgets Básicos e Definição de View 43 4.1 Widgets: os componentes de uma tela Android 44 4.2 Introdução ao Activity: a classe Java controladora de uma tela 46 4.3 Mais Widgets: EditText, ImageView e Toast 48 Aula 5 – Aprofundando o conhecimento sobre a classe Activity 51 5.1 O ciclo de vida de uma Activity: onCreate, onDestroy e etc. 51 5.2 Eventos de clique em botões 52 5.3 ListActivity = Activity + ListView 53 Exercícios do Módulo 3 58 Módulo 4 – Layouts e Intents 60 Aula 6 – Organizando a tela com gerenciadores de layout 60 6.1 RelativeLayout 61 6.2 Linear Layout 62 6.3 Menus e Caixas de Diálogo 65 7.1 Definição da classe Intent 68 7.2 Criando e abrindo uma nova tela com Intent 69 7.3 Passando valores para uma nova tela 72 Exercícios do Módulo 4 73 Módulo 5 – Banco de Dados em Android 75 Aula 8 – Banco de Dados em Android 75 8.1 Banco de Dados SQLite 75 8.2 Criação do banco de dados 76 8.3 Criação da classe DAO para acesso aos dados 78 8.4 Incluindo, excluindo e exibindo registros 81 Sumário Android: Desenvolvimento para Dispositivos Móveis 3 Exercícios do Módulo 5 85 Módulo 6 – Visão Geral de Recursos do SDK 86 Aula 9 – GPS, WebServices, Câmera e Áudio/Vídeo 86 9.1 Acessando longitude, latitude e altitude por meio do GPS do aparelho 86 9.2 Consumindo Web Services RESTful 90 9.3 Utilizando a câmera para fotos e vídeo 93 9.4 Reproduzindo arquivos de áudio 97 Exercício do Módulo 6 99 Considerações Finais 100 Respostas Comentadas dos Exercícios 101 Módulo 1 101 Módulo 2 102 Módulo 3 108 Módulo 4 117 Módulo 5 128 Modulo 6 143 Referências 148 Android: Desenvolvimento para Dispositivos Móveis 4 Apresentação Bem-vindo(a) à nossa disciplina, caro aluno (a). Meu nome é Luiz, mas sou mais conhecido pelo meu sobrenome: Querino. Vou apresentar a você os conceitos (e, é claro, as práticas) essenciais para a criação de aplicativos móveis (os famosos apps) para aparelhos equipados com o sistema operacional Android. Certamente, você já conhece os fundamentos de programação na linguagem Java, incluindo a criação dos tradicionais aplicativos desktop (que são executados nos computadores de mesa), e também dos aplicativos web, feitos para serem executados pela internet, usando um navegador. Estamos vivendo uma nova revolução na computação pessoal, ocasionada pelo aparecimento dos smartphones e tablets. As pessoas passaram a contar com esses tipos de aparelho no seu dia a dia, passando literalmente a “depender” deles! Isso abriu as portas dos desenvolvedores de software para um novo e empolgante segmento: a criação dos apps, os pequenos (mas poderosos) programas para dispositivos móveis. Dentre os diversos aparelhos existentes no mercado, aqueles que executam o sistema operacional Android se destacam como os mais vendidos, justamente por serem acessíveis e estarem disponíveis em diversas configurações. Por isso, o Android é hoje o líder isolado no mercado de sistemas operacionais para dispositivos móveis (seguido pelo iOS da Apple em segundo lugar, e pelo Windows Phone da Microsoft, que ainda possui uma fatia bem pequena desse novo e disputadíssimo mercado). O sistema operacional Android é desenvolvido primariamente pela Google, a gigante mundial que começou como um mecanismo de busca e hoje está presente em diversas áreas da TI. Desde o início, a Google tinha intenção de popularizar o sistema operacional, por isso, ele está disponível em aparelhos de vários fabricantes, sendo que estes também participam ativamente do processo de desenvolvimento e atualização do Android. Uma das medidas usadas pela Google para popularizar o Android foi ter optado pelo uso da linguagem Java para o desenvolvimento de aplicativos. Como Java já era uma linguagem amplamente conhecida e utilizada por milhões de desenvolvedores, estes poderiam fácil e rapidamente começar a desenvolver apps para Android! E é justamente aí que nós entramos! Como você já é um programador Java, nada melhor que acrescentar agora o desenvolvimento de aplicativos móveis Android no seu portfólio! Prepare-se, então, para entrar de cabeça na onda do momento: o desenvolvimento de apps! Luiz Carlos Querino Filho Android: Desenvolvimento para Dispositivos Móveis 5 Módulo 1 – Introdução ao Android e XML Este primeiro módulo trata de uma rápida introdução ao sistema operacional Android, seus aplicativos e o mercado de apps. Em seguida, são apresentados alguns conceitos básicos da linguagem XML, amplamente usada nos projetos de aplicativos Android. Aula 1 – Fundamentos do Sistema Operacional Android 1.1 Características do Sistema Operacional Android Caro aluno, em Querino Filho (2013), livro que trata sobre Android, afirmamos que a origem do sistema operacional Android remonta a uma empresa criada em 2003 no Vale do Silício, Califórnia (EUA), denominada Android Inc., por Andy Rubin, Rich Miner, Nick Sears e Chris White. Inicialmente, a empresa parecia mais uma dentre as centenas de startups criadas naquela região, com ideias mirabolantes de desenvolvimento de aplicações móveis e uma perspectiva de ser, quem sabe, a próxima Apple ou a próxima Google... E foi justamente a Google que começou a prestar atenção na pequena empresa e seu potencial de inovação tecnológica. Em 2005, reconhecendo a qualidade daquilo que estava sendo criado na Android Inc., a Google comprou a empresa e deu início à criação de um novo sistema operacional para dispositivos móveis (celulares, naquela época), usando como base o código-fonte do Linux. No dia 5 de novembro de 2007, a Google fez dois anúncios importantes: o primeiro, a formação do grupo Open Handset Alliance, encabeçado por ela e formado por diversas empresas do setor móvel, como Samsung, Sony e HTC; o segundo, anunciando o primeiro produto resultante do trabalho desse grupo — o sistema operacional Android. (QUERINO FILHO, 2013). O sistema passou, então, a ser testado e aprimorado, até que em Setembro de 2008 foi lançado o Android 1.0 – a primeira versão disponível comercialmente. Finalmente, o mundo teria acesso a aparelhos equipados com o hoje já conhecido “robozinho verde” (Figura 1). Figura 1. O robozinho verde símbolo do sistema operacional Android Fonte: <http://upload.wikimedia.org/wikipedia/commons/d/d7/Android_robot.svg> Acesso em: 10 out. 2014. Android: Desenvolvimento para Dispositivos Móveis 6 Desde esse primeiro lançamento, muita coisa mudou. O Android assumiu a liderança do mercado de sistemas operacionais para dispositivos móveis, superando o iOS (que equipa o iPhone e o iPad da Apple) que era líder até sua chegada, e hoje está presente em centenas de aparelhos dos mais diversos fabricantes. No momento da elaboração deste material, a versão mais recente do Android era a 4.4, denominada KitKat (Figura 2). Figura 2. Tela do Android 4.4 KitKat Fonte: <http://upload.wikimedia.org/wikipedia/commons/thumb/c/c7/Android_4.4.2.png/337px-Android_4.4.2.png>Acesso em: 10 out. 2014. Android: Desenvolvimento para Dispositivos Móveis 7 Antes que você pergunte: Sim, o nome KitKat veio daquele chocolate em barras que você conhece...É uma tradição da Google dar um codinome para cada versão do Android com o nome de um doce, sempre em ordem alfabética. Por exemplo, a primeira versão a ganhar esse tipo de “apelido” foi a 1.5, chamada Cupcake. Em seguida, vieram Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice Crem Sandwich, Jelly Bean e, finalmente, KitKat. Para cada versão, também é criado um desenho estilizado do robozinho verde como a sobremesa “da vez” (veja a Figura 3). Figura 3: Codinomes das versões do Android Fonte: <http://techtoward.com/wp-content/uploads/2014/02/Android-Versions-History.jpg>. Acesso em: 10 out. 2014. 1.2 Os Dispositivos Móveis Android Existem hoje no mercado centenas de smartphones e tablets equipados com o sistema operacional Android, de modelos muito simples e mais acessíveis até os mais caros e sofisticados. Fabricantes conhecidos como Samsung, Motorola, HTC e LG trazem ao usuário várias opções, com diferentes capacidades de processamento, memória e tamanho de tela. Isso proporciona ao usuário uma grande variedade de escolha, mas traz também uma nova preocupação ao desenvolvedor: como compatibilizar seu app para todas essas variedades de aparelhos? Apesar do sistema operacional ser o mesmo nos aparelhos que divulgam o fato de serem “Android”, há algumas peculiaridades a serem consideradas, segundo Querino Filho (2013): • A diversidade de versões do Android: é possível encontrar hoje no mercado celulares com versões mais antigas (como 2.2 e 2.3) até as versões mais novas (como 4.X). Isso ocasiona variações sig- nificativas entre elas. Android: Desenvolvimento para Dispositivos Móveis 8 • Customizações ao Android original adicionadas pelos fabricantes: a natureza “livre e aberta” do Android possibilita aos fabricantes de aparelho fazerem pequenas (mas impactantes) mudanças no SO, de forma que ele aproveite ao máximo o recurso dos aparelhos. • Variações na configuração (hardware) de cada aparelho: como já citado, cada modelo tem uma con- figuração específica. Por exemplo, o tamanho de uma tela pode variar por cerca de 3 a 7 polegadas em um smartphone e até mesmo mais de 10 polegadas em um tablet. Como podemos ver, a versatilidade do Android é uma faca de dois gumes: dá ao usuário mais opções de escolha de um lado, mas dificulta um pouco de outro – o “nosso lado” como desenvolvedores, que temos de preparar o aplicativo de forma que execute corretamente em várias configurações. Manter a compatibilidade com o vasto universo de aparelhos Android é tão importante que a própria Google coloca no site oficial dos desenvolvedores <http://developer.android.com/index.html>, uma estatística sobre a diversidade atual de versões (Figura 4). Figura 4. Estatística sobre as versões do Android em uso, em Agosto de 2014 Fonte: <http://developer.android.com/about/dashboards/index.html>. Acesso em: 13 out. 2014. As estatísticas da Figura 4 são geradas com base nos aparelhos com Android acessando a Google Play Store. Podemos ver que, embora cerca de 85% dos usuários já estejam usando as versões mais recentes (4.x), uma fatia importante (cerca de 15%) ainda usa versões mais antigas, como a 2.3. Esse percentual tende a ser ainda maior em países com população de baixa renda, em que celulares mais simples (como os que executam as versões 2.x) são mais vendidos. O que isso significa para nós, desenvolvedores? Significa que, ao criarmos um app para Android, devemos nos assegurar de que ele executará na maior quantidade possível de versões, para que possamos alcançar mais “clientes”. E para que isso aconteça, são necessários alguns cuidados na hora de criar seu app (falaremos mais sobre isso quando começarmos a criar os programas). Android: Desenvolvimento para Dispositivos Móveis 9 Outro fator a ser considerado: o tamanho e a resolução das telas. Veja o gráfico da Figura 5. Os dados e gráficos da Figura 5, também gerados com base nos dispositivos que acessam a Google Play Store, mostram que há uma grande variedade de tamanhos de tela (e resoluções) nos aparelhos. Se o desenvolvedor não adequar seus apps para essas diferenças, poderá correr o risco do seu aplicativo aparecer com a tela cortada, “bagunçada” ou exibindo gráficos com baixa qualidade. Figura 5. Estatísticas sobre o tamanho e a resolução de tela em uso nos dispositivos Android, em Agosto de 2014 Fonte: <http://developer.android.com/about/dashboards/index.html>. Acesso em: 13 out. 2014. Android: Desenvolvimento para Dispositivos Móveis 10 E QUANTO AO JAVA ME (ANTIGO J2ME)? Bem antes do Android existir, a linguagem Java já se fazia presente nos dispositivos móveis, por meio do “J2ME”, hoje conhecido como Java ME (Mobile Edition). Mas não confunda os dois! O Android é um sistema operacional completo, desenvolvido por um grupo de empresas lideradas pela Google, cujos aplicativos são escritos em Java. Já o Java ME é uma versão compacta da máquina virtual Java padrão, e foi criado para executar em dispositivos embarcados, incluindo alguns tipos de celulares. O Android, visualmente mais rico e preparado para usar os recursos mais modernos dos smartphones, superou o Java ME como plataforma Java mais popular para dispositivos móveis, apesar deste último ainda marcar presença significativa em outros segmentos. Fonte: QUERINO FILHO (2013) Aula 2 – Introdução ao XML Antes de começarmos a criar nossos programas Android, vamos fazer uma rápida introdução à linguagem XML. Como você verá durante a disciplina, esta linguagem é intensamente usada dentro do Android, principalmente para especificação de dados e da estrutura básica das telas dos aplicativos. 2.1 Conceitos básicos de XML (eXtensible Markup Language) Resumidamente falando, XML é uma linguagem usada para especificação de dados de uma maneira estruturada e significativa. De acordo com Fawcett e Quin (2012) o XML surgiu e ganhou popularidade como uma maneira eficiente de troca de dados entre dispositivos e plataformas distintas, de forma que esses dados pudessem ser entendidos por qualquer uma das partes envolvidas. Outra característica importante do XML e que essas “partes” citadas possam ser tanto máquinas quanto humanos, ou seja, dados em XML são estruturados de forma que possam ser criados e lidos (interpretados) por um software ou pela pessoa que criou e está usando o software. Sabemos que os computadores lidam com informações em bits (dígitos com valor zero ou um). Esse formato, denominado formato binário, é facilmente entendido por um computador, mas nem tanto por Android: Desenvolvimento para Dispositivos Móveis 11 um ser humano. Além disso, dados binários são codificados em uma forma específica de uma determinada arquitetura de computadores, o que dificulta ainda mais o uso destes dados por outro tipo de sistema. Já os arquivos em formato texto (também conhecidos pela extensão .TXT usada em muitos desses arquivos), também podem ser processados e lidos facilmente por um computador (pois cada caractere corresponde a uma dada sequência de bits), trazendo a vantagem de poderem ser lidos também por seres humanos. Uma desvantagem do uso de arquivos de formato texto, no uso para transferência de dados, está na definição de uma sintaxe adequada para a formatação dos dados, os chamados metadados. A definição dos metadados pode variar muito, além de ocupar um espaço significativo dentro do arquivo. O XML veio para sanar os problemas inerentes aos formatos binário e texto! Ainda de acordo com Fawcett e Quin (2012), tudo começou com a criação do padrão SGML - Standard Generalized Markup Language para facilitar a especificação dos metadados de um arquivo texto. O SGML, apesar dejá ser um bom começo no caminho de uma padronização para troca de dados, ainda era complexo demais – da sua simplificação surgiu, em 1996, o XML. Foi um passo tão importante para a internet que já nasceu como um padrão do World Wide Web Consortium (W3C), a entidade que controla os padrões usados na web. 2.2 Manipulação de documentos XML Para melhor entender o funcionamento do XML, vamos começar com um exemplo de arquivo no formato texto apresentado no Quadro 1. Quadro 1 – Arquivo Texto Detergente Farinha de Trigo Sabão em Pó Olhando os dados do Quadro 1, podemos deduzir que se trata de uma lista de produtos. Mas produtos do quê e de onde? Pode ser uma lista de compras de supermercado, pode ser um conjunto de produtos no estoque de uma empresa...Poderíamos até mesmo complementar as linhas do arquivo com mais uma informação, como mostra o Quadro 2. Quadro 2 – Arquivo Texto Modificado Detergente, 5 Farinha de Trigo, 2 Sabão em Pó, 4 Vemos agora que, após a descrição do produto, temos uma vírgula seguida de um número. O que significa esse número? O preço de venda do produto? Ou sua quantidade de estoque? Android: Desenvolvimento para Dispositivos Móveis 12 Não podemos saber ao certo, pois estão faltando os metadados, ou seja, os dados sobre os dados – as informações sobre o que está especificado em cada linha. Poderíamos transformar a listagem do Quadro 2 em um arquivo XML, em que tudo ficaria mais claro, como no Quadro 3. Quadro 3 – Arquivo XML <estoque> <produto descricao=”Detergente” quantidade=”5” /> <produto descricao=”Farinha de Trigo” quantidade=”2” /> <produto descricao=”Sabão em Pó” quantidade=”4” /> </estoque> Agora sim, sabemos que se trata de um estoque! E que cada item é um produto, como uma descrição e uma quantidade. Experimente escrever o código XML do Quadro 3 em um arquivo de texto (que você pode criar com o bloco de notas no Windows), salvá-lo com a extensão .xml e abri-lo em um navegador (o Firefox e o Chrome são os que apresentam melhores resultados neste sentido). Você poderá ver sua estrutura como na Figura 6. Figura 6. Arquivo XML aberto no browser Firefox Android: Desenvolvimento para Dispositivos Móveis 13 Repare que o navegador “entende” a sintaxe do arquivo, separando os elementos e possibilitando que você expanda ou contraia cada um (clicando nos sinais de - e +). 2.3 APIs: DOM, SAX e TrAX Criar arquivos XML manualmente, como fizemos na seção anterior, não é prático nem desejável. De forma semelhante, ler e interpretar seus dados diretamente, também não é ideal – afinal de contas, o intuito é de que as informações possam ser extraídas automaticamente do arquivo XML. Para podermos usar os dados contidos em um arquivo XML em um programa, precisamos de um parser XML. O parser é capaz de extrair as informações de um arquivo XML e retorná-las em um formato adequado a um tipo de sistema ou linguagem (como um objeto em Java, por exemplo). Um dos modelos para o qual os dados de um documento XML podem ser extraídos é o DOM (Document Object Model). Trata-se de uma representação em árvore do documento XML, e é também usado em arquivos HTML. Veja, na Figura 7, um gráfico mostrando a hierarquia de uma tabela HTML dentro do DOM. Figura 7: Representação DOM de uma tabela Fonte: <http://www.w3.org/TR/WD-DOM/table.gif>. Acesso em: 13 out. 2014. Outra forma de se especificar a estrutura de um arquivo XML são os DTDs (Document Type Definitions) e XML Schemas. Podemos dizer que, quando precisamos de uma representação de dados maior e mais detalhada, o uso de DTDs e XML Schemas é mais interessante que DOM. À medida que começarmos a usar XML no Android, você verá que XML Schemas são as formas para representar os dados que utiliza. Android: Desenvolvimento para Dispositivos Móveis 14 Exercício do Módulo 1 1. Arquivo XML para dados de clientes • Crie em um editor de texto qualquer um arquivo XML adequado para guardar uma lista de três clientes de uma empresa. • Os dados dos dois primeiros clientes são os seguintes: ◊ Cliente código 12991 • Nome: Maria • Endereço: Rua das Roseiras 123 • Telefone: 2332-1231 • Data da última compra: 10 de julho de 2014 ◊ Cliente código 10112 • Nome: José • Endereço: Rua das Roseiras 123 • E-mail: jose@mail.com • Saldo: -800,00 • Para o terceiro cliente, especifique você mesmo os valores • Abra o arquivo em um navegador para validá-lo. 2. Validando um arquivo pelo navegador • Escreva o código abaixo em um arquivo texto, salve-o com a extensão .xml e abra-o em um navegador. Veja como os erros existentes no arquivo são identificados e impedem sua exibição (o que não ocorre com arquivo HTML). Java possui, há muito tempo, APIs próprias para a leitura e geração de arquivos XML. A SAX (Simple API for XML) é uma das opções, em que a leitura dos arquivos XML é feita de forma sequencial. Já a TrAX (Transformation API for XML), que faz parte da API JAXP, permite a conversão de um documento XML em outros formatos. (FAWCETT; QUIN, 2012) Dentro do Android, a maior parte da leitura e criação de arquivos XML é feita internamente pelo sistema operacional, evitando que o desenvolvedor precise utilizar diretamente API desse tipo. Android: Desenvolvimento para Dispositivos Móveis 15 Módulo 2 – Ambiente de Desenvolvimento Android Você já sabe neste momento que aplicativos Android são criados em Java. Mas não basta apenas ter o JDK instalado no seu computador para começar a criar seus apps – você precisa também do Android SDK. Ele contém o conjunto de APIs específicas deste sistema operacional, imprescindível para criar um aplicativo “com a cara do Android”. Neste módulo, você saberá como obter o Android SDK, instalá-lo e deixá-lo pronto para uso, assim como começar a criar seus próprios aplicativos em Java para o sistema do robô verde! Aula 3 – SDK Android, Eclipse e Integração ADT 3.1 Baixando e instalando o SDK Android Antes de mais nada, certifique-se de que você já tem o JDK instalado na máquina. Caso ainda não esteja, ou se você simplesmente deseja atualizar o seu JDK (o que é sempre uma boa ideia), acesse <http://www. oracle.com/technetwork/java/javase/downloads/index.html> e faça o download. Lembre-se de baixar a versão correta para seu sistema operacional, de 32 ou 64 bits, além de ajustar o link, caso este esteja desatualizado, ok? Vamos agora ao download do Android SDK, que contém as bibliotecas básicas para desenvolver em Java para Android. Acesse <http://developer.android.com> e procure pelo botão indicado na Figura 8. Android: Desenvolvimento para Dispositivos Móveis 16 Figura 8: Link para download do Android SDK Fonte: <http://developer.android.com>. Acesso em: 13 out. 2014. Na tela seguinte, a versão adequada do SDK para seu sistema operacional poderá ser baixada, bastando clicar no botão indicado na Figura 9. Android: Desenvolvimento para Dispositivos Móveis 17 Figura 9: Botão para download do Android SDK na versão do seu sistema operacional Fonte: <http://developer.android.com>. Acesso em: 13 out. 2014. Em seguida, você deverá concordar com os termos do download do Android SDK e escolher se deseja a versão de 32 ou 64 bits do pacote (Figura 10). Esta é uma etapa muito importante. Escolha adequadamente de acordo com a quantidade de bits do seu sistema operacional (e, consequentemente, do JDK que você baixou e instalou anteriormente). Android: Desenvolvimento para Dispositivos Móveis 18 Figura 10: Concordando com os termos e escolhendo a quantidade de bits Fonte: <http://developer.android.com>. Acesso em: 13 out. 2014. Finalmente começará o download. Quando concluir, você possuirá um arquivo .zip com nome adt- bundle-sistema_operacional-versao. Descompacte este arquivo em alguma pasta do seu computador, preferencialmente umasubpasta da sua pasta pessoal para não ter problemas relacionados a permissões de acesso aos arquivos do SDK e do Eclipse. No exemplo da Figura 11, descompactei meu pacote na pasta Documentos. Android: Desenvolvimento para Dispositivos Móveis 19 Figura 11: Pasta descompactada do pacote do Android SDK Você também pode notar pela Figura 11 que existe, dentro da pasta principal do pacote do SDK, uma subpasta chamada eclipse. Lá dentro encontra-se uma versão do IDE Eclipse customizada para desenvolvimento de aplicativos Android. Como vamos usá-la o tempo todo, recomendo criar um atalho ao eclipse.exe (o ícone do globo) no seu Desktop. Clique duas vezes sobre o atalho criado (ou diretamente no aplicativo eclipse.exe) existente na pasta para abrir o IDE. Veremos na próxima seção como configurá-lo para trabalhar com nossos projetos Android. JÁ POSSUO UMA VERSÃO DO ECLIPSE INSTALADA. O QUE DEVO FAZER? Você pode tranquilamente manter as duas, sendo que cada uma pode ter seu próprio workspace para não misturar os projetos. Para não se confundir, dê para cada uma um nome de atalho diferente no Desktop 3.2 Utilizando o Eclipse como IDE para Android (ADT: Android Developer Tools) Ao abrir o Eclipse do Android SDK pela primeira vez, será solicitado que você defina um workspace para seus projetos (Figura 12). Escolha uma pasta de sua preferência e clique no botão OK. Android: Desenvolvimento para Dispositivos Móveis 20 Figura 12: Definindo o workspace para o Eclipse ADT Talvez apareça em seguida uma tela questionando se deseja colaborar com o desenvolvimento do Eclipse ADT e enviar estatísticas de uso ao Google. Faça sua escolha e clique em Finish para prosseguir. A tela principal do Eclipse será aberta em seguida (Figura 13). Quem já conhece o Eclipse não perceberá logo de início muita diferença, exceto pelos botões do Android na barra de ferramentas. Para podermos começar a desenvolver aplicativos Android com o Eclipse e o Android SDK, precisamos acrescentar mais alguns componentes que não estão inclusos no pacote padrão. Isso é feito pelo aplicativo SDK Manager, que pode ser aberto diretamente de dentro do Eclipse. Android: Desenvolvimento para Dispositivos Móveis 21 Figura 13: Tela inicial do Eclipse Clique no primeiro botão do Android (aquele que possui uma seta para baixo). Ele abre o SDK Manager, que usaremos para atualizar e instalar novos componentes no Android SDK (Figura 14). Android: Desenvolvimento para Dispositivos Móveis 22 Figura 14: Tela do Android SDK Manager Precisamos instalar a versão mais recente do Android para podermos desenvolver e testar nossos aplicativos. Marque as opções indicadas na Figura 14 e depois clique em Install XX packages. Android: Desenvolvimento para Dispositivos Móveis 23 ATENÇÃO! FUJA (pelo menos por enquanto) DAS VERSÕES “W”!!! As versões com a letra W indicam que se trata do Android Wear, usado em dispositivos como relógios. Para programar para tablets e smartphones, precisamos da versão padrão (sem a letra W). Também evite usar versões Preview ou Beta, pois ainda podem conter bugs. Após clicar no botão Install, você deverá concordar com as licenças dos pacotes que serão baixados. Selecione Accept License e clique em Install, como é mostrado na Figura 15. Figura 15: Aceitando as licenças e instalando os novos pacotes Terminada a instalação dos novos pacotes, remova quaisquer versões do tipo W ou Preview instaladas, para que você não tenha surpresas no processo de desenvolvimento e teste dos seus aplicativos. (Veja um exemplo de quais pacotes remover na Figura 16). Android: Desenvolvimento para Dispositivos Móveis 24 Figura 16: Removendo versões Wear ou Preview Para remover os pacotes, lembre-se de clicar no botão Delete, como indicado na Figura 16. Será solicitada uma confirmação para a remoção dos pacotes. Pronto! Agora você já tem os pacotes adequados para começar a desenvolver. Basta apenas preparar o emulador para depois poder testar os apps. Android: Desenvolvimento para Dispositivos Móveis 25 3.3 Criando um dispositivo virtual para testar no emulador Para testar seus aplicativos, você utilizará o emulador do Android incluído no SDK. Antes de utilizá-lo, é preciso criar um “dispositivo virtual Android” (AVD: Android Virtual Device), que é uma “imagem” do sistema operacional com uma configuração de hardware adequada para seus testes (simulando, assim, um dispositivo real). Você precisa criar somente um AVD para testar seus programas. Porém, caso deseje (ou precise), pode criar AVDs com diferentes versões do Android e configurações de hardware variadas para testes. Vamos criar um AVD para um dispositivo padrão usando a versão 4.4 (KitKat). Para isso, no Eclipse, clique sobre o botão indicado na Figura 17. Figura 17: Botão da barra de ferramentas para abertura do AVD Manager O AVD Manager será aberto. Inicialmente, como você pode ver pela Figura 18, não há nenhuma imagem criada. Para criá-la, clique sobre o botão Create. Android: Desenvolvimento para Dispositivos Móveis 26 Figura 18: AVD Manager: gerenciador de dispositivos virtuais para o emulador do Android Configure o AVD com os valores de acordo com a Figura 19, que será apresentada a seguir: Android: Desenvolvimento para Dispositivos Móveis 27 Figura 19: Configurações do novo dispositivo virtual Android Android: Desenvolvimento para Dispositivos Móveis 28 As principais configurações são as seguintes: • AVD Name: um nome identificador para o AVD. O valor colocado aqui será o nome da imagem no AVD Manager; • Device: escolha um dos dispositivos na lista para determinar o tamanho e a resolução da tela do emulador. Não são mostrados todos os dispositivos existentes no mercado – apenas alguns tama- nhos padronizados estão cadastrados; • Target: essa configuração é importantíssima! Determina a versão do Android que será usada no emulador. Escolha aquele que você instalou pelo SDK Manager na seção anterior (não use versões W – são destinadas a outros tipos de aparelho); • Keyboard: certifique-se de que a opção Hardware keyboard present esteja marcada. Assim, será possível digitar valores nos aplicativos em execução no emulador diretamente pelo teclado do com- putador, sem necessidade de uso do teclado virtual. • Snapshot: marque esta opção para não ter de esperar a inicialização do Android toda vez que iniciar o emulador. Feitas as configurações básicas, clique no botão OK para que o AVD seja criado. Ele será exibido na lista de dispositivos virtuais do AVD Manager (veja Figura 20). Figura 20: Dispositivo virtual criado no AVD Manager Android: Desenvolvimento para Dispositivos Móveis 29 Tudo pronto! Pode fechar o AVD Manager e vamos finalmente criar nosso primeiro aplicativo Android. 3.4 Seu primeiro aplicativo Android no Eclipse Para poder exemplificar a criação passo a passo de um aplicativo Android, vamos criar um programa simples, que realiza uma contagem com base em toques em um botão. Crie o seu projeto clicando sobre a seta no botão indicado na Figura 21 e selecionando Android Application Project. Figura 21: Criando um novo projeto de aplicativo Android no Eclipse Será iniciado o assistente de criação do projeto. A primeira tela permite que você defina o nome do aplicativo e outras configurações importantes (veja Figura 22), detalhadas a seguir. Android: Desenvolvimento para Dispositivos Móveis 30 Figura 22: Criando um novo projeto de aplicativo Android – Primeira Tela Application Name: o nome do aplicativo que será exibido quando estiver instalado em um aparelho Android. Neste caso, escolhemos Contador. Project Name: o nome do projeto dentro do Eclipse. Geralmente deixamos o mesmo nome definido em Application Name. Package Name: um nome para o pacote dasclasses Java do seu projeto. Caso possua, coloque um nome de domínio internet em formato reverso; senão crie algum valor fictício diferente do padrão (com.example). Minimum Required SDK: a versão mínima do Android necessária para que o aplicativo funcione. O padrão atual (API 8: Android 2.2) indica que nosso app poderá ser executado em versões do Android iguais ou superiores a esta – assim, a abrangência do aplicativo aumenta, como dissemos. Porém, recursos novos acrescentados em versões posteriores poderão não estar disponíveis. Android: Desenvolvimento para Dispositivos Móveis 31 Target SDK e Compile With: estas opções marcam qual será a versão usada para compilar o projeto. É recomendado deixar esta opção na versão mais recente disponível em produção (neste caso, a KitKat 4.4). Theme: o tema usado pelo aplicativo, que determinará seu visual padrão. Mantenha o valor default. Clicando em Next, passamos para a próxima tela (veja Figura 23). Nela, manteremos as opções padrão, que indicam que criaremos uma tela inicial junto ao aplicativo e que configuraremos um ícone para ele (a próxima etapa). Figura 23: Criando um novo projeto de aplicativo Android – Segunda Tela A tela seguinte possibilita a definição de um ícone customizado para o aplicativo (veja Figura 24). Você poderá usar um arquivo PNG existente (Image), um Clipart (escolhendo dentro de um conjunto de símbolos) ou um texto estilizado (Text). Faça sua escolha (ou continue com o ícone padrão) e clique em Next para prosseguir. Android: Desenvolvimento para Dispositivos Móveis 32 Figura 24: Criando um novo projeto de aplicativo Android – Terceira Tela Na penúltima etapa podemos configurar o layout básico da tela inicial do aplicativo, como na Figura 25. Para nossos projetos, escolheremos sempre a primeira opção (Blank Activity – uma tela padrão do Android em branco). Clique em Next em seguida. Android: Desenvolvimento para Dispositivos Móveis 33 Figura 25: Criando um novo projeto de aplicativo Android – Quarta Tela A última etapa consiste na definição do nome do arquivo de layout e a classe Java para a tela inicial (Figura 26). Em breve, conheceremos melhor o papel destes arquivos. Deixe os valores default e clique em Finish para finalizar a criação do projeto. Android: Desenvolvimento para Dispositivos Móveis 34 Figura 26: Criando um novo projeto de aplicativo Android – Quinta Tela Após alguns segundos, seu projeto estará criado e pronto para ser modificado. A tela do Eclipse com um projeto recém-criado é semelhante à apresentada na Figura 27. Android: Desenvolvimento para Dispositivos Móveis 35 Figura 27: Projeto Contador no Eclipse • À esquerda, temos o Project Explorer, em que são exibidos os arquivos do projeto. Os dois arqui- vos mais importantes para nós, por enquanto, são os seguintes: ◊ MainActivity.java, na pasta src: é o arquivo no qual escrevemos o código Java relativo aos eventos (ações) que ocorrem em uma tela. Por exemplo, quando a tela é criada ou quando o usuário toca em um botão. ◊ activity_main.xml, na pasta res\layout: contém a especificação em XML do layout da tela do programa. É este arquivo que está aberto no momento e você pode vê-lo (no modo de layout gráfico) na parte central do Eclipse. • Na parte central do Eclipse são exibidos os arquivos atualmente abertos. Na Figura 27, o arquivo atualmente aberto é o activity_main.xml, que contém o layout da tela. Quando criamos o layout, podemos alternar entre sua exibição gráfica (por meio da aba Graphical Layout, na parte inferior), ou do seu código em XML. Outros arquivos abertos podem ser “trazidos para frente”, por meio do uso das abas. • No canto superior direito, temos o Outline, ele é útil, pois mostra um resumo dos elementos con- tidos no arquivo atualmente abertos. Se for um arquivo de layout (como é o caso da Figura 27), ele mostrará a hierarquia dos widgets na janela (os componentes que usamos para montar uma tela – como botões e rótulos de texto). Android: Desenvolvimento para Dispositivos Móveis 36 • No lado superior, ao meio, temos a Properties Window, a janela de propriedades. Ela é usada para modificarmos os atributos dos widgets existentes na tela. Por exemplo, clicando sobre um bo- tão, podemos trocar o texto exibido dentro dele alterando a propriedade Text. • Por fim, na parte inferior do Eclipse, temos janelas de informações diversas. É ali que ficará o Log- Cat, usado no Android para obtermos informações sobre a execução de um programa e verificação de erros de programação. A primeira etapa na criação de um app geralmente é a montagem da sua interface. No Android, fazemos isso colocando e configurando os elementos visuais (widgets), e isso pode ser feito graficamente ou por meio da escrita direta do arquivo XML. Para escrever o layout de uma tela em XML, na parte inferior da janela central do Eclipse, clique na aba com o nome do arquivo XML. Você tem duas opções agora: pode construir sua interface graficamente, arrastando os widgets existentes na palheta (Palette) e configurando suas propriedades de acordo com a listagem do Quadro 4, ou digitar diretamente seu código em XML. Android: Desenvolvimento para Dispositivos Móveis 37 Quadro 4 – Código do arquivo activity_main.xml (pasta res\layout do projeto) <RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android” xmlns:tools=”http://schemas.android.com/tools” android:layout_width=”match_parent” android:layout_height=”match_parent” android:paddingBottom=”@dimen/activity_vertical_margin” android:paddingLeft=”@dimen/activity_horizontal_margin” android:paddingRight=”@dimen/activity_horizontal_margin” android:paddingTop=”@dimen/activity_vertical_margin” tools:context=”posjava.android.contador.MainActivity” > <TextView android:id=”@+id/txtContador” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_alignParentTop=”true” android:layout_centerHorizontal=”true” android:layout_marginTop=”48dp” android:text=”0” android:textAppearance=”?android:attr/textAppearanceLarge” /> <Button android:id=”@+id/button1” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_below=”@+id/txtContador” android:layout_centerHorizontal=”true” android:layout_marginTop=”42dp” android:text=”Contar” android:onClick=”onClickContar”/> </RelativeLayout> Neste layout, temos um TextView, usado para exibição de um texto, e um Button, o qual, quando tocado, incrementará uma variável contadora que será posteriormente mostrada no TextView. O TextView recebeu o id txtContador, e será por meio dele que faremos acesso a esse widget pelo código Java. Também modificamos a propriedade text de cada um deles, colocando nela o texto que será exibido (0 inicialmente para o TextView contador e “Contar” para o botão). Repare, na última linha das configurações do Button, que definimos o valor onClickContar para sua propriedade onClick. Trata-se do nome do método Java que será disparado, dentro do arquivo MainActivity.java, quando o usuário clicar no botão. Android: Desenvolvimento para Dispositivos Móveis 38 CUIDADO NA HORA DE DEFINIR O NOME DO MÉTODO PARA onClick! O nome que você coloca na propriedade onClick de um Button deve ser exatamente o mesmo que utilizará no código Java! Tome cuidado, pois maiúsculas e minúsculas fazem, sim, toda a diferença. Vamos agora ao código Java. Abra o arquivo MainActivity.java, existente dentro da pasta src do seu projeto. Deixe o código-fonte como o exibido no Quadro 5. As linhas que você deverá adicionar estão em negrito. Quadro 5 – Código do arquivo MainActivity.java(pasta src do projeto) package posjava.android.contador; import android.os.Bundle; import android.support.v7.app.ActionBarActivity; import android.view.Menu; import android.view.MenuItem; import android.view.View; import android.widget.TextView; public class MainActivity extends ActionBarActivity { int contador = 0; public void onClickContar(View v) { TextView txtContador = (TextView)findViewById(R.id.txtContador); contador++; txtContador.setText(String.valueOf(contador)); } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } Android: Desenvolvimento para Dispositivos Móveis 39 @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.main, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { // Handle action bar item clicks here. The action bar will // automatically handle clicks on the Home/Up button, so long // as you specify a parent activity in AndroidManifest.xml. int id = item.getItemId(); if (id == R.id.action_settings) { return true; } return super.onOptionsItemSelected(item); } } Começamos acrescentando os imports para duas classes do Android SDK que vamos utilizar: View e TextView. Em seguida, no início da classe, declaramos uma variável int denominada contador e atribuímos 0 a ela. Essa variável será criada assim que a janela for aberta (ou seja, assim que o programa começar), e será visível por todos os métodos existentes nela. Sua “vida útil” será a mesma da classe, como a classe corresponde à janela, enquanto a janela estiver ativa a variável será mantida. O método onClickContar será executado quando o usuário tocar no botão que colocamos na interface. Repare que esse método deve ter o mesmo nome colocado no arquivo XML e deve, obrigatoriamente, ter o retorno e parâmetro especificados. Os widgets colocados na interface não são diretamente acessíveis pelo código Java, por isso precisamos da primeira linha existente no método, na qual chamamos o importantíssimo comando findViewById() para “conectar” a variável local txtContador, declarada dentro do método, ao respectivo widget existente na interface (localizado por seu id em R.id.txtContador). Em seguida, incrementamos o valor do inteiro contador e o colocamos convertido em String “dentro” do txtContador, nosso TextView, usando seu método setText(). Android: Desenvolvimento para Dispositivos Móveis 40 EXIBINDO INFORMAÇÕES NA TELA DE UM APLICATIVO ANDROID Tendo um widget TextView na tela do Android, você pode facilmente mudar o text dele usando seu método setText(). Apenas não se esqueça de antes fazer a “ligação” do código Java ao widget, usando findViewById(), e que o parâmetro do setText() deverá ser uma String Java. Tudo pronto! Para executar o aplicativo e testá-lo no emulador, clique no botão da barra de ferramentas do Eclipse, selecione Android Application na tela que será mostrada e clique em OK. O resultado será semelhante ao apresentado na Figura 28. Figura 28: Tela do aplicativo Contador Android: Desenvolvimento para Dispositivos Móveis 41 Exercícios do Módulo 2 1. Mostrador de Data e Hora • Crie em um aplicativo Android para mostrar a Data e a Hora do smartphone. Monte sua interface de acordo com a figura logo abaixo. • Quando o usuário clicar no botão Obter da primeira linha, exiba a data atual no formato dd/mm/aaaa no TextView logo à direita de Data:. • No toque do botão Obter da linha inferior, mostre a data e a hora atual no format hh:mm no TextView à direita de Hora:. • DICA: Você pode (e deve!) usar classes “tradicionais” do Java para isso, como Date e SimpleDateFormat. 2. Gerador de aposta da MegaSena • Faça um aplicativo Android para gerar um jogo de MegaSena, ou seja, sortear seis núme- ros aleatórios entre 1 e 60 e exibi-los ao usuário, como na figura a seguir. • REQUISITO 1: Não permita que números repetidos sejam sorteados. • REQUISITO 2: Exiba os números em ordem crescente, como na tela a seguir. Android: Desenvolvimento para Dispositivos Móveis 42 Módulo 3 – View e Activity Neste módulo entraremos mais a fundo no que é uma View e uma Activity no Android. Você verá que entender bem os conceitos por trás destas duas classes é essencial para desenvolver aplicativos mais completos. Aprenderá como usar outros widgets, além do Button e do TextView vistos no módulo anterior e saberá como funciona o processo de abertura e exibição de uma tela, por meio da sua Activity. Por fim, conhecerá a ListActivity e a ListView, que permitem a exibição rápida e prática de uma lista de itens na tela do Android. Aula 4 – Widgets Básicos e Definição de View No módulo anterior você ficou sabendo o que são widgets: os elementos que usamos para “construir” a tela de um aplicativo Android. Mas ainda não sabe que existe uma classe “pai” para todos esses objetos que colocamos na tela do Android: a View. Basicamente, poderíamos definir uma View como um espaço retangular delimitado na tela do Android. Nessa definição se encaixam os widgets e, também, os gerenciadores de layout, que funcionam como “caixas” ou “containers” de outros widgets. Todos pertencem a uma hierarquia de classes, que pode ser observada (parcialmente) na Figura 29. Figura 29: Parte da hierarquia de Views e Widgets do Android Fonte: (QUERINO FILHO, 2013, p. 63) Android: Desenvolvimento para Dispositivos Móveis 43 Por isso, lembre-se: todo elemento colocado em uma tela do Android é, portanto, uma View. Isso possibilita, por exemplo, que possamos usar o comando findViewById para conectar o código Java à qualquer tipo de objeto na tela. 4.1 Widgets: os componentes de uma tela Android Como já sabemos, existem diversos widgets que podemos usar para montar uma tela de um aplicativo Android. Nós já usamos e conhecemos dois deles: o TextView e o Button. Você pode conhecer os demais pela Palette do Eclipse (figura 30) ou consultando a documentação oficial da API do Android. Figura 30: Palheta de widgets do Android Android: Desenvolvimento para Dispositivos Móveis 44 Você já percebeu que podemos colocar os widgets diretamente em uma tela arrastando os componentes a partir da palheta? Selecionando um widget, você pode configurar suas propriedades pela janela Properties, como na Figura 31. Figura 31: Configurando widgets graficamente Android: Desenvolvimento para Dispositivos Móveis 45 Porém, desenvolvedores mais experientes, de acordo com os tutoriais e documentação disponibilizados pelo Google em Developer.android (2014), preferem configurar a interface diretamente pelo código XML. Para editar a interface usando XML, clique sobre a aba indicada na Figura 32. Figura 32: Visualizando e editando a interface via XML 4.2 Introdução ao Activity: a classe Java controladora de uma tela A classe MainActivity.java que existe em todo projeto Android criado contém o código necessário para manipular os eventos que acontecem com a tela. Dê uma olhada no código “básico” de uma Activity recém-criada no Quadro 6. Android: Desenvolvimento para Dispositivos Móveis 46 Quadro 6 – Código do arquivo MainActivity.java de um projeto recém-criado package posjava.android.contador; import android.os.Bundle; import android.support.v7.app.ActionBarActivity; import android.view.Menu; import android.view.MenuItem; public class MainActivity extends ActionBarActivity { @Override protected void onCreate(BundlesavedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.main, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { // Handle action bar item clicks here. The action bar will // automatically handle clicks on the Home/Up button, so long // as you specify a parent activity in AndroidManifest.xml. int id = item.getItemId(); if (id == R.id.action_settings) { return true; } return super.onOptionsItemSelected(item); } } Imediatamente pela declaração da classe, você pode perceber que ela herda a ActionBarActivity, uma classe existente no Android SDK que serve como base para criarmos nossas telas, contendo uma ActionBar (um widget usado para exibição de uma menu de opções). Android: Desenvolvimento para Dispositivos Móveis 47 Como desenvolvedor Java experiente, você já notou a existência de três métodos e que todos têm a anotação @Override, que indica que estes métodos estão sobrescrevendo métodos recebidos por herança da superclasse (ActionBarActivity). O mais interessante para nós, por enquanto, é o onCreate. Como o próprio nome dá a entender, ele é executado quando o evento de criação da tela acontece, ou seja, assim que a tela é criada. Dentro dele, vemos uma chamada ao método original da superclasse – ele está lá para que uma tela básica em branco seja criada. Em seguida, vem uma parte fundamental: o comando setContentView. Perceba que passamos ao setContentView o nome do nosso arquivo de layout, existente na pasta res/ layout. Sim, é ele mesmo: o arquivo XML no qual definimos nossa interface! É graças ao setContentView que, ao invés de ficarmos com a tela branca padrão, temos a exibição do layout criado! FAZENDO UMA EXPERIÊNCIA: DESATIVANDO O “setContentView” Para entender melhor o “porquê” do setContentView, faça uma experiência com um dos seus projetos: comente (coloque duas barras no início da linha) o setContentView, dentro do método onCreate da classe MainActivity, execute o projeto e veja o resultado... Sentiu falta de alguma coisa??? 4.3 Mais Widgets: EditText, ImageView e Toast Vamos conhecer agora mais alguns widgets bastante úteis, começando por um praticamente essencial: o EditText. É com ele que o usuário pode digitar informações para o aplicativo, por meio do uso do teclado virtual (ou físico em alguns poucos modelos). O widget EditText pode ser configurado para restringir os caracteres que o usuário poderá digitar nele. Por exemplo, no caso de fornecimento de valores numéricos, é possível “travar” a entrada de caracteres que não sejam números, pontuação e sinal. Há também uma variação adequada para o fornecimento de números de telefone, por exemplo, que permite apenas números, parênteses e hífen. Você pode adicionar o EditText diretamente pelo código XML ou pode simplesmente arrastar e soltar uma das suas variações existentes na palheta, dentro da categoria Text Fields (veja a Figura 33). Android: Desenvolvimento para Dispositivos Móveis 48 Figura 33: Localização dos widgets EditText na palheta do Eclipse Todos os widgets existentes na palheta são EditText; o que diferencia um do outro aqui é sua configuração Input Type, que estabelece o controle sobre quais caracteres são permitidos. Com um EditText na interface, você pode obter o valor digitado nele por seu método getText() (que deverá receber um toString() ao final para que seja convertido para uma String Java. Para colocar uma String em um EditText, usamos o seu método setText(), passando a String como seu parâmetro. Veja no Quadro 7 exemplos de como utilizá-los. Android: Desenvolvimento para Dispositivos Móveis 49 Quadro 7 – Exemplo de uso de um EditText em código Java // Faz a conexão ao editText1 na interface EditText editText1 = (EditText)findViewById(R.id.editText1); // Obtém o conteúdo do editText1 e o converte para uma String Java básica String textoNoEdit = editText1.getText().toString(); // Coloca no editText1 o conteúdo da String em letras maiúsculas editText1.setText(textoNoEdit.toUpperCase()); Outro widget que pode ser bastante útil em seus projetos é o ImageView. Com ele, podemos exibir imagens e fotos em uma tela do Android. Para utilizá-lo, basta copiar uma imagem para uma das pastas res\drawable* (por exemplo drawable- hdpi, usada para imagens em alta resolução) do seu projeto. Você pode fazer isso simplesmente arrastando um arquivo até a pasta. Apenas lembre-se de, ao soltar o arquivo, selecionar a opção Copy files para que o arquivo original seja mantido. Após colocada a imagem, arraste um widget ImageView (ele está dentro da categoria Images & Media) até alguma parte da sua tela. Ao soltar, selecione e a figura recentemente adicionada e veja logo em seguida sua imagem dentro do seu app (veja a Figura 34)! Figura 34: Adicionando imagens a uma tela com ImageView Android: Desenvolvimento para Dispositivos Móveis 50 Mais um widget útil: o Toast. Ele não é encontrado na palheta de objetos – seu uso é realizado diretamente pelo código Java. Com o Toast, você consegue exibir mensagens curtas que desaparecem automaticamente após um período. Para utilizá-lo, use um código semelhante ao do Quadro 8. Quadro 8 – Exemplo de uso de Toast Toast.makeText(this, “Esta é uma mensagem rápida!”, Toast.LENGTH_SHORT).show(); O método makeText() recebe três parâmetros: • Um indicador do contexto atual, que geralmente é a própria Activity na qual o comando é executado – por essa razão, passamos this neste parâmetro; • Uma String de texto com a mensagem a ser exibida; • Uma constante que determina a duração da exibição da mensagem, que pode ser Toast.LENG- TH_LONG (para maior duração) ou Toast.LENGTH_SHORT (para menor duração). NUNCA SE ESQUEÇA de chamar o método show() após makeText(), como no Quadro 8!!! O método makeText cria a mensagem, mas não a exibe; quem faz isso é o método show(). Aula 5 – Aprofundando o conhecimento sobre a classe Activity A Activity, classe que funciona como uma controladora de uma tela do aplicativo Android, é bastante robusta e flexível. Existem vários eventos e estados de uma Activity, e o programador pode criar comportamentos específicos para cada uma delas. Nesta aula, conheceremos também uma Activity especial, a ListActivity, que possui embutida uma lista que pode ser usada para listagem de diversos tipos de informação. 5.1 O ciclo de vida de uma Activity: onCreate, onDestroy e etc. Já sabemos que, quando uma tela é criada, o seu método onCreate é invocado. Dentro dele, podemos colocar código de inicialização de valores e também definição dos elementos da interface, com base em um arquivo XML. Porém, existem outros eventos em uma Activity que podem ser programados. Suponha, por exemplo, que no momento em que a Activity for fechada, você precisaria salvar dados ou gravar o estado atual do aplicativo para que possa ser restaurado depois...Pois bem, existe um evento que você pode sobrescrever para especificar o que fazer nesta situação! Android: Desenvolvimento para Dispositivos Móveis 51 Para compreender melhor o ciclo de vida de uma Activity, dê uma olhada no gráfico da Figura 35. Figura 35: Ciclo de vida de uma Activity Fonte: <http://developer.android.com/images/training/basics/basic-lifecycle.png>. Acesso em: 14 out. 2014. • Quando a Activity é criada, o evento onCreate() é disparado. • Em seguida, ocorre o evento onStart(), logo antes da Activity finalmente ser exibida ao usuário. • Quando a Activity atual fica parcialmente em segundoplano, em função de uma caixa de diálogo ou outra tela semitransparente ter sido aberta, ou seja, uma situação que não oculta totalmente a tela, esta entra no estado de onPause(). • No momento em que ocorre a desobstrução, a Activity continua após o evento onResume(). • No caso de uma nova tela ser aberta e ocultar totalmente a tela atual, dizemos que esta Activity entrou no estado de parada e executou o evento onStop(). • Neste caso, quando o usuário retorna à Activity que ficou “de baixo”, ela executa o evento onRes- tart() e posteriormente o onStart(). • Finalmente, logo antes da Activity ser totalmente fechada, ocorre o evento onDestroy(). 5.2 Eventos de clique em botões Os cliques (ou melhor dizendo, toques) nos botões são as principais formas de programar ações em um aplicativo Android. Dizemos que ele é um evento e que ele será manipulado por um método dentro de uma classe Java (no caso, a Activity). Definimos o nome do método que será disparado no toque de um botão por meio da sua propriedade onClick, dentro de um arquivo XML. Também pode ser designado por meio da interface gráfica, usando a janela de propriedades. No caso do XML, a configuração da propriedade é feita como exibido no Quadro 9. Android: Desenvolvimento para Dispositivos Móveis 52 Quadro 9 – Exemplo de uso de configuração do evento onClick botão <Button android:id=”@+id/button1” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_centerHorizontal=”true” android:layout_marginTop=”42dp” android:text=”Incluir” android:onClick=”onClickIncluir”/> Depois de configurado o nome do método na propriedade, o método para o evento deve ter exatamente o mesmo nome que foi especificado. Também é obrigatório que o método seja public com retorno vazio e que receba um objeto View como parâmetro, como mostra o exemplo no quadro 10. Quadro 10 – Exemplo de método para evento onClick de um botão public void onClickIncluir(View v) { // Lógica para execução no clique do botão, como por exemplo // procedimentos para inclusão de um cliente no banco de dados } 5.3 ListActivity = Activity + ListView Se você já deu uma boa olhada na palheta de widgets, pode ter visto um componente chamado ListView. Ele é bastante útil para uma série aplicativos, pois torna muito fácil a exibição de dados em listas. Ele está dentro da categoria Composite da palheta (veja a Figura 36). Android: Desenvolvimento para Dispositivos Móveis 53 Figura 36: Localização do widget ListView na palheta do Eclipse Você pode adicionar este ListView a uma tela de layout, conectá-lo ao código Java com findViewById() e depois programar o widget para exibir os dados. Mas há um jeito ainda mais prático e com mais opções: usar a ListActivity. Trata-se de uma Activity especial, que já “sabe” como lidar com um ListView. Na verdade, ela traz um ListView nela embutido e poderia até mesmo ser usada sem um arquivo de layout, mas vamos usá-la junto do activity_main.xml para que possamos customizá-lo. Vamos supor que você está querendo criar uma lista de compras. O primeiro passo é criar um layout com um ListView para exibição da lista, assim como um EditText para o usuário escrever um nome de um item e um botão com a ação de incluí-lo. Um exemplo de layout dessa maneira pode ser visto no Quadro 11. Android: Desenvolvimento para Dispositivos Móveis 54 Quadro 11 – Exemplo de arquivo de layout com ListView, EditText e Button. <RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android” xmlns:tools=”http://schemas.android.com/tools” android:layout_width=”match_parent” android:layout_height=”match_parent” android:paddingBottom=”@dimen/activity_vertical_margin” android:paddingLeft=”@dimen/activity_horizontal_margin” android:paddingRight=”@dimen/activity_horizontal_margin” android:paddingTop=”@dimen/activity_vertical_margin” tools:context=”.MainActivity” > <EditText android:id=”@+id/edtProduto” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_alignParentLeft=”true” android:layout_alignParentTop=”true” android:layout_toLeftOf=”@+id/button1” android:ems=”10” /> <Button android:id=”@+id/button1” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_alignParentRight=”true” android:layout_alignTop=”@+id/edtProduto” android:onClick=”onClickAdicionar” android:text=”Adicionar” /> <ListView android:id=”@android:id/list” android:layout_width=”match_parent” android:layout_height=”wrap_content” android:layout_alignLeft=”@+id/edtProduto” android:layout_below=”@+id/button1” android:layout_marginTop=”25dp” > </ListView> </RelativeLayout> Android: Desenvolvimento para Dispositivos Móveis 55 Os pontos principais neste layout são os seguintes: • Colocamos no EditText, em que será digitado o item id edtProduto, para identificá-lo corretamente no código Java; • No Button que vai realizar a inclusão do item digitado, configuramos seu evento onClick para dis- parar o método onClickAdicionar – este será o nome que deveremos usar na classe Java. • No ListView, uma configuração fundamental para que ele possa ser usado na ListActivity: seu id tem que ser, obrigatoriamente, @android:id/list. Na classe Java, teremos código para: • Inicializar a lista com alguns valores (faremos isso no evento onCreate); • Incluir um item na lista quando o usuário tocar no botão (isso será feito na programação do método onClickAdicionar); • Excluir um item da lista quando o mesmo for tocado (conseguiremos fazer isso com o uso de um evento especial da ListActivity, chamado onListItemClick). Para conseguir cumprir esses procedimentos, altere o código da MainActivity.java do seu projeto para o exibido no Quadro 12. Quadro 12 – Código para MainActivity.java com suporte a ListView package posjava.android.listadecompras; import java.util.ArrayList; import android.app.ListActivity; import android.os.Bundle; import android.view.View; import android.widget.ArrayAdapter; import android.widget.EditText; import android.widget.ListView; public class MainActivity extends ListActivity { EditText edtProduto; ArrayList<String> lista; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Android: Desenvolvimento para Dispositivos Móveis 56 String[] produtos = new String[]{“Arroz”, “Feijão”, “Batata”}; lista = new ArrayList<String>(); for (int i = 0; i < produtos.length; ++i) { lista.add(produtos[i]); } ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, lista); setListAdapter(adaptador); edtProduto = (EditText)findViewById(R.id.edtProduto); } public void onClickAdicionar(View v) { String produto = edtProduto.getText().toString(); lista.add(produto); ArrayAdapter<String> adaptador = (ArrayAdapter<String>)getListAdapter(); adaptador.notifyDataSetChanged(); edtProduto.setText(“”); } @Override protected void onListItemClick(ListView l, View v, int position, long id) { Toast.makeText(this, “Você selecionou: “ + lista.get(position), Toast.LENGTH_SHORT).show(); } } • O primeiro passo a ser feito é mudar a superclasse de MainActivity de ActionBarAc- tivity para ListActivity. Basta trocar o nome da superclasseapós extends e adicionar o import adequado; • Toda lista precisa ter uma fonte para seus dados, ou seja, os elementos que serão colocados na lista; por isso, declaramos na nossa classe um ArrayList de Strings denominado lista. Como usare- mos o EditText edtProduto em mais de um método, também o colocamos como um campo global da classe; • No onCreate, fazemos a inicialização da lista. Criamos um vetor comum de Strings (produtos) e depois adicionamos os seus elementos ao ArrayList lista. Para conectar os elementos do ArrayList à lista do ListView, usamos um objeto do Android denominado ArrayAdapter. Criamos um cha- mado adaptador, e ao seu construtor passamos três parâmetros: uma referência ao contexto atual (this, ou seja, a própria Activity em que estamos criando o adaptador); o nome de um layout para a lista – neste caso, usamos um layout padrão do Android que contém apenas uma linha de texto por item da lista – simple_list_item_1; e, finalmente, o adaptador. Android: Desenvolvimento para Dispositivos Móveis 57 • Na penúltima linha do onCreate, o método setListAdapter configura o adaptador para a lista existente. Com isso, os itens já adicionados ao ArrayList já aparecerão no ListView; • Por fim, no onCreate, criamos a ligação entre o edtProduto local na classe e ao existente na inter- face R.id.edtProduto. • O método onClickAdicionar será executado quando o usuário tocar no botão criado na interface. Inicialmente, usamos a referência a edtProduto para obter o texto nele contido e armazenar na String produto. Obtemos, então, uma referência ao adaptador para chamar seu método notifyDa- taSetChanged(), que fará a atualização dos dados exibidos no ListView, já que mudamos a fonte dados do ListView (o ArrayList lista) acrescentando mais um produto. • O método onListItemClick é um evento que ocorre quando um item da lista é tocado. Bastante útil, ele recebe quatro parâmetros. Um deles é particularmente útil para nós: o int position, que traz o índice da linha tocada dentro da lista (0 para o primeiro até n-1 para o último, sendo n a quantidade de itens na lista). Como nossa lista está exibindo diretamente o conteúdo de um ArrayList, o position é exatamente o índice do elemento no ArrayList. Assim, exibimos uma mensagem rápida com Toast, mostrando o nome do item tocado, que é obtido diretamente do ArrayList. A VERSATILIDADE DO onListItemClick Esse método pode ser usado para várias outras operações com a lista: • Excluir um item tocado; • Abrir uma próxima tela com mais informações do elemento tocado (ve- remos como abrir uma nova tela no próximo módulo); • Iniciar a alteração do item, em uma caixa de diálogo ou tela em que os dados podem ser alterados. Exercícios do Módulo 3 1. Conversor Celsius/Fahrenheit • Faça um aplicativo Android que realize a conversão de graus Celsius para Fahrenheit e vice-versa. • Se o usuário fornecer o valor no campo Celsius, faça a conversão para Fahrenheit e a exiba no campo logo à direita; • Se o usuário não fornecer o valor para Celsius, mas se fornecer para Fahrenheit, converta o valor para Celsius e o exiba no campo esquerdo; • Por fim, se nenhum valor for informado, exiba uma mensagem rápida indicando que o usuário deve fornecer pelo menos um dos valores. Android: Desenvolvimento para Dispositivos Móveis 58 • Para seguir o modelo de divisão em camadas, implemente os métodos de conversão em uma classe própria. Por exemplo, você pode criar a classe Conversor e criar os métodos obterFahrenheitDoCelsius() e obterCelsiusDoFahrenheit(). • Fórmulas para conversão de temperaturas: ◊ Celsius = ((Fahrenheit - 32) * 5) / 9) ◊ Fahrenheit = ((Celsius * 9) / 5) + 32 2. Lista de Tarefas • Crie um aplicativo para o usuário adicionar, exibir e excluir uma lista de tarefas. • Use ListActivity para facilitar o processo de implementação. • Mantenha sempre a lista de tarefas em ordem alfabética. Ao adicionar uma nova tarefa à lista, lembre-se de fazer a reordenação dos elementos e atualização dos dados na tela. • Quando o usuário tocar em uma tarefa, faça sua exclusão da lista e exiba na tela a men- sagem “TAREFA FINALIZADA: ” seguida do texto descritivo da tarefa. Android: Desenvolvimento para Dispositivos Móveis 59 Módulo 4 – Layouts e Intents Construir uma boa interface de um aplicativo Android é muito mais do que simplesmente escrever o có- digo XML corretamente ou arrastar, soltar e configurar as propriedades dos widgets. O uso dos “containers” de widgets (os gerenciadores de layout) possibilitam que os elementos permaneçam organizados adequada- mente na tela, até mesmo no caso de aparelhos com diferentes tamanhos de tela. Neste módulo, conhecere- mos um pouco mais sobre os gerenciadores de layout. A classe Intent, utilizada para realizar operações que envolvam atenção do sistema operacional como, por exemplo, abrir novas janelas, também será abordada neste módulo. Aula 6 – Organizando a tela com gerenciadores de layout Há várias opções de gerenciadores de layout no Android SDK. Muitas delas podem ser simplesmente ar- rastadas para a tela por meio da palheta de widgets, como pode ser observado na Figura 37. Figura 37: Gerenciadores de layout disponíveis na palheta de widgets Android: Desenvolvimento para Dispositivos Móveis 60 Como você pode ver, há várias opções de layout. Porém, a grande maioria dos aplicativos é construída com um destes dois: RelativeLayout e Linear- Layout, que são, inclusive, os mais utilizados nos documentos de referência que a Google disponibiliza no developer.android.com. Veremos agora um pouco mais sobre cada um deles, assim como as vantagens e desvantagens em utilizá- -los. 6.1 RelativeLayout O layout relativo (RelativeLayout) é o padrão para construção de novas telas no Android. Ele faz com que os widgets sejam posicionados em relação a um outro, ou em relação aos cantos e centro da tela. Assim, os widgets podem se adaptar adequadamente a mudanças na tela. Veja na figura 38 um exemplo de uso do layout relativo. Você vê as linhas verdes na Figura 38? Elas mostram o posicionamento relativo do widget selecionado. Por exemplo, o TextView contendo o texto Celsius está posicionado em relação aos lados superior e esquerdo da tela, assim como um pouco acima em relação ao TextView contendo o texto Fahrenheit. Agora veja na figura 39 o posicionamento do EditText à direita de Fahrenheit. Podemos ver que o EditText está posicionado em relação aos dois TextView, ao botão e à margem direita da tela. Figura 38: Exemplo de uso do RelativeLayout Figura 39: Exemplo de uso do RelativeLayout Esse excesso de “relações” pode ser problemático: se movermos ou reposicionarmos apenas um wid- get, pode ocorrer uma “reação em cadeia” que modificará profundamente a interface. Em alguns casos, o reposicionamento automático para diferentes tamanhos de tela pode, da mesma forma, não surtir o efeito desejado. Android: Desenvolvimento para Dispositivos Móveis 61 Para ter uma garantia maior da posição final dos widgets, diminuindo a liberdade no seu posicionamento, podemos utilizar o Linear Layout. 6.2 Linear Layout Com o layout linear, podemos ter mais certeza com relação ao posicionamento final dos widgets em dife- rentes tamanhos de tela, assim como não correremos mais o risco de um reposicionamento de um widget alterar completamente a interface. Há duas variações do Layout Linear: o vertical e o horizontal. Quando usamos o vertical, os widgets são colocados um abaixo do outro; quando usamos o horizontal, são colocados ao lado, em um única linha. Veja a diferença entre eles na Figura 40. Figura 40: Comparação entre Layout Linear Vertical (esquerda) e Horizontal (direita) Aparentemente, o uso do LinearLayout parece ser bem limitado; afinal, no vertical, (esquerda na Figura 40) você pode apenas colocar umwidget abaixo do outro, e no horizontal (direita na Figura 40), todos ficam na mesma linha, um ao lado do outro. Porém, você pode mesclar o uso do layout linear horizontal com o vertical e criar telas em um estilo tabela. Dê uma olhada no exemplo da Figura 41. Android: Desenvolvimento para Dispositivos Móveis 62 Figura 41: Uso do LayoutLinear horizontal combinado com o vertical Na Figura 41, veja no Outline (no canto superior direito) que colocamos um Layout Linear Vertical com dois Layout Linear Horizontal empilhados, seguidos de um botão. Dentro dos dois layouts horizontais, coloca- mos, em linha, os TextViews e campos de entrada de texto necessários. A listagem deste exemplo de layout pode ser vista no Quadro 13. Android: Desenvolvimento para Dispositivos Móveis 63 Quadro 13 – Código para arquivo XML de layout com Linear Layout <?xml version=”1.0” encoding=”utf-8”?> <LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android” android:layout_width=”match_parent” android:layout_height=”match_parent” android:orientation=”vertical” > <LinearLayout android:layout_width=”match_parent” android:layout_height=”wrap_content” > <TextView android:id=”@+id/textView1” android:layout_width=”0dp” android:layout_height=”wrap_content” android:layout_weight=”1” android:gravity=”right” android:text=”@string/celsius” android:textAppearance=”?android:attr/textAppearanceLarge” /> <EditText android:id=”@+id/editText1” android:layout_width=”0dp” android:layout_height=”wrap_content” android:layout_weight=”1” android:ems=”10” android:inputType=”numberDecimal” > <requestFocus /> </EditText> </LinearLayout> <LinearLayout android:layout_width=”match_parent” android:layout_height=”wrap_content” > Android: Desenvolvimento para Dispositivos Móveis 64 <TextView android:id=”@+id/textView2” android:layout_width=”0dp” android:layout_height=”wrap_content” android:layout_weight=”1” android:gravity=”right” android:text=”@string/fahr” android:textAppearance=”?android:attr/textAppearanceLarge” /> <EditText android:id=”@+id/editText2” android:layout_width=”0dp” android:layout_height=”wrap_content” android:layout_weight=”1” android:ems=”10” android:inputType=”numberDecimal” /> </LinearLayout> <Button android:id=”@+id/button1” android:layout_width=”match_parent” android:layout_height=”wrap_content” android:text=”@string/conv” /> </LinearLayout> 6.3 Menus e Caixas de Diálogo Figura 42: AcionBar (em destaque) em um aplicativo Android Android: Desenvolvimento para Dispositivos Móveis 65 Para aplicativos novos, a Google recomenda o uso da ActionBar como menu dos aplicativos. A ActionBar é a barra existente no topo de um aplicativo Android (veja Figura 42). Por essa razão, para todo novo projeto de aplicativo criado no Eclipse, a tela inicial é uma ActionBarAc- tivity, contendo a barra e o botão existente no seu lado direito, que aciona o menu de opções do aplicativo. Os itens de menu da ActionBar são ações que devem ser definidas com a tag item, em um arquivo XML existente dentro da pasta res/menu. Todo novo projeto já vem com um arquivo XML contendo um item de menu para abrir as preferências do aplicativo (caso existam). Veja seu conteúdo no Quadro 14. Quadro 14 – Código para arquivo XML do arquivo de menu res/layout/main.xml <menu xmlns:android=”http://schemas.android.com/apk/res/android” xmlns:app=”http://schemas.android.com/apk/res-auto” xmlns:tools=”http://schemas.android.com/tools” tools:context=”posjava.android.megasena.MainActivity” > <item android:id=”@+id/action_settings” android:orderInCategory=”100” android:title=”@string/action_settings” app:showAsAction=”never”/> </menu> Em seguida, o que acontecerá quando um item for tocado deverá ser programado no evento onOption- sItemSelected, dentro da Activity (veja o Quadro 15). Quadro 15 – Código para o evento que trata o clique em cada um dos itens de menu na ActionBarActivity @Override public boolean onOptionsItemSelected(MenuItem item) { int id = item.getItemId(); if (id == R.id.action_settings) { Toast.makeText(this, “Você tocou no item das configurações!”, Tast.LENGTH_LONG). show(); // AQUI NESTE PONTO PODERÍAMOS ACRESCENTAR O CÓDIGO NECESSÁRIO PARA // ABERTURA DA TELA DE CONFIGURAÇÕES DO APLICATIVO return true; } return super.onOptionsItemSelected(item); } Android: Desenvolvimento para Dispositivos Móveis 66 Para cada item criado no arquivo XML, é possível testar, dentro do onOptionsItemSelected, se ele foi pressionado e executar o procedimento adequado. No exemplo do Quadro 15, apenas mostramos uma men- sagem ao usuário. Veremos na próxima aula como abrir novas janelas – esse poderia ser o resultado final do clique do item de menu Settings. No caso de novos itens, você pode adicionar outros else if ao código ou simplesmente trocar o uso de if por switch...case. Uma caixa de diálogo pode ser criada facilmente no Android, por meio do uso da classe DialogFrag- ment. Podem ser criados diálogos simples, com botões que o usuário pode utilizar para responder uma questão, por exemplo, ou diálogos mais sofisticados, com widgets como caixas de entrada de texto. Para criar um diálogo com DialogFragment, precisamos criar uma subclasse desta. Isso pode ser feito dentro da própria classe da Activity – afinal, Java permite criar classes dentro de classes! Veja um exemplo no Quadro 16, que pode ser colocado dentro de uma Activity. Quadro 16 – Código para classe de criação de um diálogo, interna em uma Activity public class FecharDialogFragment extends DialogFragment { @Override public Dialog onCreateDialog(Bundle savedInstanceState) { AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); builder.setMessage(“Deseja fechar esta tela?”) .setPositiveButton (“OK”, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // USUÁRIO CLICOU EM OK finish(); } }) .setNegativeButton (“Cancelar”, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // USUÁRIO CLICOU EM CANCELAR } }); return builder.create(); } } Android: Desenvolvimento para Dispositivos Móveis 67 Agora, você pode chamar o diálogo no ponto em que desejar da sua Activity (como em um clique de bo- tão) instanciando a classe criada e chamando o método show() no objeto criado, como pode ser visto no Quadro 17. Quadro 17 – Código para exibir a caixa de diálogo criada no Quadro 14 public void onClick(View o) { new FecharDialogFragment().show(getSupportFragmentManager(), “fechar”); } 7.1 Definição da classe Intent A classe Intent é usada quando desejamos realizar alguma ação que envolve outros componentes do aplicativo ou do sistema. Basicamente, é uma mensagem de solicitação, que será enviada a alguém solici- tando, por exemplo, a abertura de uma janela, uma chamada telefônica ou a abertura do navegador em um determinado endereço. Provavelmente o uso mais comum de um Intent é a abertura de uma nova tela.
Compartilhar