Apostila Android

Profº. Luiz Carlos Querino Filho

É vedada, terminantemente, a cópia do material didático sob qualquer forma, o seu fornecimento para fotocópia ou gravação, para alunos ou terceiros, bem como o seu fornecimento para divulgação em locais públicos, telessalas ou qualquer outra forma de divulgação pública, sob pena de responsabilização civil e criminal.

SUMÁRIO APRESENTAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Módulo 1 – Introdução ao Android e XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Aula 1 – Fu Fundamentos do do Si Sistema Op Operacional An Android . . . . . . . . . . . . . . . . . . . . . . . 6 1.1. Car araact cter erííst stic icaas do Sist stem emaa Op Oper eraaci cion onaal An Andr droi oid d . . . . . . . . . . . . . . . . . . . . . . . .6

1.2. Os Dispositivos Móveis Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Aula 2 – Introdução ao XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.1 2. 1. Con Conce ceit itos os bá bási sico coss de de XML XML (eX eXte tens nsib ible le Ma Mark rkup up La Lang ngua uage ge). ). . . . . . . . . . . . . . .1 .11 1 2.2. Manipulação de documentos XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 12 2.3. APIs: DOM, SA X e TrAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Módulo 2 – Am Ambbiente de Desenvolvimento Android . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Aula 3 – Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 3.1. Baixando e instalando o Android Studio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1 .16 6 3.2. Primeiro contato com o Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 3.3. Se Seu pr primeiro ap aplicativo An Android. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .24 3.4. Criando um dispositivo virt rtu ual An And droid (AVD) . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.5. Es Escreven end do o código do do seu seu primei eirro ap aplicativo. . . . . . . . . . . . . . . . . . . . . . . 33

Módulo 3 – View e Activity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 Aula 4 – Widgets B Báásicos e Definição de View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 4.1. Widgets: os componentes de uma tela Android. . . . . . . . . . . . . . . . . . . . . . . . 39 4.2.. Intr 4.2 Introdu odução ção ao Acti Activity vity:: a clas classe se Jav Javaa contr controla olador doraa de uma uma tela tela . . . . . . . . . .4 .41 1 4.3. Mais Widgets: E Ed ditTex t, ImageView e Toast . . . . . . . . . . . . . . . . . . . . . . . . . . . .42

Aul ulaa 5 – Apr Aprof ofun unda dand ndoo o con conhe heci cime ment ntoo sob sobre re a cla class ssee Act Activ ivit ityy . . . . . . . . . . . . . . . . 45 5.1 5. 1. O cic ciclo lo de vi vida da de um umaa Act Activ ivit ity: y: on onCr Crea eatte, onD onDes estr tro oy etc.. etc.. . . . . . . . . . . . . . . 45 5.2. Eventos de clique em e m botões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 5.3. List Activity = Activity + ListView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47

Módulo 4 – Layouts e Intents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 Aul ulaa 6 – Or Orggan aniiza zand ndoo a tel elaa co com m ge gerren enci ciaado dorres de la layyout. . . . . . . . . . . . . . . . . . . . . 54 6.1. RelativeLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 6.2. LinearLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.3. Menus e Caixas de Diálogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Aula 7 – Intents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 7.1. Definição da classe Intent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 7.2. Cr Criando e ab abrindo um uma nova tela co com Intent . . . . . . . . . . . . . . . . . . . . . . . . . . 64 7.3. Passando valores para uma nova tela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

Módulo 5 – Banco de Dados em Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Aula 8 – Banco de Dados em Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 8.1. Banco de Dados SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 8.2. Criação do banco de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 8.3. Criação da classe DAO para acesso aos dados . . . . . . . . . . . . . . . . . . . . . . . 70 8.4. Incluindo, excluindo e exibindo registros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Módulo 6 – Visão Geral de Recursos do SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 Aula 9 – GPS, WebServices, Câmera e Áudio/Vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . 76 9.1. Acessando longitude, latitude e altitude por meio do GPS do aparelho . . . .76 9.2. Consumindo Web Services RESTful . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 9.3. Utilizando a câmera para fotos e vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 9.4. Reproduzindo arquivos de áudio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91

Considerações Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 Glossário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 Referências bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

APRESENTAÇÃO Bem-vindo(a) à nossa disciplina, caro(a) 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 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, que abrange 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 a 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!

Pág. 5 de 95

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

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 usados nos projetos de aplicativos Android.

AULA 1 – FUNDAMENTOS DO SISTEMA OPERACIONAL ANDROID 1.1. Características do Sistema Operacional Android De acordo com Querino (2013), 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).

Pág. 6 de 95

FIGURA 1 – Logo da Plataforma Android

Fonte:

FIGURA 2 – Tela do Android 6.0.1 Marshmallow

Fonte: < https://pt.wikipedia.org/wiki/Android_Marshmallow#/media/File:Android_6.0-en.png >

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), então líder até sua chegada, e hoje está presente em centenas de aparelhos dos mais diversos fabricantes. No momento da finalização deste material, a versão oficial mais recente do Android era a 6.0.1, denominada Marshmallow (figura 2). É 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” Pág. 7 de 95

foi a 1.5, chamada Cupcake. Em seguida, vieram Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice Crem Sandwich, Jelly Bean, KitKat, Lollipop e, finalmente, Marshmallow. A próxima versão já tem codinome anunciado: Nougat, conhecido no Brasil popularmente como “torrone”. 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:

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 de o 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 6.0.1). Isso ocasiona variações significativas entre elas. • 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.

Pág. 8 de 95

• Variações na configuração (hardware) de cada aparelho: como já citado, cada modelo tem uma configuração específica. Por exemplo, o tamanho de uma tela pode variar de 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, pois 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 – – 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 2016

Fonte:

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 80% dos usuários já estejam usando as versões mais recentes (da 4.4 em diante), uma fatia importante (cerca de 20%) ainda usa versões mais antigas. Esse percentual tende a ser ainda maior em países com população de baixa renda, em que celulares mais simples são mais vendidos. O que isso significa para nós, desenvolvedores?

Pág. 9 de 95

Significa que, ao criarmos um app para Android, devemos nos assegurar 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). 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á c orrer o risco de o 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 2016

Fonte:

Pág. 10 de 95

CURIOSIDADE E QUANTO AO JAVA ME (ANTIGO J2ME)? Bem antes de o 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 de este ú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 estes dados pudessem ser entendidos por qualquer uma das partes envolvidas. Outra característica importante do XML é 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 soft ware 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

Pág. 11 de 95

tanto por 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 destes 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!

Segundo 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 de já 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.

FIGURA 6 – World Wide Web Consortium

Fonte:

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.

Pág. 12 de 95

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, 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 Modicado

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 este número? O preço de venda do produto? Ou sua quantidade de estoque? 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

Agora sim sabemos que se trata de um estoque! E que cada item é um produto, com uma descrição e uma quantidade.

Pág. 13 de 95

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 7.

FIGURA 7 – Arquivo XML aberto no browser Firefox

Fonte: Autoria própria

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 é 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 8, um gráfico mostrando a hierarquia de uma tabela HTML dentro do DOM.

Pág. 14 de 95

FIGURA 8 – Representação DOM de uma tabela

Fonte:

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. 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 e 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 deste tipo.

Pág. 15 de 95

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 Studio. Trata-se do software usado para criarmos aplicativos Android, no qual está incluído o Android SDK, um 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 Studio, 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 – ANDROID STUDIO 3.1. Baixando e instalando o Android Studio Antes de qualquer coisa, certifique-se de que você já tem o JDK versão 8 instalado na sua máquina. Caso ainda não tenha, 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 Studio, uma IDE ( Integrated Development Environment , ou Ambiente de Desenvolvimento Integrado, em português) que contém as bibliotecas básicas para desenvolver em Java para Android. Acesse http://developer.android.com e procure pelo link indicado na figura 9.

Pág. 16 de 95

FIGURA 9 – Link para download do Android Studio

Fonte:

Na tela seguinte, a versão adequada do Android Studio para seu sistema operacional poderá ser baixada, bastando clicar no botão indicado na figura 10.

Pág. 17 de 95

FIGURA 10 – Botão para download do Android Studio na versão do seu sistema operacional

Fonte:

Em seguida, você deverá concordar com os termos do download do Android S tudio marcando a caixa indicada pela seta e clicar no botão logo abaixo (figura 11) para iniciar o download do pacote de instalação.

FIGURA 11 – Concordando com os termos e iniciando o download

Fonte:

Pág. 18 de 95

Finalmente começará o download. No caso de instalação em sistema operacional Windows, você possuirá, no término da transferência, um arquivo que, ao ser executado, iniciará o processo de instalação. Para sistemas operacionais Mac OS X e Linux, consulte as instruções exibidas no navegador após o download.

No caso de instalação no Windows, após executar o programa baixado, será exibida a tela mostrada na figura 12. Clique sobre o botão Next para começar o processo de instalação.

FIGURA 12 – Iniciando a instalação do Android Studio no Windows

Fonte:

O procedimento de instalação é simples e segue o padrão da maioria dos instaladores de softwares para Windows: basta você manter selecionadas as opções default apresentadas e seguir clicando em Next até que o processo esteja concluído. No final da instalação, será exibida uma tela semelhante àquela mostrada na figura 13.

Pág. 19 de 95

FIGURA 13 – Finalizando o processo de instalação do Android Studio

Fonte:

Ao clicar em Finish, como indicado na figura 13, o instalador será encerrado e o Android Studio passará a ser inicializado pela primeira vez. AVISO! Para executar o Android Studio de modo satisfatório, é recomendado que o computador possua pelo menos 4 GB de RAM.

3.2. Primeiro contato com o Android Studio Ao abrir o Android Studio pela primeira vez, talvez você seja questionado se deseja importar as configurações usadas em uma versão anterior da ferramenta. Escolha a opção de sua preferência (ou simplesmente deixe marcada a opção padrão) e clique no botão OK (figura 14).

Pág. 20 de 95

FIGURA 14 – Opções da primeira inicialização do Android Studio

Fonte: Android Studio

Em seguida, o Android Studio realizará o download de componentes adicionais e fará a criação de um AVD (Android Virtual Device) automaticamente para você. Esse “dispositivo virtual Android” será usado para testar seu app no emulador incluído no Android Studio. Para que tudo seja feito automaticamente, clique no botão Next na tela exibida na figura 15. FIGURA 15 – Fazendo as congurações nais do Android Studio


Na tela seguinte (figura 16), mantenha a opção Standard selecionada e clique em Next.

Pág. 21 de 95

FIGURA 16 – Selecionando a opção padrão para nalizar a conguração


Será então exibida uma tela mostrando os componentes adicionais que serão baixados e onde eles serão armazenados no seu computador (figura 17). FIGURA 17 – Finalizando o assistente e congurações nais do Android Studio


Clique em Finish para iniciar o download. Assim que ele for concluído, o Android Studio fará a autoconfiguração do AVD.

Caso seu computador suporte a virtualização VT-x, tudo deverá acontecer sem problema. Porém, caso não tenha, talvez seja mostrada, ao final da instalação, uma mensagem semelhante à apresentada na figura 18: Pág. 22 de 95

FIGURA 18 – Tela nal da conguração exibindo mensagem de erro


IMPORTANTE Com o intuito de acelerar a execução do emulador, o Android Studio inicialmente tenta criar um AVD com uma versão do Android para processadores x86, que poderá ser executada com excelente desempenho em computadores que suportam a tecnologia de virtualização VT-x com uso do software Intel HAXM.

Caso seu computador apresente a mensagem em vermelho na figura 18 (ou algo semelhante), será necessário, antes de executar os programas no emulador, criar manualmente um AVD usando uma versão do Android para processadores ARM. Veja como isso é feito na próxima seção deste material. De qualquer forma, tendo sido mostrada a mensagem de erro ou não, logo após o fechamento da janela mostrada na figura 18 será exibida a tela de boas-vindas do Android Studio (figura 19):

Pág. 23 de 95

FIGURA 19 – Tela de boas-vindas do Android Studio


Clique no botão indicado pela seta na figura 19 para criar um novo projeto de aplicativo Android.

3.3. Seu primeiro aplicativo Android Após clicar no botão indicado na figura 19, será iniciado o assistente de criação de um novo projeto. Na primeira tela (figura 20), você deverá informar um nome para o seu projeto (que será também o nome do seu app quando ele estiver instalado no aparelho). Para este exemplo, use o nome “Contador”.

FIGURA 20 – Primeira tela na criação de um novo projeto


Pág. 24 de 95

Em Company Domain você pode colocar um nome de domínio Internet, que será usado, em formato reverso, nos pacotes das suas classes Java; se não tiver direito de uso de um domínio, pode usar uma valor fictício, como o indicado (example.com). O seu projeto ficará salvo na pasta indicada em Project Location; você pode alterá-la, se quiser. Após definir as configurações desejadas, clique em Next. Na próxima tela (figura 21) indicamos a plataforma alvo do aplicativo Android que criaremos. É possível criar apps para Android destinados a outras plataformas de aparelhos, como TVs, relógios ( Wear) e até mesmo o famoso Google Glass, mas no nosso caso o alvo serão os principais dispositivos para esse sistema operacional: Phone and Tablet. FIGURA 21 – Denindo a plataforma e versão mínima do Android


Em Minimum SDK é possível estabelecer a versão mínima do Android necessária para que o aplicativo funcione. O padrão mostrado na tela da figura 21 ( API 15: Android 4.0.3) 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. A versão sugerida é uma boa escolha, pois proporciona um balanço entre disponibilidade de recursos novos e abrangência de uso (veja na figura 21 que a versão selecionada é a utilizada em cerca de 97,4% dos aparelhos ativos). Clique em Next para passar à próxima tela.

Pág. 25 de 95

FIGURA 22 – Escolhendo um modelo para a tela principal do aplicativo


Neste momento (figura 22) podemos escolher um modelo inicial para a tela principal do aplicativo. Nos nossos projetos escolheremos sempre a versão mais simples de tela: a Empty Activity, como indicado na figura 22, que traz uma tela em branco sem conteúdo específico. Selecione esse tipo e clique em Next. A última tela do assistente de criação do projeto permite a definição do nome do arquivo de layout e a classe Java para a tela inicial (figura 23). Em breve, conheceremos melhor o papel destes arquivos. Deixe os valores default e clique em Finish para finalizar a criação c riação do projeto.

FIGURA 23 – Escolhendo um modelo para a tela principal do aplicativo


Após alguns segundos, seu projeto estará criado e pronto para ser modificado. A tela do Android Studio com um projeto recém-criado é semelhante à apresentada na figura 23. Caso não esteja

Pág. 26 de 95

visualizando a tela do aplicativo como a mostrada na figura, abra, à esquerda, as pastas app\res\ visualizando layout e clique duas vezes sobre o arquivo activity_main.xml.

FIGURA 24 – Projeto Contador no Android Studio


• À esquerda, temos a aba Project, em que são exibidos os arquivos do projeto. Os dois arquivos mais importantes para nós, por enquanto, são os seguinte seguintes: s: ◊

MainActivity.java , na pasta app\java\nome_do_pacote_de_classes : é 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. ◊

e m XML do layout da activity_main.xml, na pasta app\res\layout: contém a especificação em tela do programa. É este arquivo que está aberto no momento e você pode vê-lo vê- lo (no modo de layout gráfico) na parte central do Android Studio.

• Na parte central do Android Studio, são exibidos exibidos os arquivos arquivos atualmente atualmente abertos. Na figura 24, o arquivo atualmente aberto é o activity_main.xml, que contém o layout da tela. Quando criamos o layout, podemos alternar entre a sua exibição gráfica (por meio da aba Design, na parte inferior) ou do seu código em XML (exibido no clique da aba Text). Outros arquivos abertos podem ser “trazidos “ trazidos para frente” frente” por meio do uso das abas. • No canto canto superior direito, temos a Component Tree (Ár (Árvore vore de Componentes). Componentes). Ela é útil, pois mostra a hierarquia dos widgets na janela (os componentes que usamos para montar uma tela – como botões e rótulos de texto).

Pág. 27 de 95

• No canto inferior direito, temos Properties, a janela de propriedades. Ela é usada para modificarmos os atributos dos widgets existentes na tela. Por exemplo: clicando sobre um botão, podemos trocar o texto exibido dentro dele alterando a propriedade text. • Por fim, na parte inferior do Android Studio, Studio, temos temos (ocultas (ocultas na figura 24, mas que que podem ser abertas clicando nos botões existentes) janelas de informações diversas. É ali que serão exibidas informações sobre a execução de um u m programa e localização de erros de compilação e execução. Antes de começarmos a escrever o código c ódigo do nosso aplicativo, aplicativo, precisamos assegurar que um AVD (Android Virtual Vir tual Device) esteja disponível para testarmos testarmos o app no emulador. Esse AVD já pode ter sido criado para você automaticamente no momento mome nto da instalação. Porém, se uma mensagem de f igura 18), 18), será necessário necessári o criar o AVD manualmente. erro foi exibida ao seu final (como mostrado na figura Se este foi o seu caso, siga as etapas da próxima seção, onde são dadas instruçõ es sobre como criar o AVD caso ele não exista.

3.4. Criando um dispositivo virtual Android (AVD) Para testar seus aplicativos você utilizará o emulador do Android incluído no Android Studio. 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. prog ramas. Porém, caso deseje desej e (ou precise), pode criar AVDs com diferente diferentess versões do Android e configurações de hardware variadas para testes. Verifique se o AVD AVD foi criado no momento da instalação clicando sobre o botão indicado na figura f igura 25. Este botão abre o AVD Manager, um gerenciador para criação e manutenção dos dispositivos dispositivos virtuais.

Pág. 28 de 95

FIGURA 25 – Botão da barra de ferramentas para abertura do AVD Manager


Se seu computador atendeu aos requisitos necessários, deve ter sido criado um AVD usando uma imagem do Android para processadores x86, que poderá ser executada em alto desempenho no seu computador. Caso não tenha sido possível a criação, e uma mensagem de erro semelhante à exibida na figura 18 tenha sido mostrada, será preciso criar um AVD usando uma imagem do Android para processadores ARM. Caso seja exibida uma tela como a da figura 26, siga as próximas etapas para criar o AVD.

FIGURA 26 – AVD Manager: neste exemplo, nenhum AVD foi criado


Para iniciar o processo de criação do AVD, clique no botão Create Virtual Device. Será mostrada a tela apresentada na figura 27.

Pág. 29 de 95

FIGURA 27 – Congurações do novo dispositivo virtual Android


Neste ponto selecionamos uma configuração para o aparelho a ser emulado. Marque o Nexus 4 dentro da categoria Phone. Ele tem um tamanho de tela semelhante a muitos aparelhos Android do mercado e serve perfeitamente como base para nossos aplicativos. Clique em Next para continuar. Em seguida, precisaremos escolher a imagem do Android a ser usada na emulação. Lembre-se de que estamos criando um AVD porque o instalador do Android Studio não conseguiu gerar um dispositivo virtual padrão com a imagem x86 no seu computador. Por isso, deveremos escolher uma imagem destinada a outra família de processadores, a família ARM. Para baixar a imagem do Android para ARM, clique na aba Other Images da tela na figura 28. Localize a imagem do Android Marshmallow (ou versão mais recente) para processador ARM (indicada na coluna ABI como armeabi-v7) e com suporte às APIs do Google, como a indicada pela seta na figura 28. Clique então em Download para que a imagem seja baixada.

Pág. 30 de 95

FIGURA 28 – Escolhendo a imagem do Android a ser usada no AVD


Uma nova tela, exibida na figura 29, será exibida. Para iniciar o download, você precisa concordar com os termos de uso da imagem clicando em Accept e, posteriormente, em Next.

FIGURA 29 – Aceitando os termos e iniciando o download


O download será então iniciado. Quando estiver finalizado, clique no botão Finish (figura 30).

Pág. 31 de 95

FIGURA 30 – Aceitando os termos e iniciando o download


A nova imagem poderá agora ser selecionada, como indicado na figura 31. Clique sobre ele e, em seguida, no botão Next.

FIGURA 31 – Selecionando a imagem ARM para o AVD


Os avisos em vermelho indicam que a CPU do computador em questão não suporta a tecnologia VT-x, por isso temos de criar um AVD com a imagem do Android para processador ARM. Como

Pág. 32 de 95

indicado na outra mensagem logo abaixo, a emulação para x86 apresentaria um desempenho superior. Na última tela de configuração do AVD (figura 32), podemos manter as configurações default e clicar no botão Finish.

FIGURA 32 – Última tela do processo de criação do AVD


Tudo pronto! Pode fechar o AVD Manager e voltar ao projeto que criamos anteriormente; vamos finalmente implementá-lo!

3.5. Escrevendo o código do seu primeiro aplicativo 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. 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 Android Studio, clique na aba Text. 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.

Pág. 33 de 95

QUADRO 4 – Código do arquivo activity_main.xml (pasta res\layout do projeto)
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=”com.example.professores.contador.MainActivity” >
android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :textAppearance=”?android:attr/textAppearanceLarge” android :text=”0” android :id=”@+id/txtContador” android :layout _ alignParentTop=”true” android :layout _ centerHorizontal=”true” android :layout _ marginTop=”41dp” />
android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :text=”Contar” android :id=”@+id/button” android :layout _ below=”@+id/txtContador” android :layout _ centerHorizontal=”true” android :layout _ marginTop=”41dp” android :onClick=”onClickContar” />

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.

Pág. 34 de 95

O TextView recebeu o idtxtContador, e será por meio dele que faremos acesso a este 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. 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 java\ nome_do_seu_pacote do seu projeto (o nome do pacote dependerá do que foi colocado emCompany domain no momento da criação do app – veja a figura 20). Deixe o código-fonte como o exibido no quadro 5.

Pág. 35 de 95

QUADRO 5 – Código do arquivo MainActivity.java (pasta java do projeto) package com.example.professores.contador;

import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

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 ); }

}

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.

Pág. 36 de 95

O método onClickContar será executado quando o usuário tocar no botão que colocamos na interface. Repare que este 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(). Tudo pronto! Para executar o aplicativo e testá-lo no emulador, clique no botão da barra de ferramentas do Android Studio, selecione um AVD na tela que será mostrada e clique em OK. O resultado será semelhante ao apresentado na figura 33.

FIGURA 33 – Tela do aplicativo Contador


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,

Pág. 37 de 95

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 34.

FIGURA 34 – Parte da hierarquia de Views e Widgets do Android

Fonte: Querino Filho, 2013

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 a qualquer tipo de objeto na tela.

Pág. 38 de 95

FIGURA 35 – Palheta de widgets do Android


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 Android Studio (figura 35) ou consultando a documentação oficial da API do Android. 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 36.

Pág. 39 de 95

FIGURA 36 – Congurando widgets gracamente


Porém, desenvolvedores mais experientes, de acordo com os tutoriais e documentação disponibilizados pelo Google em developer.android.com (2014), preferem configurar a interface diretamente pelo código XML. Para editar a interface usando XML, clique sobre a aba indicada na figura 37.

FIGURA 37 – Visualizando e editando a interface via XML


Pág. 40 de 95

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.

QUADRO 6 – Código do arquivo MainActivity.java de um projeto recém-criado package com.example.professores.contador;

import android.support.v7.app.AppCompatActivity; import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

@Override


}

Imediatamente, pela declaração da classe, você pode perceber que ela herda AppCompatActivity, uma classe existente no Android SDK que serve como base para nossas telas. Como desenvolvedor Java experiente, você já notou a existência de um método e que ele está marcado com a anotação @Override, que indica que este método está sobrescrevendo um método recebido por herança da sua superclasse (AppComptaActivity). O método em questão se chama 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 aparece pela primeira vez. 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,

Pág. 41 de 95

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! CURIOSIDADE 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 38).

Pág. 42 de 95

FIGURA 38 – Localização dos widgets EditText na palheta do Android Studio


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.

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 a pasta res\drawable do seu projeto. Você pode fazer isso simplesmente copiando o arquivo da imagem (com CTRL+C em um PC ou Command+C Pág. 43 de 95

em um Mac) e colando (com CTRL+V em um PC ou Command+V no Mac) na pasta drawable. Na tela que será exibida logo após colar, confirme a operação de cópia clicando em OK. Após colocada a imagem, arraste um widget ImageView (ele está dentro da categoria Widgets da palheta) até alguma parte da sua tela. Clique duas vezes sobre ele e, na janela popup que aparecerá, especifique a imagem a ser utilizada na propriedade src (veja a figura 39)!

FIGURA 39 – Adicionando imagens a uma tela com ImageView


É possível digitar o nome da imagem diretamente em src, colocando o identificador @drawable/ antes deste e omitindo sua extensão. Se preferir, clique nos três pontinhos à direita e, na janela que será exibida, localize sua imagem na aba Drawable. Conheceremos agora 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.

Pág. 44 de 95

QUADRO 8 – Exemplo de uso de Toast

Toast.makeText (this, “Esta é uma mensagem rápida!”, rápida!”, Toast.LENGTH_SHORT ).show(); ).show();

O método makeText() recebe três parâmetros: 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. LENGTH_LONG (para maior duração) ou Toast.LENGTH_SHORT (para menor duração). NUNCA SE ESQUEÇA de chamar o método show() show( ) após makeT makeText( ext(),), 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 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 eventos e estados de uma Activity, e o programador pode criar comportamento compor tamentoss 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 etc. Já sabemos que, quando uma tela é criada, o seu método onCreate é invocado. Dentro dele, podemos colocar código de inicialização 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! Para compreender melhor o ciclo de vida de uma Activity, dê uma olhada no gráfico da figura 40.

Pág. 45 de 95

FIGURA 40 – Ciclo de vida de uma Activity

Fonte:

• 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 segundo plano, em função de uma caixa de diálogo ou outra tela semitransparente semitransparente ter sido aberta, aber ta, 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().

aber ta e ocultar totalmente a tela atual, dizemos que esta Activity Ac tivity • No caso de uma nova tela ser aberta entrou no estado de parada e executou o evento onStop(). ◊

Neste caso, quando o usuário retorna à Activity que ficou “de baixo”, baixo”, ela executa o event evento o onRestart() e posteriormente o onStart().

• Finalmente, logo antes da Activity ser totalment totalmentee fechada, ocorre o evento 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 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 inter face

Pág. 46 de 95

gráfica, usando a janela de propriedades. No caso do XML, a configuração da propriedade é feita como exibido no quadro 9. QUADRO 9 – Exemplo de uso de conguração do evento onClick botão
android :la layo you ut _ wi widt dth= h=” ”wr wrap ap _ co con nten tent t” android :la layo you ut _ he heig igh ht= t=” ”wr wrap ap _ co con nten tent” t” android :text=”Incluir” :text=”Incluir” android :id=”@+id/button” :id=”@+id/button” android :la layou yout t _ cente centerHo rHori rizon zontal tal= =”true” android :la layou yout t _ marg margin inTo Top= p=”36dp” ”36dp” android :onClick=”onClickIncluir” /> :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 (void) e que receba um objeto da classe 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 void onClickIncluir(View view) {

// 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 de aplicativos, pois torna muito fácil a exibição de dados em listas. Ele está dentro da categoria Containers da palheta (veja a figura 41).

Pág. 47 de 95

FIGURA 41 – Localização do widget ListView na palheta do Android Studio


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 em si um ListView 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.

Pág. 48 de 95

QUADRO 11 – Exemplo de arquivo de layout com ListView, EditText e Button.

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=”com.example.professores.listadecompras.MainActivity” >
android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :id=”@+id/edtProduto” android :layout _ alignParentTop=”true” android :layout _ alignParentLeft=”true” android :layout _ alignParentStart=”true” android :layout _ alignParentRight=”true” android :layout _ alignParentEnd=”true” />
android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :text=”Incluir” android :id=”@+id/button” android :layout _ below=”@+id/edtProduto” android :layout _ alignParentLeft=”true” android :layout _ alignParentStart=”true” android :layout _ alignRight=”@+id/edtProduto” android :layout _ alignEnd=”@+id/edtProduto”

Pág. 49 de 95

android :onClick=”onClickAdicionar” />
android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :id=”@android:id/list” android :layout _ below=”@+id/button” android :layout _ alignParentLeft=”true” android :layout _ alignParentStart=”true” />

Os pontos principais neste layout são os seguintes: • Colocamos no EditText, em que será digitado o item idedtProduto, para identificá-lo corretamente no código Java; • No Button que vai realizar a inclusão do item digitado, configuramos seu evento onClick para disparar 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 List Activity: 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 ele 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.

Pág. 50 de 95

QUADRO 12 – Código para MainActivity.java com suporte a ListView package com.example.professores.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; import android.widget.Toast; public class MainActivity extends ListActivity { EditText

edtProduto;

ArrayList lista; @Override

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout. activity _ main ); String[] produtos =

new String[]{“Arroz”, “Feijão”, “Batata”};

lista = new ArrayList(); for (int i = 0; i < produtos.length; ++i) { lista.add(produtos[i]); } ArrayAdapter adaptador =

new ArrayAdapter(this,

android.R.layout.simple _ list _ item _ 1 ,

lista);

setListAdapter(adaptador);

edtProduto = (EditText)findViewById(R.id. edtProduto ); }

public void onClickAdicionar(View v) {

Pág. 51 de 95

String produto =

edtProduto.getText().toString();

lista.add(produto); ArrayAdapter adaptador = (ArrayAdapter)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(); } }

android :layout _ alignRight=”@+id/edtProduto” android :layout _ alignEnd=”@+id/edtProduto” android :onClick=”onClickAdicionar” />
android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :id=”@android:id/list” android :layout _ below=”@+id/button” android :layout _ alignParentLeft=”true” android :layout _ alignParentStart=”true” />

O primeiro passo a ser feito é mudar a superclasse de MainActivity de AppCompatActivity para ListActivity. Basta trocar o nome da superclasse apó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 usaremos 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

Pág. 52 de 95

• • •

•

ArrayList à lista do ListView, usamos um objeto do Android denominado ArrayAdapter. Criamos um chamado 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; 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 interface 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 notifyDataSetChanged(), que fará a atualização dos dados exibidos no ListView, já que mudamos a fonte dos 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 intposition, 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. SAIBA MAIS A VERSATILIDADE DO onListItemClick Este 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 (veremos 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.

MÓDULO 4 – LAYOUTS E INTENTS Construir uma boa interface de um aplicativo Android é muito mais do que 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) possibilita que os elementos permaneçam organizados

Pág. 53 de 95

adequadamente na tela, até mesmo no caso de aparelhos com diferentes tamanhos de tela. Neste módulo, conheceremos um pouco mais sobre os gerenciadores de layout. A classe Intent, utilizada para realizar operações que envolvam atenção do sistema operacional, 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 arrastadas para a tela por meio da palheta de widgets, como pode ser observado na figura 42.

FIGURA 42 – Gerenciadores de layout disponíveis na palheta de widgets


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 LinearLayout, 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 destes dois, assim como as vantagens e desvantagens em utilizá-los.

Pág. 54 de 95

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 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 43 um exemplo de uso do layout relativo.

FIGURA 43 – Exemplo de uso do RelativeLayout


Você vê as linhas verdes na figura 43? 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 44 o posicionamento do EditText à direita de Fahrenheit.

FIGURA 44 – Exemplo de uso do RelativeLayout


Pág. 55 de 95

Podemos ver que o EditText está posicionado em relação aos dois TextView, ao EditText do Celsius e também ao botão. Esse excesso de “relações” pode ser problemático: se movermos ou reposicionarmos apenas um widget , 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 também não surtir o efeito desejado.

Para ter uma garantia maior da posição final dos widgets, diminuindo a liberdade no seu posicionamento, podemos utilizar o Linear Layout.

6.2. LinearLayout Com o layout linear, podemos ter mais certeza com relação ao posicionamento final dos widgets em diferentes tamanhos de tela, assim como não correremos mais o risco d e 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 uma única linha. Veja a diferença entre eles na figura 45.

FIGURA 45 – 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 45) você pode apenas colocar um widget abaixo do outro, e no horizontal (direita na figura 44), todos ficam na mesma linha, um ao lado do outro.

Pág. 56 de 95

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 46.

FIGURA 46 – Uso do LayoutLinear horizontal combinado com o vertical


Na figura 46, veja na Component Tree (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, colocamos, em linha, os TextViews e campos de entrada de texto necessários. A listagem deste exemplo de layout pode ser vista no quadro 13.

Pág. 57 de 95

QUADRO 13 – Código para arquivo XML de layout com Linear Layout

android :orientation=”vertical” android :layout _ width=”match _ parent” android :layout _ height=”match _ parent”>
android :orientation=”horizontal” android :layout _ width=”match _ parent” android :layout _ height=”wrap _ content”>
android :layout _ width=”0dp” android :layout _ height=”wrap _ content” android :textAppearance=”?android:attr/textAppearanceLarge” android :text=”Celsius:” android :id=”@+id/textView3” android :layout _ weight=”1” android :gravity=”right” />
android :layout _ width=”0dp” android :layout _ height=”wrap _ content” android :inputType=”numberDecimal” android :ems=”10” android :id=”@+id/editText3” android :layout _ weight=”1”>
android :orientation=”horizontal” android :layout _ width=”match _ parent”

Pág. 58 de 95

android :layout _ height=”wrap _ content”>
android :layout _ width=”0dp” android :layout _ height=”wrap _ content” android :textAppearance=”?android:attr/textAppearanceLarge” android :text=”Fahrenheit:” android :id=”@+id/textView4” android :layout _ weight=”1” android :gravity=”right” />
android :layout _ width=”0dp” android :layout _ height=”wrap _ content” android :inputType=”numberDecimal” android :ems=”10” android :id=”@+id/editText4” android :layout _ weight=”1” />
android :layout _ width=”match _ parent” android :layout _ height=”wrap _ content” android :text=”Converter” android :id=”@+id/button2” />

6.3. Menus e Caixas de Diálogo 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 47).

Pág. 59 de 95

FIGURA 47 – ActionBar (em destaque) em um aplicativo Android


Para poder usar a ActionBar é necessário possuir um arquivo XML que define os itens que ela contém. Também é preciso possuir dois métodos específicos implementados no código da Activity. Você não precisa criar o arquivo XML e os métodos manualmente: para tê-los automaticamente, no momento de criação do seu projeto, escolha o modelo Blank Activity para sua tela inicial (veja a figura 22 na seção 3.3). 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 criado com o modelo de te;a Blank Activity 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/menu/menu_main.xml < menu


xmlns:app=”http://schemas.android.com/apk/res-auto” xmlns:tools=”http://schemas.android.com/tools” tools:context=”com.example.professores.megasena.MainActivity” >
android :id=”@+id/action _ settings” android :orderInCategory=”100” android :title=”@string/action _ settings” app:showAsAction=”never” />

Pág. 60 de 95

Em seguida, o que acontecerá quando um item for tocado deverá ser programado no evento onOptionsItemSelected, 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 AppCompatActivity @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!”,

Toast.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); }

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 mensagem 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 DialogFragment. 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.

Pág. 61 de 95

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 static class FecharDialogFragment extends DialogFragment {

static FecharDialogFragment newInstance() { return new FecharDialogFragment(); }

@Override

public Dialog onCreateDialog(Bundle savedInstanceState) {

AlertDialog.Builder builder =

builder.setMessage( “Deseja

new AlertDialog.Builder(getActivity());

fechar esta tela?”)

.setPositiveButton ( “OK”,

new DialogInterface.OnClickListener() {

public void onClick(DialogInterface dialog, int id) { // USUÁRIO CLICOU EM OK

} }) .setNegativeButton ( “Cancelar”,

new DialogInterface.OnClickListener() {

public void onClick(DialogInterface dialog, int id) { // USUÁRIO CLICOU EM CANCELAR } });

return builder.create(); } }

Agora, você pode chamar o diálogo no ponto em que desejar da sua Activity (como em um clique de botão) instanciando a classe criada e chamando o método show() no objeto criado, como pode ser visto no quadro 17. Pág. 62 de 95

QUADRO 17 – Código para exibir a caixa de diálogo criada no quadro 14 public void onClick(View view) { FecharDialogFragment fecharDialogFragment = FecharDialogFragment. newInstance(); fecharDialogFragment.show(getSupportFragmentManager(),

“dialog”);

}

AULA 7 – INTENTS 7.1. Definição da classe Intent A classe Intent é usada quando desejamos realizaralguma ação que envolve outros componentes do aplicativo ou do sistema. Basicamente, é uma mensagem de solicitação, que será enviada a alguém requerendo, 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. Veja no diagrama da figura 48 como acontece esse processo.

FIGURA 48 – Abertura de uma nova tela (Activity) usando Intent

Fonte:

A partir da tela inicial (Activity A), usamos o comando startActivity() com uma Intent para sinalizar ao Android que desejamos abrir uma nova tela. O sistema operacional abre então a Activity B indicada na Intent e passa a execução ao evento onCreate () nela existente.

Pág. 63 de 95

Veremos na próxima seção quais são os comandos necessários para realizar estas etapas.

7.2. Criando e abrindo uma nova tela com Intent Antes de tudo, para que possamos abrir outra tela em um aplicativo Android, é preciso haver uma classe Activity e um layout XML para ela. Embora esses dois arquivos possam ser criados individualmente, o Android Studio possui um assistente de criação de Activities que automatiza o processo de criação destes dois arquivos. Para criar uma nova tela no seu aplicativo, clique com o botão direito do mouse sobre a pasta app do seu projeto e, no menu que será exibido, selecione File > New >Activity. Escolha o modelo para a nova tela – pode ser Empty Activity, como indicado na figura 49.

FIGURA 49 – Adicionando uma nova Activity ao projeto


Em seguida (figura 50), dê um nome para sua nova Activity em Activity Name (procure sempre manter a palavra Activity ao final – é uma convenção dentro do Android nomear activities dessa forma). Note que à medida que você digita o nome da Activity, o nome do arquivo de layout ( Layout Name) também muda de forma correspondente. Selecione o pacote adequado em Package name e clique em Finish.

Pág. 64 de 95

FIGURA 50 – Adicionando uma nova Activity ao projeto


Perceba que agora você possui uma nova classe Java na pasta java (dentro do primeiro pacote de classes) do projeto e um novo arquivo de layout em res\layout! E não é só isso: novas telas devem ser declaradas no arquivo AndroidManifest.xml do projeto, e isso também já foi feito pelo assistente. Supondo que você criou uma nova Activity chamada NovaActivity, como na figura 46, para abrila você deverá usar os comandos do quadro 18.

QUADRO 18 – Código para abrir uma nova tela (Activity) Intent intent = new Intent(this, NovaActivity.class); startActivity(intent);

É bastante simples: basta declarar um objeto da classe Intent, instanciá-lo e passar ao seu construtor o contexto atual ( this) e o nome da classe da Activity que desejamos abrir. Em seguida, invocamos o método startActivity() passando o objeto intent como parâmetro.

7.3. Passando valores para uma nova tela Quando usamos uma Intent para abrir novas telas, podemos também passar valores a elas. Isso é feito com o método putExtra() do objeto Intent.

Existem várias sobrecargas deste método, para que possamos passar diferentes tipos de valores, e todos eles recebem como primeiro parâmetro uma String que servirá como chave do valor passado, seguindo a sintaxe putExtra(chave, valor).

Pág. 65 de 95

No exemplo do quadro 19, estamos passando um número double com uma chave denominada valor e uma String com a chave nome.

QUADRO 19 – Código para passar valores à tela que será aberta Intent intent =

new Intent(this, NovaActivity.class);

intent.putExtra(“valor”, 200.5); intent.putExtra(“nome”,

“Anita”);

startActivity(intent);

Na Activity que será aberta, podemos obter estes valores no seu evento onCreate, como é mostrado no quadro 20.

QUADRO 20 – Código para recuperar valores passados na nova tela aberta @Override

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout. activity _ nova ); Intent intent = getIntent();

double valor = intent.getExtras().getDouble( “valor”); String nome = intent.getExtras().getString( “nome”); }

É simples: primeiro, obtemos uma referência à Intent que abriu esta tela, com getIntent. Em seguida, obtemos os parâmetros passados a ele com seu método getExtras() e extraímos dentro deles os valores que queremos, usando um método getter adequado para os tipos de dados de cada valor. Por exemplo, como “valor” foi passado como um número double, usamos getDouble; como “nome” foi passado como String, usamos getString.

MÓDULO 5 – BANCO DE DADOS EM ANDROID Os aplicativos que criamos até agora não possuem a capacidade de guardar dados entre as suas execuções. Para que possamos manter dados em um aplicativo Android, temos de recorrer a algum recurso que possibilite que estes fiquem gravados no dispositivo. A alternativa mais utilizada é o banco de dados SQLite, existente em todo aparelho com o sistema operacional Android e que pode gravar e obter dados rapidamente no próprio dispositivo – até mesmo no caso de um grande

Pág. 66 de 95

volume de dados. Neste módulo saberemos como utilizar o SQLite no nosso aplicativo Android para salvar e posteriormente consultar dados.

AULA 8 – BANCO DE DADOS EM ANDROID 8.1. Banco de Dados SQLite O SQLite é um sistema de gerenciamento de banco de dados compacto, escrito na forma de uma biblioteca de funções em C. Com código-fonte aberto e distribuído em domínio público, pode ser obtido gratuitamente no seu site oficial: http://www.sqlite.org . Como o próprio nome dá a entender, o SQLite é pequeno: sua versão mais recente ocupa pouco mais de 650 KB! Mas isso não quer dizer que ele seja pequeno na capacidade, já que pode lidar com bancos de dados de até 140 Terabytes e que, segundo testes realizados, consegue realizar cerca de 50.000 inclusões por segundo em um computador desktop padrão (de acordo com dados disponíveis no site oficial).

Outra característica importante: para criar a estrutura e manipular os dados na tabela, são usados comandos tipo-SQL, o que facilita bastante a adaptação e migração para o SQLite.

FIGURA 51 – Logotipo do SQLite

Fonte: https://sqlite.org/images/sqlite370_banner.gif

Por razões como as supracitadas, o SQLite é o banco de dados padrão não só dos aparelhos com Android, mas também daqueles com iOS! Sim, o iPhone e o iPad também possuem o SQLite instalado e usam o banco para armazenar boa parte dos dados dos seus aplicativos. Apesar de a API do SQLite estar originalmente em C, a Google criou classes Java que abstraem os principais comandos para manipulação do banco.

Pág. 67 de 95

Neste módulo, conheceremos as duas principais: SQLiteDatabase e SQLiteOpenHelper.

8.2. Criação do banco de dados O primeiro passo para fazer com que seu aplicativo possa usar o SQLite é criar uma subclasse de SQLiteOpenHelper. Esta classe existe para facilitar a abertura e, caso ainda não exista, criar o banco de dados. Basta criar uma classe Java básica herdando SQLiteOpenHelper e implementar o seu evento onCreate, que será usado para criar a(s) tabela(s) do banco (somente quando ele ainda não tiver sido criado). No quadro 21 você pode ver um exemplo de classe para abrir e criar um banco de dados com uma tabela para armazenar a lista de compras criada na seção 5.3.

Pág. 68 de 95

QUADRO 21 – Código para classe BancoListaOpenHelper package com.example.professores.listadecomprassql; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; public class BancoListaOpenHelper extends SQLiteOpenHelper { public BancoListaOpenHelper(Context contexto, String nome, SQLiteDatabase.CursorFactory fabrica,

int versao) {

super(contexto, nome, fabrica, versao); } @Override

public void onCreate(SQLiteDatabase db) { String criarTabela =

“CREATE TABLE produtos “ +

“( _ id INTEGER PRIMARY KEY AUTOINCREMENT, “ + “nome TEXT);”; db.execSQL(criarTabela); db.execSQL( “INSERT

INTO produtos (nome) “ +

“VALUES (‘Arroz’)”); db.execSQL( “INSERT


“VALUES (‘Feijão’)”); db.execSQL( “INSERT


“VALUES (‘Laranja’)”); } @Override

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { } }

A nossa subclasse de SQLiteOpenHelper precisa possuir os três métodos existentes na listagem do quadro 21: um construtor, o evento onCreate e o evento onUpdate. Este último só é usado quando o banco precisar sofrer alguma atualização. O onCreate é obrigatório, pois será executado quando o aplicativo tentar abrir um banco que ainda não existe. Ou seja, é ele que faz a criação inicial da estrutura do banco a ser usado!

Pág. 69 de 95

No exemplo do quadro 21, executamos no banco de dados (por meio do objeto db da classe SQLiteDatabase, recebido por onCreate) um comando SQL CREATE TABLE, para criar a estrutura da tabela Produtos. Ela possui os seguintes campos: • _id: o campo inteiro (INTEGER), chave primária (PRIMARY KEY ), que será único para cada produto e será gerado automaticamente ( AUTOINCREMENT ) como um número inteiro. Precisamos usar este nome exato ( _id ) para facilitar a ligação da tabela com um ListView – falaremos mais sobre isso depois. • nome: um campo do tipo TEXT (equivalente à String ou VARCHAR em outros SGBDs) para armazenar a descrição/nome do produto. • quantidade: um campo inteiro (INTEGER) para guardar a quantidade a ser comprada do produto. O comando é executado no banco por meio do método execSQL() do objeto db. Em seguida, executamos mais três comandos SQL para inclusão ( INSERT ) de alguns produtos de exemplo no banco, junto das suas respectivas quantidades. SAIBA MAIS Para saber mais sobre a sintaxe SQL e tipos de dados suportados pelo SQLite, acesse a documentação oficial em http://www.sqlite.org/docs.html .

8.3. Criação da classe DAO para acesso aos dados Como as operações comuns no banco de dados (inclusão, consulta, exclusão e alteração) envolvem o uso de diversos métodos, e estes são sempre relativos a um determinado sistema, é uma boa prática organizá-los em uma classe própria para a finalidade de manipulação dos dados no banco. Esta classe é comumente conhecida como classe DAO (Data Access Object), que é que uma classe Java padrão que encapsula todos os procedimentos de manipulação dos dados, assim como abertura e fechamento do banco. Para utilizá-la no seu aplicativo, crie uma classe Java padrão e chame-a de Dao. Acrescente a ela o código existente no quadro 22.

Pág. 70 de 95

QUADRO 22 – Código para classe Dao package com.example.professores.listadecomprassql; import android.content.ContentValues; import android.content.Context; import android.database.Cursor; import android.database.SQLException; import android.database.sqlite.SQLiteDatabase; public class Dao { private static final String NOME _ DO _ BANCO = “ListaDeCompras.db”; private SQLiteDatabase banco; private BancoListaOpenHelper bancoOpenHelper; public Dao(Context context) { , bancoOpenHelper = new BancoListaOpenHelper(context, NOME _ DO _ BANCO

null, 1); }

public void abrir() throws SQLException { banco = bancoOpenHelper.getWritableDatabase(); }

public void fechar() { (banco != null) if

banco.close(); }

public void inserirProduto(String nome) { ContentValues novoProduto =

new ContentValues();

novoProduto.put(“nome”, nome);

banco.insert(“produtos”, null, novoProduto); }

public void alterarProduto( long id, String nome) { ContentValues produtoAlterado =

new ContentValues();

produtoAlterado.put(“nome”, nome);

Pág. 71 de 95

banco.update(“produtos”, produtoAlterado, “ _ id = “ + id, null); }

public void removerProduto(long id) { banco.delete(“produtos”, “ _ id = “ + id, null); }

public Cursor obterTodosOsProdutos() { return banco.query(“produtos”, null, null, null, null, null, “nome”); } }

• Como na classe Dao realizaremos todo o acesso ao banco, precisamos ter dentro dela uma instância de SQLiteDatabase e outra de BancoListaOpenHelper ; • O construtor desta classe recebe um Context como parâmetro. Ele chamará por sua vez o construtor de BancoListaOpenHelper passando a ele: o contexto atual; uma String especificando um nome para o arquivo de banco de dados; null no terceiro parâmetro, pois não usaremos CursorFactory; e 1 no último parâmetro, sendo este o número de versão do banco. O objeto instanciado ficará armazenado em bancoOpenHelper ; • O método abrir faz a obtenção do objeto SQLiteDatabase gravável que servirá de “ponte de acesso” ao arquivo de banco de dados, por meio do método getWritableDatabase do openHelper; assim, seu retorno deve ficar armazenado em um objeto SQLiteDatabase-banco; • Já o método fechar realiza o fechamento de banco, caso este seja diferente de null (significando que o mesmo foi aberto); • O método inserirProduto é uma abstração para o método insert existente no objeto banco. Passamos ao inserirProduto um nome de produto e uma quantidade, para serem inseridos como um novo registro do banco. Um objeto da classe ContentValues chamado novoProduto é então usado para fazer a correspondência entre os campos da tabela e os valores a serem colocados neles, por meio do seu método put(campo, valor). Este objeto é então passado ao método insert , junto do nome da tabela na qual o registro será incluído; • A modificação de um produto na lista é feita com o método alterarProduto . Seu funcionamento é muito parecido com inserirProduto, contudo, como estamos alterando os valores de um produto existente, passamos ao alterarProduto o id do produto sendo modificado, junto dos (possíveis) novos valores para nome e quantidade. Este id será usado para montar a cláusula de condição de alteração (“_id = “ + id ) no método update do objeto banco;

Pág. 72 de 95

• Para excluir um produto, usamos o método removerProduto, que recebe como parâmetro o id do registro a ser excluído. Este id é então usado na condição de exclusão do método delete, existente no objeto banco; • Por fim, temos o método obterTodosOsProdutos. Ele retorna um objeto da classe Cursor do Android, que é um ponteiro para um conjunto de registros. Este cursor é criado por meio de uma consulta gerada com o método query, que faz um SELECT no banco de acordo com os parâmetros que recebe, sendo eles, em ordem sequencial: ◊

O nome da tabela a ser consultada;

◊

O nome dos campos a serem retornados (null retorna todos);

◊

A condição WHERE de consulta; null indica que não há condição;

◊

Os valores para as condições de WHERE;

◊

Cláusula de agrupamento (GROUP BY em SQL);

◊

Condição de agrupamento (HAVING em SQL);

◊

Cláusula de ordenação (ORDER BY em SQL).

Agora, podemos voltar à Activity. Nela, utilizaremos estes métodos da classe Dao para fazer a interação com o banco de dados. Para poder mostrar os dados da tabela no ListView, usaremos uma nova classe: SimpleCursor Adapter, o adaptador de listas usando cursores como fonte de dados.

8.4. Incluindo, excluindo e exibindo registros A utilização da classe Dao dentro do código da Activity é bastante simples. Dê uma olhada no código do quadro 23.

Pág. 73 de 95

QUADRO 23 – Código para MainActivity utilizando classe Dao package com.example.professores.listadecomprassql; import android.app.ListActivity; import android.os.Bundle; import android.support.v4.widget.SimpleCursorAdapter; import android.view.View; import android.widget.EditText; import android.widget.ListView; public class MainActivity extends ListActivity { EditText Dao

edtProduto;

dao;

@Override

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout. activity _ main );

dao = new Dao(this); dao.abrir(); SimpleCursorAdapter adaptador =

new SimpleCursorAdapter(

this, android.R.layout.simple _ list _ item _ 2 ,

dao.obterTodosOsProdutos(), new String[]{“ _ id”, “nome”}, }, new int[]{android.R.id.text1, and roid.R.id.text2 0); setListAdapter(adaptador);

edtProduto = (EditText)findViewById(R.id. edtProduto ); }

public void onClickAdicionar(View v) { String produto =

edtProduto.getText().toString();

dao.inserirProduto(produto);

Pág. 74 de 95

SimpleCursorAdapter adaptador = (SimpleCursorAdapter)getListAdapter(); adaptador.swapCursor( dao.obterTodosOsProdutos());

edtProduto.setText(“”); } @Override

protected void onListItemClick(ListView l, View v, int position, long id) { dao.removerProduto(id); SimpleCursorAdapter adaptador = (SimpleCursorAdapter)getListAdapter(); adaptador.swapCursor( dao.obterTodosOsProdutos()); } @Override

protected void onDestroy() { dao.fechar(); super.onDestroy(); } }

• Comparando com a versão anterior, usando ArrayList para armazenar os dados, temos como primeira mudança a declaração da variável global dao, objeto da classe Dao. Usaremos este objeto para acessar os métodos da classe Dao dentro dos eventos da Activity; • No onCreate, passamos a usar agora o SimpleCursorAdapter para conectar a lista aos dados. Ele recebe como parâmetros: ◊

Uma referência ao contexto (this);

◊

O nome de um layout para cada linha da lista – neste caso, usamos o layout simple_list_ item_2 do Android, que exibe duas linhas de texto (a de cima com fonte grande e a de baixo com fonte pequena);

◊

O cursor que trará os dados do banco – isso será feito pelo método obterTodosOsProdutos da classe Dao;

◊

Um vetor de Strings com os nomes dos campos trazidos pelo cursor que serão exibidos na lista;

Pág. 75 de 95

◊

Um vetor de ints com os ids dos widgets, no qual os campos do parâmetro anterior serão colocados, respectivamente; android.R.id.text1 indica a linha grande de cima e android.R.id. text2 indica a linha de baixo com fonte pequena;

◊

Valor 0, pois não usaremos os recursos ativados por esta flag.

• No onClickAdicionar, usamos agora o método inserirProduto para adicioná-lo ao banco. Em seguida, o método swapCursor é usado para atualizar a lista; • Quando o usuário tocar em um item da lista, onListItemClick chamará removerProduto na classe Dao, fazendo a exclusão do item por meio do seu id – veja que o id é um dos parâmetros recebidos pelo evento onListItemClick. Também usamos swapCursor para fazer um refresh na lista; • Nesta Activity, sobrescrevemos o evento onDestroy, que será executado quando a Activity for destruída, para que possamos fechar o banco de dados.

MÓDULO 6 – VISÃO GERAL DE RECURSOS DO SDK O Android SDK possui um conjunto enorme de APIs para que o desenvolvedor consiga utilizar os recursos existentes nos smartphones e tablets equipados com o sistema operacional Android. Vamos, neste módulo, conhecer um pouco sobre estas outras APIs e como você pode utilizá-las nos seus aplicativos. Falaremos sobre uso de GPS e mapas do Google Maps, como consumir dados de um Web Service e como acessar a câmera do aparelho para acesso a fotos e vídeos, assim como a API para reprodução de arquivos de áudio.

AULA 9 – GPS, WEBSERVICES, CÂMERA E ÁUDIO/VÍDEO 9.1. Acessando longitude, latitude e altitude por meio do GPS do aparelho Os smartphones modernos vêm equipados com um receptor de GPS, capaz de dar ao aparelho seu posicionamento global em latitude e longitude. Aliando os dados do GPS a um serviço de mapas, como o Google Maps, o usuário poder ter no seu celular um dispositivo de localização e de planejamento de rotas e itinerários imprescindível. No Android, os dados de localização são fornecidos pelos Location Services. O primeiro passo para utilizá-los em um aplicativo é solicitar sua utilização quando o usuário iniciar o programa. Isso

Pág. 76 de 95

é feito adicionando a linha do quadro 24 ao arquivo AndroidManifest.xml (coloque-a logo antes da tag ).

QUADRO 24 – Linha para utilização do Location Service no AndroidManifest.xml
android :name=”android.permission.ACCESS _ COARSE _ LOCATION”/>

Outro requisito importante : Nas novas versões do Android, o acesso aos serviços de localização

é feito pelo Google Play Services. Dessa forma, para que os recursos de localização funcionem corretamente, é preciso que o aparelho do usuário tenha o Google Play instalado e atualizado.

Mais um requisito: para desenvolver usando o Google Play Services, é preciso instalar o pacote necessário usando o SDK Manager. Para abri-lo, clique no botão da barra de ferramentas do Android Studio indicado na figura 52.

FIGURA 52 – Abrindo o SDK Manager pelo Android Studio


Na janela que será mostrada, clique na aba SDK Tools e, logo abaixo, marque a caixa relativa ao Google Play Services (figura 53). Clique então em OK para que ele seja baixado e instalado.

Pág. 77 de 95

FIGURA 53 – Instalando o Google Play Services para desenvolvimento


Depois de clicar em OK, será feito o download e instalação da biblioteca do Google Play Services. Pode ser que seja solicitada a confirmação do download ou da licença de uso da biblioteca, bastando aceitá-la para iniciar a instalação. Abra o arquivo build.gradle (Module:app), localizado dentro da lista de componentes do projeto (à esquerda no Android Studio), dentro de Gradle Scripts, e acrescente a linha em negrito no quadro 25 dentro do elemento dependencies do arquivo:

QUADRO 25 – Linha para utilização do Google Play Services no build.gradle dependencies { ....

compile ‘com.google.android.gms:play-services:9.4.0’ }

Cumpridos todos estes requisitos, ainda é preciso que sejam implementados alguns eventos na Activity, em que será feito o acesso aos serviços de localização. Veja o exemplo no quadro 26.

Pág. 78 de 95

QUADRO 26 – Activity contendo métodos para utilização dos Location Services package com.example.professores.testelocation; import android.content.pm.PackageManager; import android.location.Location; import android.support.annotation.NonNull; import android.support.annotation.Nullable ; import android.support.v4.app.ActivityCompat; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import android.widget.TextView; import android.widget.Toast; import com.google.android.gms.common.ConnectionResult; import com.google.android.gms.common.api.GoogleApiClient; import com.google.android.gms.location.LocationServices; public class MainActivity extends AppCompatActivity implements GoogleApiClient.ConnectionCall backs, GoogleApiClient.OnConnectionFailedListener { GoogleApiClient

googleApiClient;

@Override

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout. activity _ main );

if (googleApiClient == null) { googleApiClient = new GoogleApiClient.Builder( this) .addConnectionCallbacks(this) .addOnConnectionFailedListener( this) .addApi(LocationServices. API ) .build(); } }

Pág. 79 de 95

protected void onStart() { googleApiClient.connect(); super.onStart(); }

protected void onStop() { googleApiClient.disconnect(); super.onStop(); }

public void onClick(View v) { if (ActivityCompat. checkSelfPermission (this, ACCESS _ COARSE _ LOCATION ) android.Manifest.permission. != PackageManager. PERMISSION _ GRANTED ) { ActivityCompat.requestPermissions (this,

new String[] { android.Manifest.permission. ACCESS _ COARSE _ LOCATION }, 0);

return; } Location localizacaoAtual = LocationServices. FusedLocationApi.getLastLocation( goo

gleApiClient);

if (localizacaoAtual != null) {

double latitude = localizacaoAtual.getLatitude(); double longitude = localizacaoAtual.getLongitude(); double altitude = localizacaoAtual.getAltitude(); TextView textView = (TextView) findViewById(R.id. textView ); String texto =

“LATITUDE: “ + latitude + “\n” +

“LONGITUDE: “ + longitude + “\n” + “ALTITUDE: “ + altitude;

Pág. 80 de 95

textView.setText(texto);

} } @Override

public void onConnected(@Nullable Bundle bundle) { Toast.makeText(this,

“CONECTADO ao Google Play Services”,

Toast.LENGTH _ SHORT ).show(); } @Override

public void onConnectionSuspended( int i) { Toast.makeText(this,

“Conexão ao Google Play Services SUSPENSA.”,

Toast.LENGTH _ SHORT ).show(); } @Override

public void onConnectionFailed(@NonNull ConnectionResult connectionResult) { Toast.makeText(this,

“FALHA NA CONEXÃO ao Google Play Services”,

Toast.LENGTH _ SHORT ).show(); } }

• Para poder usar os Location Services, a classe, logo na sua declaração, deve dizer que implementa (usando a palavra chave implements) as interfaces: GoogleApiClient.ConnectionCallbacks e GoogleApiClient.OnConnectionFailedListener

• Declaramos globalmente na classe um objeto da classe GoogleApiClient, que servirá como nosso cliente de acesso ao Google Play Services; • No evento onCreate da Activity, instanciamos o objeto googleApiClient; • No evento onStart da Activity chamamos o método connect do objeto googleApiClient , que fará a conexão ao serviço; de forma equivalente, chamamos o método disconnect no evento onStop da Activity; • Quando o usuário clicar no botão no qual está designado o método onClick, primeiramente solicitaremos a permissão do usuário para acessar sua localização, se isso ainda tiver sido feito (ActivityCompat.checkSelfPermission ); em seguida, obteremos a última localização válida usando o método getLastLocation do LocationServices, cujo retorno é armazenado em um objeto da classe Location; desse objeto, podemos obter a latitude, longitude e altitude atual, que exibimos ao usuário em um TextView;

Pág. 81 de 95

• Os métodos onConnectionFailed , onConnected e onConnectionSuspended devem ser obrigatoriamente implementados para tratar, respectivamente, de falha na conexão, conexão bem-sucedida e desconexão aos serviços de localização; sua existência na Activity é obrigatória, mesmo que fiquem vazios. SAIBA MAIS EXIBINDO MAPAS Para exibir a localização do usuário em um mapa do Google Maps, é preciso antes se registrar no serviço, obter uma chave de acesso e depois adaptar seu aplicativo à API do Google Maps. Mais detalhes em: < http://developer.android.com/google/play-services/maps.html >

9.2. Consumindo Web Services RESTful A implementação da linguagem Java existente no Android traz duas classes que podem ser utilizadas para realizar conexões a Web Services REST. Estas classes, pertencentes ao pacote java. net, são as seguintes: • URL: usada para representar o endereço a um recurso na Web, ou seja, um site ou Web Service; • HttpUrlConnection : permite a realização de uma conexão a uma URL por meio do protocolo HTTP. Além delas, utilizaremos também uma classe do pacote org.json para poder extrair os dados recebidos dos Web Services. O formato JSON é oriundo do JavaScript, e é utilizado para obtermos uma representação em modo texto de objetos, com os dados no formato “chave” : “valor”. Um objeto JSON é um conjunto de chaves e valores delimitados por { e }. JSONObject: armazena os dados recebidos em formato texto como um objeto. Os valores guardados nas chaves podem então ser retornados com métodos getters, existentes para os tipos de dados comuns.

Para saber como usar estas classes para se conectar a um Web Service REST, veja o código do quadro 27, com comentários explicando seu funcionamento.

Pág. 82 de 95

QUADRO 27 – Código de exemplo para conexão a um Web Service e recepção de dados em JSON package net.querino.dicionario; import android.os.AsyncTask; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import org.json.JSONException; import org.json.JSONObject; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; public class MainActivity extends AppCompatActivity { // Variável global da classe que vai armazenar a resposta recebida // do Web Service, em formato JSON. String

respostaJSON;

@Override


public void onClick(View view) { // Inicia a Thread que vai conectar ao Web Service // e obter os dados JSON

new ConsultaWebService().execute(“”); } public class ConsultaWebService extends AsyncTask { HttpURLConnection

urlConnection;

Pág. 83 de 95

@Override

protected Boolean doInBackground(String... args) {

// Este objeto StringBuilder será usada para armazenar o texto // JSON que estiver sendo mandado pelo Web Service. StringBuilder resultado =

new StringBuilder();

try { // MUITO IMPORTANTE: substitua o endereço a seguir pelo do Web // Service que você vai usar, incluindo parâmetros e valores URL url =

new URL(“http://” +

“endereco _ para _ seu _ webservice/” + “parametro=valor” );

// Faz a conexão ao serviço

urlConnection = (HttpURLConnection)url.openConnection(); InputStream in =

new

BufferedInputStream(urlConnection.getInputStream()); BufferedReader reader =

new

BufferedReader(new InputStreamReader(in)); String linha;

// O laço a seguir vai lendo, linha a linha, a // resposta do Web Service e guardando em builder.

while ((linha = reader.readLine()) != null) { resultado.append(linha); } }

catch (Exception e) {

// HOUVE ALGUM ERRO!

}

// AVISE O USUÁRIO COM UM TOAST, PELO MENOS!!!

Pág. 84 de 95

e.printStackTrace(); }

finally { // Ao encerrar a leitura dos dados em JSON, fecha a conexão

urlConnection.disconnect(); }

respostaJSON = resultado.toString(); return true; } @Override

protected void onPostExecute(Boolean result) { JSONObject objetoJSON;

try { objetoJSON =

new JSONObject(respostaJSON);

// Aqui é o local onde você deverá usar o objetoJSON para // conseguir os dados que precisa. // Por exemplo, se o objeto tiver um valor string em uma // chave denominada “texto”, você a obterá com: //

String texto = objetoJSON.getString(“texto”);

// Se tiver um valor double com u m chave “saldo”: // }

double saldo = objetoJSON.getDouble(“saldo”);

catch (JSONException e) { e.printStackTrace(); } }

} }

9.3. Utilizando a câmera para fotos e vídeo O acesso à câmera do aparelho é realizado por uma Intent. Antes de usá-la, é preciso solicitar a permissão de acesso à câmera incluindo a linha do quadro 28 ao AndroidManifest.xml.

Pág. 85 de 95

QUADRO 28 – Linha para utilização da câmera no AndroidManifest.xml
android :name=”android.hardware.camera” android :required=”true” />

Tirar e salvar a foto em um aparelho Android é um processo que envolve o uso de várias classes. No código do quadro 29, temos uma Activity com um evento de clique de botão que abre a câmera e salva a foto obtida no sistema de arquivos do Android.

QUADRO 29 – Código completo de uma Activity para tirar e salvar uma foto package com.example.professores.cameraaudio; import android.content.Intent; import android.net.Uri; import android.os.Environment; import android.provider.MediaStore; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import android.widget.Toast; import java.io.File; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Date; public class MainActivity extends AppCompatActivity { String

caminhoParaFoto;

private File criarArquivoDaFoto() throws IOException { String timeStamp =

new SimpleDateFormat( “yyyyMMdd _ HHmmss”).format(new Date());

String nomeDoArquivoDaImagem =

“JPEG _ ” + timeStamp + “ _ ”;

File pastaDeGravacao = Environment. getExternalStoragePublicDirectory ( Environment.DIRECTORY

); _ PICTURES

File imagem = File.createTempFile (nomeDoArquivoDaImagem,

“.jpg”,

pastaDeGravacao);

Pág. 86 de 95

caminhoParaFoto = “file:” + imagem.getAbsolutePath(); return imagem; } @Override


public void onClick(View v) { Intent intentParaTirarFoto =

new Intent(MediaStore. ACTION _ IMAGE _ CAPTURE );

if (intentParaTirarFoto.resolveActivity(getPackageManager()) != null) { File arquivo =

null;

try { arquivo = criarArquivoDaFoto(); }

catch (IOException ex) { Toast.makeText(this,

“Falha ao gravar a foto.”, Toast.LENGTH _ LONG ).show();

}

if (arquivo != null) { intentParaTirarFoto.putExtra(MediaStore. EXTRA _ OUTPUT , Uri.fromFile(arquivo)); startActivityForResult(intentParaTirarFoto, 1); } } }

}

O processo de gravar um vídeo e visualizá-lo é bastante semelhante. A permissão adicionada ao AndroidManifest.xml anteriormente (veja o quadro 29) também dá acesso à gravação de vídeo. Veja um exemplo de como gravar e reproduzir um vídeo no código exibido no quadro 30.

Pág. 87 de 95

ACONTECEU Em 2013, a NASA, agência espacial americana, lançou três satélites feitos com smarphones Android. Os satélites possuíam o tamanho de uma caixa de 25 cm e custavam entre 3.500 e 7.000 dólares, o que é um valor incrivelmente barato perto de um satélite convencional, que pode custar milhões! Os satélites enviaram fotos e dados direto do espaço:

QUADRO 30 – Código completo de uma Activity para gravar e exibir um vídeo package com.example.professores.cameraaudio; import android.content.Intent; import android.net.Uri; import android.provider.MediaStore; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import android.widget.VideoView; public class VideoActivity extends AppCompatActivity { VideoView

videoView;

} } @Override

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout. activity _ video ); ); videoView = (VideoView)findViewById(R.id.videoView }

public void onClickGravarVideo(View v) { Intent takeVideoIntent =

new Intent(MediaStore. ACTION _ VIDEO _ CAPTURE );

Pág. 88 de 95

if (takeVideoIntent.resolveActivity(getPackageM anager()) != null) { startActivityForResult(takeVideoIntent, 1); } } @Override

protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == 1 && resultCode == RESULT _ OK ) { Uri uriDoVideo = data.getData();

videoView.setVideoURI(uriDoVideo); } } }

• Começamos declarando um objeto global denominado videoView, da classe VideoView. Ele existe na nossa interface (quadro 31) e será a janela de exibição do vídeo; • Quando o usuário tocar no botão, ativando o método onClickGravarVideo , usaremos uma Intent para abrir a câmera, indicando que o usuário fará a gravação de um vídeo; • O evento onActivityResult será executado quando o usuário terminar a gravação do vídeo e fechar a câmera. Nele, colocamos o vídeo salvo para ser exibido no videoView.

Pág. 89 de 95

QUADRO 31 – Arquivo /res/layout/activity_vide.xml com a interface da VideoActivity

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=”com.example.professores.cameraaudio.VideoActivity” >
android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :text=”Gravar Vídeo” android :id=”@+id/button2” android :layout _ alignParentTop=”true” android :layout _ alignParentLeft=”true” android :layout _ alignParentStart=”true” android :onClick=”onClickGravarVideo” /> < VideoView

android :layout _ width=”wrap _ content” android :layout _ height=”wrap _ content” android :id=”@+id/videoView” android :layout _ below=”@+id/button2” android :layout _ alignParentLeft=”true” android :layout _ alignParentStart=”true” android :layout _ marginTop=”113dp” />

Pág. 90 de 95

9.4. Reproduzindo arquivos de áudio Para reproduzir um arquivo de áudio no Android usamos a classe MediaPlayer. Trata-se de uma classe bastante simples de usar, ao mesmo tempo em que possui diversos recursos.

Com a MediaPlayer, é possível reproduzir arquivos de áudio nos formatos suportados pelo Android, que são: MP3, MP4, M4A, WAV, AAC, MIDI, FLAC e Ogg Vorbis (.ogg). Você deverá acrescentar seus arquivos de áudio em uma pasta denominada raw, dentro da pasta res, no seu projeto. Esta pasta não existe inicialmente; para criá-la, clique com o botão direito do mouse sobre a pasta res do seu projeto e selecione New... > Folder. Forneça o nome raw para a pasta e clique em Finish. Criada a pasta, arraste seus arquivos de áudio para ela, lembrando de, ao soltar, selecionar a opção Copy Files para que uma cópia do arquivo seja colocada no projeto. Agora é simples: é só acrescentar as linhas de código no quadro 32 a algum evento da sua Activity, substituindo arquivo pelo nome do seu arquivo para que o áudio seja reproduzido:

QUADRO 32 – Código para reproduzir um arquivo de áudio public void onClickReproduzirAudio(View v) { MediaPlayer mediaPlayer = MediaPlayer.create( this, R.raw.arquivo); mediaPlayer.start(); }

CONSIDERAÇÕES FINAIS Então é isso! Chegamos ao final de mais uma etapa deste curso. Parabéns! Desta vez, conhecemos o empolgante universo do desenvolvimento de apps, os pequenos, mas poderosos aplicativos criados para smartphones e tablets. Você aprendeu a desenvolver aplicações para o sistema operacional mais popular do mercado, o Android, que, além de ser líder absoluto neste segmento, apresenta outra grande vantagem para nós: os programas para ele são criados em Java! Aproveitando boa parte do conhecimento em Java que você já havia adquirido, pudemos agora transportá-los para uma nova plataforma, agregando as novidades e mudanças existentes em um app Android.

Pág. 91 de 95

Como você pode perceber, um desenvolvedor Java experiente pode começar a criar aplicativos Android em pouco tempo. Isso abre de imediato uma grande gama de oportunidades de desenvolvimento de novos aplicativos, assim como a migração de outros já existentes para essa nova plataforma. O mercado de aplicativos móveis está literalmente “pegando fogo” neste momento – por isso, arregace as mangas, junte os conceitos aprendidos nesta disciplina com os que você já possui, “dê asas” à sua imaginação e comece já a criar e publicar seus próprios programas. Desejo a todos boa sorte e muito sucesso nos seus projetos “móveis”!

Prof. Querino

GLOSSÁRIO Startups Uma empresa de tecnologia que acaba de ser aberta, ainda em fase de desenvolvimento. Disponível em: . Acesso em: 24 jan. 2017.

Formato Binário Sistema utilizado por computadores, onde as informações são traduzidas em 0 e 1.

Disponível em: < https://pt.wikipedia.org/wiki/Sistema_de_numera%C3%A7%C3%A3o_ bin%C3%A1rio >. Acesso em: 24 jan. 2017.

Metadados São os dados sobre outros dados. É a informação interpretada pelo computador que relaciona um tipo de dado a outra informação, qualidade ou característica. Disponível em: . Acesso em: 24 jan. 2017.

Parser Parser é a análise sintática em computação, o processo de analisar uma sequência de entrada para determinar sua estrutura, transformando, por exemplo, um texto em uma estrutura de dados

Pág. 92 de 95

para processsamento. Disponível em: . Acesso em: 24 jan. 2017.

Emulador É um software que reproduz um determiando ambiente para executar outros softwares, simulando o comportamento de uma configuração de hardware ou sistemas específicos, permitindo que um software criado para uma platforma específica funcione em outra diferente. Disponível em: . Acesso em: 24 jan. 2017.

Domínio É um nome usado para localizar e identificar conjuntos de computadores na Internet. O endereço de um site na Internet (www.exemplo.com.br) é um domínio, por exemplo. Ao acessar um site, o nome do domínio é convertido numa sequência de números que é o endereço IP, utilizado pelo computador para localizar a página. Disponível em: < https://pt.wikipedia.org/wiki/Dom%C3%ADnio >. Acesso em: 24 jan. 2017. Widget

Um widget é um componente da interface gráfica de um sistema operacional, como botões, ícones, apps interativos etc. Disponível em: < https://pt.wikipedia.org/wiki/Widget >. Acesso em: 24 jan. 2017.

Interface Interface é o conjunto de meios para adaptar dois sistemas com o objetivo de alcançar um resultado que possui características comuns aos dois sistemas. São as ferramentas utilizadas para uso e movimentação de qualquer sistema de informação. Disponível em: < https://pt.wikipedia.org/ wiki/Interface >. Acesso em: 24 jan. 2017.

Variável Em programação, variável é um objeto que tem a hablidade de guardar e representar um valor ou expressão. Disponível em: . Acesso em: 24 jan. 2017.

Pág. 93 de 95

REFERÊNCIAS BIBLIOGRÁFICAS ANDROID Tutorials. Vogella, 21 nov. 2012. Disponível em: . Acesso em: 23 jan. 2017. ARNOLD, K.; GOSLING, J.; HOLMES, D. A Linguagem de Programação Java. Porto Alegre: Bookman, 2007. BLOCH, J. Effective Java. Upper Saddle River: Addison-Wesley, 2012. DARWIN, I. Android cookbook . Sebastopol: O’Reilly Media, Inc., 2012. DEITEL, H. et al. Android for Programmers: An App-Driven Approach . Upper Saddle River: Pearson Education, 2012.

DEVELOPER ANDROID. These are the Android APIs. 2014. Disponível em: < http://developer.android. com/reference/packages.html>. Acesso em: 20 ago. 2014. FAWCETT, J.; QUIN, L.R.E. Beginning XML: 5th Edition. Indianapolis: John Wiley & Sons, Inc, 2012. GOSLING, J.; MCGILTON, H. The Java Language Environment . 1997. Disponível em: < http://www. oracle.com/technetwork/java/intro-141325.html >. Acesso em: 20 ago. 2014. JAVA 7 API. Java™ Platform, Standard Edition 7 API Specification . 2014. Disponível em: . Acesso em: 20 set. 2014. JAVA Tutorial. Oracle, 19 jul. 2014. Disponível em: . Acesso em: 23 jan. 2017. MEIER, R. Professional Android 4 Application Development. Indianapolis: John Wiley & Sons, Inc., 2012. PHILLIPS, B.; HARDY, B. Android Programming: The Big Nerd Ranch Guide. Indianapolis: Pearson Education, 2013. PRESSMAN, R. S. Engenharia de Software. São Paulo: McGraw-Hill, 2010. Pág. 94 de 95

Apostila Android

Recommend Documents