Vous êtes sur la page 1sur 32

Sumário

1 Introdução a programação para dispositivos móveis

1

1.1 Aplicações, Bibliotecas, Kernel

1

1.2 Arquitetura Android

 

1

1.3 Estrutura Geral (Componentes Android)

2

1.4 Componentes Para Desenvolvimento Android

3

1.5 Preparando Ambiente Para Instalação do Android Studio

4

1.6 Compilação e Empacotamento Projetos Android

4

1.7 IDE Android Studio

 

6

1.8 Configurando Sem Ambiente Para Desenvolvimento

7

1.8.1 Preparando

SDK

7

1.8.2 Preparando AVD

8

2 Definindo Layout de Aplicações Android

10

2.1 Criando e Estruturando um Projeto

10

2.2 Widgets

 

15

2.2.1

TextView

15

2.2.2

Button

15

2.2.3 ToggleButton

 

16

2.2.4 CheckBox

16

2.2.5 RadioGroup e RadioButton

16

2.2.6

Spinner

17

2.2.7

EditText

17

2.2.8

ImageView

17

2.3 Gerenciadores de Layout

18

2.3.1 RelativeLayout

 

18

2.3.2 LinearLayout

20

2.3.3 GridLayout

21

3 Manipulando Informações

22

3.1 Evento de Click

 

22

3.2 Capturando e Gerando Informações da Tela

24

3.3 Transição de

Telas com Activity

26

3.4 Transferindo Informações entre Atividades

28

4 Bibliografia

 

31

1

Introdução a programação para dispositivos móveis

Introdução Iniciamos agora a entrada no mundo da plataforma Android, nesse momento conheceremos as características da plataforma, um pouco de sua história, seus componentes e assim poderemos trabalhar cada função. Nessa unidade também exploraremos as bibliotecas que fazem parte do contexto da plataforma, conheceremos e entenderemos o funcionamento dos itens nativos do Android, ver a integração do mesmo com a Java Development Kit (JDK), estudar o processo configuração e instalação do ADT Bundle, pacote de desenvolvimento para Android, e compreenderemos o processo de instalação do SDK Android e Android Virtual Device nas plataformas Windows e Linux.

1.1 Aplicações, Bibliotecas, Kernel

O Android é uma S.O (Sistema Operacional) móvel, desenvolvida pela Google que em 2007 tornou pública uma versão baseada na plataforma Java com sistema operacional Linux, hoje o Android é mantido pela OHA(Open Handset Alliance), um grupo de empresas que se uniram com oo objetivo de dar suporte ao desenvolvimento de soluções para a plataforma móvel. Entre essas empresas podemos encontrar gigantes como: Vodafone, Telecom, Telefónica, Acer, Asus, Dell, Huawei, Lenovo, LG, Motorola, Samsung, entre outras.

Dell, Huawei, Lenovo, LG, Motorola, Samsung, entre outras. Saiba mais sobre OHA(Open Handset Aliance), seus membros

Saiba mais sobre OHA(Open Handset Aliance), seus membros e as ações que esse grupo de

empresas desenvolve em prol do desenvolvimento com uso da plataforma livre Android:

Inicialmente os aparelhos (SmarthPhones) que chegaram ao mercado brasileiro com essas características foram o Motorola Milestone e o Samsung Galaxy. Agora para entendermos um pouco da estrutura dessa plataforma vamos fazer algumas definições:

Assim como um sistema operacional convencional o Android possui uma série de características próprias. Ou seja, para entendermos seu funcionamento e conseguirmos desenvolver para ele temos que antes compreendê-lo. Ele possui um SDK (Software Development Kit) um Kit para desenvolvimento de aplicações que trabalharemos nesse curso.

1.2 Arquitetura Android

S.O. desenvolvido pela Google baseado em Linux. De acordo com as próprias organizações,

empresas como Motorola, LG, Sansung e Sony desenvolvem seus aparelhos utilizando o Android

com

o dispositivos fabricados, grande motivo pelo seu grande crescimento nos últimos anos. A

ilustra as camadas responsáveis pelo funcionamento do sistema operacional.

Figura 1

Figura 1: Arquitetura Android 1.3 Estrutura Geral (Componentes Android). Como todo sistema operacional o android

Figura 1: Arquitetura Android

1.3 Estrutura Geral (Componentes

Android).

Como todo sistema operacional o android também possui itens nativos, em outras palavras, componentes que já vem com o sistema, módulos que podem ser usados por outras aplicações e que podem ser ou não dependentes do Hardware. Abaixo listamos os itens nativos mais completos dessa plataforma:

Vocabulário Nativo – Próprio SGBD – Sistema Gerenciador de Banco de Dados SDK –Software Development
Vocabulário
Nativo – Próprio
SGBD – Sistema Gerenciador de
Banco de Dados
SDK –Software Development Kit

Independentes do Hardware

Dalvik virtual machine: U

dispositivos móveis.

ma máquina virtual como a JVM do Java porém otimizada para

Browser Integrado

Gráficos Otimizados

para • Browser Integrado • Gráficos Otimizados baseado no webkitengine. possui uma biblioteca 2D e 3D

baseado no webkitengine.

possui uma biblioteca 2D e 3D baseada na especificação OpenGL ES

1.0

SQLite: U

m SGBD, para guarda de dados na própria plataforma.

Suporte multimídia: P JPG, PNG, GIF).

ara áudio, vídeo e formatos de imagem (MPEG4, MP3, AAC, AMR,

Dependentes do Hardware

Telefonia GSM

Bluetooth, EDGE, 3G, e WiFi

Câmera, GPS, compasso, e acelerômetro

Além dos itens já citados acima o Android possui um conjunto de aplicações como cliente de email, agenda, mapas, etc. Uma base de bibliotecas para uso de softwares e componentes de sistemas como múltiplas camadas 2D e 3D, bibliotecas baseadas em C especiais para dispositivos rodando Linux, FreeType para fontes, etc.

O runtime, ou seja, ambiente de execução de aplicações Android possui uma peculiaridade: Cada aplicação Android roda em seu próprio processo com sua própria instância de máquina virtual (Dalvik). Ela executa arquivos “.dex”, projetados para consumir o mínimo de memória. O Kernel Linux, baseado na versão 2.6 trata serviços como Gestão de memória, gestão de processos, segurança, etc.

1.4 Componentes Para Desenvolvimento Android.

Antes de mais nada vamos entender cada componente que preenche as partes do ambiente para desenvolvimento Android. É necessário uma série de aplicativos e plugins para que possamos ter o ambiente para uso do Android:

1º O Kit de desenvolvimento Java JDK

– Que contém a máquina virtual Java e as ferramentas

para desenvolvedores nessa linguagem, como o compilador Java, etc.

2º O SDK(Android) para desenvolvimento para desenvolvimento android.

– Conjunto de ferramentas e APIs que compõem o kit

3º AVD(Android Virtual Device) em sua máquina.

– Uma ferramenta que emula um Sistema Operacional Android

4º O Android Studio IDE

Android desenvolvida pela Google

(Ferramenta de desenvolvimento) – Ambiente de desenvolvimento para

Levando em considerações que já conhecemos a estrutura de programação e Java, iremos apenas passar rapidamente pelos mesmos dando enfoque maior para o SDK do Android e ao Android Studio. Até pouco tempo tínhamos que fazer download e instalar cada um desses itens para o funcionamento, o que demandava bastante tempo com configuração. Para suprir essa necessidade, os desenvolvedores resolveram criar um pacote que contém todas as funcionalidades e aplicativos necessários para funcionamento do Android em sua máquina que pode ser baixado na página de desenvolvedores.

máquina que pode ser baixado na página de desenvolvedores. Para fazer o Download do Android Studio

Para fazer o Download do Android Studio que contém os componentes necessários para

instalação da plataforma Android no seu computador acesse o link:

Nesse pacote você tem em um só lugar:

Android Studio – Ferramenta Para desenvolvimento Android.

Android SDK Tools (Todas as ferramentas de desenvolvimento do Android).

Android Platform-tools (ferramentas da plataforma android, como AVD (Android Virtual Device, um emulador para o android no seu computador).

A última plataforma Android (Ultima versão distribuída do android). A última imagem do sistema Android para o emulador (Versão do android para o

emulador).

Isso facilitou muito a vida dos desenvolvedores, pois juntou em um único pacote tudo que o que os programadores precisam para trabalhar com a plataforma android. Vamos agora conhecer esses componentes:

1.5 Preparando Ambiente Para Instalação do Android Studio

Antes de Iniciar a instalação do Ambiente de Desenvolvimento Android Studio, certifique-se que a versão Java está instalada:

Para Linux:

que a versão Java está instalada: Para Linux: Para Windows: 1.6 Compilação e Empacotamento Projetos

Para Windows:

a versão Java está instalada: Para Linux: Para Windows: 1.6 Compilação e Empacotamento Projetos Android. Iremos

1.6 Compilação e Empacotamento Projetos Android.

Iremos agora entender de uma forma mais detalhada qual a função de cada componente necessário para o Desenvolvimento para aplicativos Android. Quem estuda linguagens de programação, certamente já ouviu falar em JAVA, essa linguagem de programação que domina o mercado. O JDK é um kit que contém uma série de aplicativos necessários para quem pretende desenvolver usando essa linguagem, ou seja, ele cria todo o ambiente necessário para que as aplicações Java possam ser: compiladas, interpretadas e executadas.

Dentro dos JDK nós temos uma ferramenta chamada JVM (Java Virtual Machine), ou seja,

máquina virtual Java, essa ferramenta consegue rodar as aplicações Java de forma que diversas plataformas possam usá-lo. Porém para executar especificamente aplicações android temos que

portanto deve ser instalado separadamente. Observe a

ter o pacote AVD(Android Virtual Device)

imagem abaixo que representa o funcionamento da JVM:

,

Código Java Compilador Bytecode Java. VM Windows VM Linux VM Celular S.O Windows S.O Linux
Código Java
Compilador
Bytecode Java.
VM Windows
VM Linux
VM Celular
S.O Windows
S.O Linux
S.O Celular
Desenho 1: Compilação com JVM

Observe que temos o ambiente de desenvolvimento onde escreveremos e compilar o JAVA, em

seguida é gerado pelo compilador um código intermediário chamado:

diversas máquinas virtuais, por isso o código Java é independente de plataforma, a única coisa necessária para que o Java rode em determinado sistema é que lá exista uma máquina virtual Java que entenda os bytecodes. Assim, temos diversas máquinas virtuais para diversas plataformas: Linux, Windows e dispositivos móveis.

, ele pode rodar em

bytecode

Para ter uma aplicação android executável Android é necessário que de um SDK(Software development kit). Ele contém um componente responsável por fazer o Processo de

empacotamento, reunindo não apenas o bytecode, mas também arquivos de configuração, layout,

imagens sons, vídeos e outros. O resultado final é gerado um arquivo no formato “.apk”. A ilustra o processo até a geração do executável.

Figura 2

no formato “.apk”. A ilustra o processo até a geração do executável. Figura 2 Figura 2:

Figura 2: Empacotamento Android

1.7

IDE Android Studio

Devido ao vasto conjunto de pacotes necessário para desenvolver e executar aplicativos Android em uma máquina a Google desenvolveu um Ambiente próprio para o a criação de aplicativos para o Sistema Operacional Android, essa Ferramenta chama-se Android Studio.

Android, essa Ferramenta chama-se Android Studio. Figura 3: Android Studio

Figura 3: Android Studio

Quem já ouviu falar sobre linguagens de programação, certamente já ouviu falar sobre IDEs, ela é um ambiente de desenvolvimento integrado, que permite ao desenvolvedor dispor de ferramentas

que facilitarão sua vida durante o processo de criação de software, uma IDE traz consigo inúmeras funções para facilitar a vida de quem programa, como exemplo podemos citar o fato de

autocompletar o código ao digitarmos determinado trecho de uma linguagem. Observe a

Figura 4 :

determinado trecho de uma linguagem. Observe a Figura 4 : Figura 4: IDE Android Studio v2.2

Figura 4: IDE Android Studio v2.2

Através dessa IDE podemos baixar Ferramenta SDK e Platform-tools para acesso ao AVD. Assunto que iremos ver nos próximos tópicos.

1.8

Configurando Sem Ambiente Para Desenvolvimento.

1.8.1 Preparando SDK

O primeiro passo é configurar o nosso SDK, acesse no menu Principal:

Tools > Android > SDK

Manager. Antes de Clicar, certifique-se de deixar habilitado a opção “Enable ADB Integration”.

de deixar habilitado a opção “Enable ADB Integration”. Figura 5: Configurando SDK 1 Na Área do

Figura 5: Configurando SDK 1

Na Área do SDK, aparecerá um conjunto de versões Android com suas respectivas APIs, Escolha Android 7.0 utilizando API 24, instalei também outras versões que deseja desenvolver para

projetos futuros. Observe a

Figura 6

.

outras versões que deseja desenvolver para projetos futuros. Observe a Figura 6 . Figura 6: Configurando

Figura 6: Configurando SDK 2

Ao Clicar em “OK”. Todos os pacotes necessários serão baixados e instalados em seu computador, caso necessário Clique em: “Launch Standalone SDK Manager” para visualizar todos os pacotes de forma mais detalhada.

1.8.2 Preparando AVD

Como dito em tópicos anteriores, AVD significa (Android Virtual Device). Depois que criarmos nossa primeira aplicação precisaremos dele para executar nosso projeto. Para criar nosso primeiro Emulador basta ir em : Tools > Android > AVD Manager como na Figura 7.

: Tools > Android > AVD Manager como na Figura 7. Figura 7: Configurando AVD 1

Figura 7: Configurando AVD 1

Inicialmente, você precisa criar um emulador utilizando as configurações que baixou no processo de instalação do SDK. No final do processo, aparecerá uma janela com esse conteúdo:

final do processo, aparecerá uma janela com esse conteúdo: Figura 8: Configurando AVD 2 Ocorrendo tudo

Figura 8: Configurando AVD 2

Ocorrendo tudo certo, ao clicar no botão “Run” na Coluna “Actions” abrirá o emulador com a seguinte Janela:

Figura 9: Emulador AVD Nesse momento configuramos com sucesso nosso emulador, todas as aplicações desenvolvidas

Figura 9: Emulador AVD

Nesse momento configuramos com sucesso nosso emulador, todas as aplicações desenvolvidas no Android Studio passará pelo processo de compilação, empacotamento e irá ser direcionada para esse emulador

OBS 1: Se deseja executar em outra versão do android, basta voltar ao SDK, baixar os pacotes de instalação da versão desejada e preparar um emulador para a versão escolhida.

OBS 2: Se tiver um aparelho android com versão compatível com seu SDK, poderá executar diretamente de dele oferecendo as permissões necessárias.

Com nosso ambiente preparado, Iremos no próximo Capítulo começar a criar nossos

primeiros projetos e começar a pôr a mão na massa com os Aplicativos!!!!!

2

Definindo Layout de Aplicações Android

Agora chegamos ao momento de iniciarmos o desenvolvimento das aplicações Android. O desenvolvimento dessas aplicações requer o conhecimento das estruturas que compõem um projeto para a plataforma, nessa unidade começaremos a compreender as estruturas SRC, GEN e RES, bem como as estruturas de Layout que facilitam a construção de um projeto para essa aplicação. Veremos a função de cada estrutura e com exemplos ilustraremos a criação de aplicações. Compreenderemos também os diretórios de saída de projeto onde identificaremos o local de encontro dos executáveis Android. E em seguida o uso dos Widgets que são os componentes gráficos e não-gráficos que compõem a plataforma android. Nosso objetivo é: Entender os componentes de um projeto android no Android Studio, verificando cada diretório e sua função. Também reconheceremos e faremos uso das estruturas de divisão do projeto e suas camadas, determinando assim o uso de mídias extras dentro do projeto; Usaremoos o compilador para criação dos aplicativos; Definiremos o passo a passo para a criação uma aplicação Android; Exportaremos a aplicação Android para Smartphones ou Tablets e realizaremos sua instalação; Por fim, conheceremos e faremos uso dos widgets Android nas aplicações com exemplos.

2.1 Criando e Estruturando um Projeto.

Projetos Android seguem os mesmos passos de aplicações Java, a criação de um projeto gerará

uma série de diretórios que irão compor toda a estrutura lógica de uma aplicação como diretórios e

arquivos de configuração observe a sequência iniciando em:

File > New > New Project

a sequência iniciando em: File > New > New Project Figura 10: Criando um Projeto 1

Figura 10: Criando um Projeto 1

Na Figura 10

definimos o nome do projeto, o seu domínio de acesso e o caminho que ele ficará

guardado, passando para a tela seguinte temos:

Figura 11: Criando um Projeto 2 Aqui definiremos em qual versão do SDK mínimo rodará

Figura 11: Criando um Projeto 2

Aqui definiremos em qual versão do SDK mínimo rodará nossas aplicações. Como instalamos e baixamos a versão Android 7.0 com API 24, criaremos nosso projeto nessa versão também. Passando para a tela seguinte temos:

nessa versão também. Passando para a tela seguinte temos: Figura 12: Criando um Projeto 3 Agora

Figura 12: Criando um Projeto 3

Agora precisamos definir um layout padrão para o nosso projeto. Para nosso projeto inicial iremos escolher “Empty Activity”, na tela seguinte temos:

Figura 13: Criando um Projeto 3 Aqui definiremos o nome da Classe Principal que trabalhará

Figura 13: Criando um Projeto 3

Aqui definiremos o nome da Classe Principal que trabalhará com nossa Tela inicial, deixaremos com o nome MainActivity, por fim clicamos em Finish.

Com isso, o Android Studio criará algumas pastas e arquivos com definições padrões do nosso Projetos, entenderemos o que cada pasta representa no nosso projeto.

entenderemos o que cada pasta representa no nosso projeto. Manifest : Toda aplicação Android deverá ter

Manifest: Toda aplicação Android deverá ter um AndroidManifest.xml, o arquivo contém informações Essências sobre o aplicativo, como nome do aplicativo, Domínio, telas que serão carregadas, etc.

Java: Aqui ficarão todos os códigos java do Projeto, basicamente todas as regras de camada de controle e modelo feitas em Java ficarão organizadas nessa pasta.

Res: Abreviação de resource, nessa pasta ficará todos os recursos da aplicação, como telas em xml, imagens Icones, sons etc

Grandle Script: Aqui é uma área para as configurações do seu aplicativos, como versão mínima suportada.

Agora que entendemos um pouco as pastas, inicialmente vamos compreender como funciona a classe Principal da nossa aplicação. MainActivity.java

Resumindo, a nossa classe MainActivity precisa estender de “AppCompactActivity”. Essa classe contém alguns métodos para processamento de telas. Essa classe nos possibilita usar o método “onCreate” que será executada ao ser carregado. Internamente utilizaremos o método setContentView, que receberá como parâmetro uma tela chamada ao layout activity_main que é nossa tela principal.

OBS: A Classe “R” é uma classe definida para capturar informações da nossa camada de visão, no nosso contexto atual, estamos acessando área de layout e acessando nosso layout inicial.

acessando área de layout e acessando nosso layout inicial. Figura 14: Classe MainActivity Nossa classe MainActivity

Figura 14: Classe MainActivity

Nossa classe MainActivity está pronta para carregar o layout principal, antes de e executarmos o projeto, vamos até nossa main_activity.xml e realizar algumas alterações na tela.

Entrando na pasta res > layout > main_activity.xml podemos visualizar a tela que será carregada na Figura 15 :

Figura 15: Layout Principal Ao clicar em activity_main.xml podemos ver como é a interface. Nela

Figura 15: Layout Principal

Ao clicar em activity_main.xml podemos ver como é a interface. Nela trabalharemos a camada de visão: A esquerda temos a Paleta onde podemos trabalhar com nossos “Widget”, ou seja, componentes da nossa tela, no centro podemos ver como ficará nossa tela, e a direita podemos ver e alterar algumas propriedades de cada elemento.

OBS: todo layout nativo android utiliza-se da linguagem XML que é basicamente uma linguagem de marcação onde podemos definir ordem e propriedades, abaixo podemos ver 2 Abas: Design e Text, ao clicar em Text podemos ver todas as informações escritas em XML dessa tela.

Ao executar nosso projeto no Android Studio no menu Principal em Run > app, será perguntado em qual emulador rodará. Como configuramos um emulador inicialmente, basta escolher o emulador configurado que abrirá o que foi feito já

o emulador configurado que abrirá o que foi feito já 1 – Crie uma tela que

1 – Crie uma tela que representará uma área de Login

utilizando só elementos da Paleta do Android Studio

2 – Crie uma tela que pedirá 2 números e somar.

3 – Crie uma tela que simulará uma lista de contatos.

Studio 2 – Crie uma tela que pedirá 2 números e somar. 3 – Crie uma

2.2 Widgets

Os Componentes que compõem um layout são criados a partir de widgets, mostraremos na apostila qual XML é gerado para cada componente apresentando algumas propriedades de cada elementos. Antes de entendermos qualquer componente temos que compreender como funciona o redimensionamento deles, existem 2 propriedades básicas:

1. :layout_width

android

2. :layout_height

android

: :
:
:

Define a largura de um componente.

Define a Altura de um Componente.

Os valores que são atribuídos a eles podem ser representados por 4 elementos:

1. match_parent:

2. wrap_content:

conteúdo.

Esse valor faz o elemento ter a mesma largura ou altura do elemento pai.

Esse valor faz o elemento ter a largura ou a altura suficiente englobar o seu

3.

4.

fill_parent: Mesmo que match_parent. Recomenda-se utilizar o valor match_parent a partir da API Level 8.

Valor:

suportadas na plataforma Android.

Uma dimensão, ou seja, um valor numérico utilizando uma das unidades de medida

Sabendo dessa propriedade Podemos começar a estudar nossos Widgets!!!!

2.2.1 TextView

TextView basicamente é um componente onde pode inserir uma informação em formato de texto muito parecido com a estrutura de uma label. Sua criação em formato XML logo abaixo:

1.

<TextView

2.

android:layout_width="wrap_content"

3.

android:layout_height="wrap_content"

4.

android:text="Olá Mundo!" />

Nesse contexto podemos dizer que meu textview ira ter uma largura to tamanho do seu conteúdo:

“Olá Mundo!”.

2.2.2 Button

1.

<Button

2.

android:text="Button"

3.

android:layout_width="wrap_content"

4.

android:layout_height="wrap_content"

5.

android:id="@+id/button" />

2.2.3

ToggleButton

Este é um elemento que variará entre ON e OFF de acordo com o pressionar do usuário.

1.

<ToggleButton

2.

android:text="ToggleButton"

3.

android:layout_width="wrap_content"

4.

android:layout_height="wrap_content"

5.

android:id="@+id/toggleButton" />

2.2.4 CheckBox

Esse elemento permite uma seleção individual do usuário, em nível de controle, esse elemento poderá retornar verdadeiro ou falso.

1.

<CheckBox

2.

android:text="CheckBox"

3.

android:layout_width="wrap_content"

4.

android:layout_height="wrap_content"

5.

android:id="@+id/checkBox" />

2.2.5 RadioGroup e RadioButton

Esse elemento permite uma seleção singular excluindo outras seleções que tiver no mesmo grupo, para isso, além da marcação RadioButton, temos que agrupar todos eles em um RadioGroup, veja o exemplo abaixo:

1.

<RadioGroup

2.

android:layout_width="wrap_content"

3.

android:layout_height="wrap_content"

4.

android:layout_alignParentStart="true" >

5.

<RadioButton

6.

android:text="Feminino"

7.

android:layout_width="wrap_content"

8.

android:layout_height="wrap_content"

9.

android:id="@+id/radioButton2"

10.

/>

11.

<RadioButton

12.

android:text="Masculino"

13.

android:layout_width="wrap_content"

14.

android:layout_height="wrap_content"

15.

android:id="@+id/radioButton"

16.

/>

17.

</RadioGroup>

2.2.6

Spinner

Os Spinners são seletores que podem ser criados para o usuário escolher uma opção. Para isso temos que antes atribuir o conjunto de opções em strings.xml

1.

<string-array name = "bairros">

2.

<item>Selecione Um Bairro</item>

3.

<item>Aerolândia</item>

4.

<item>Dias Macedo</item>

5.

<item>Aldeota</item>

6.

</string-array>

Depois de Preparada as opções podemos fazer a referência no XML Spinner no nosso layout principal activity_main.xml

1.

<Spinner

2.

android:layout_width="match_parent"

3.

android:layout_height="wrap_content"

4.

android:layout_alignParentTop="true"

5.

android:layout_alignParentStart="true"

6.

android:entries="@array/bairros" />

Utilizamos o atributo strings.xml

“android:entries”

para capturar o conjunto de elementos que atribuímos em

2.2.7 EditText

Esse componente permite que você digite um texto ao pressioná-lo,

1.

<EditText

2.

android:layout_width="wrap_content"

3.

android:layout_height="wrap_content"

4.

android:inputType="textPersonName"

5.

android:text="Digite um nome"

6.

android:id="@+id/editText" />

Por padrão, abre o teclado genérico para um componente EditText, porém existe uma propriedade ”

numéricos, telefone e outros elementos.

chamada “ android :inputType

onde

podemos

definir

esse

campo

como

senha,

campos

2.2.8 ImageView

Componente responsável por mostrar uma imagem no projeto. Antes de inserir o componente, temos que importar a imagem na pasta drawable.

1. <ImageView

2. android:layout_width="wrap_content"

3. android:layout_height="wrap_content"

4.

app:srcCompat="@drawable/egpce"

5.

android:id="@+id/imageView2"

6.

/>

Para pegar um recurso, precisamos utilizar a propriedade “ com a referência @drawable e informar o nome da imagem.

app

:srcCompat

”

, informar a pasta

Aprendemos como incluir nos nossos projeto os elementos, porém temos a responsabilidade de manter esses elementos alinhados nos mais diferentes tipos de aparelhos com resoluções diferentes. Para isso Trabalharemos em conjunto com Gerenciamento de Layout, assunto que iremos ver nos próximos típicos.

2.3 Gerenciadores de Layout.

Os gerenciadores de layout são estruturas que permitem a orientação e organização dos demais componentes vinculando-os a posições na vertical e horizontal e também os formatos de distribuição do objeto dentro do layout principal. No Android a classe que permite o início da criação e da distribuição desses layouts é a classe android.view.View, é dela que herdam todos os outros widgets. Os layouts são classificados como uma subclasse da classe View. Nesse contexto surge a classe ViewGroup que a partir dela surgem as classes: RelativeLayout, LinearLayout e GridLayout e outros. Abaixo citaremos os principais layouts e faremos exemplos para mostrar sua funcionalidade.

2.3.1 RelativeLayout

O RelativeLayout é o gerenciador de layout criado por padrão nos nossos aplicativos. Veja a seguir a sua criação XML:

1. <RelativeLayout

2. android:layout_width="match_parent"

3. android:layout_height="match_parent"

4. android:layout_alignParentTop="true"

5. android:layout_alignParentStart="true">

6. <!-- Os Componentes, como botões, caixa de texto, imagens ficarão nessa Área -->

7. </

RelativeLayout

>

Os componentes se posicionam considerando a posição dos outros componentes ou através de coordenadas, para isso, novas propriedades irão ser utilizadas para cada elemento, vamos para um exemplo prático com alguns botões seguindo diferentes tipos de alinhamentos e posições:

Figura 16: Componentes com RelativeLayout A estrutura XML referente à Figura 16 encontra-se a seguir:

Figura 16: Componentes com RelativeLayout

A estrutura XML referente à

Figura 16

encontra-se a seguir:

<RelativeLayout

android:layout_width="match_parent"

android:layout_height="match_parent"

android:layout_alignParentTop="true"

android:layout_alignParentStart="true">

<Button

android:text="Button1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_alignParentTop="true"

android:layout_alignParentStart="true"

android:layout_marginStart="19dp"

android:layout_marginTop="20dp"

android:id="@+id/button4" />

<Button

android:text="Button3"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:id="@+id/button6"

android:layout_alignBaseline="@+id/button5"

android:layout_alignBottom="@+id/button5"

android:layout_toEndOf="@+id/button5" />

<Button

android:text="Button2"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:id="@+id/button5"

android:layout_below="@+id/button4"

android:layout_alignStart="@+id/button4" />

<Button

android:text="Button4"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_alignParentTop="true"

android:layout_alignParentEnd="true"

android:layout_marginEnd="65dp"

android:layout_marginTop="163dp"

android:id="@+id/button7" /> </RelativeLayout>

2.3.2 LinearLayout

O LinearLayout é um gerenciador que permite posicionar todos os outros componentes da tela,

inclusive novos layouts, na vertical ou na horizontal. Os principais atributos dessa classe são o width e o height (Largura e altura) e o orientation(orientação) que define a colocação do layout na vertical e na horizontal. Para testar vamos criar um projeto para definição de alguns objetos:

1. <LinearLayout

2. android:orientation="horizontal"

3. android:layout_width="match_parent"

4. android:layout_height="match_parent"

5. android:layout_alignParentTop="true"

6. android:layout_alignParentStart="true">

7. <!-- Os Componentes, como botões, caixa de texto, imagens ficarão nessa Área -->

8. </LinearLayout>

O atributo que define os alinhamentos dos elementos é:

como: "horizontal"

ou "vertical"

android :orientation

. Veja como os elementos ficam posicionados:

, que poderá ser definido

os elementos ficam posicionados: , que poderá ser definido Figura 17: LinearLayout Horizontal Figura 18: LinearLayout

Figura 17: LinearLayout Horizontal

ficam posicionados: , que poderá ser definido Figura 17: LinearLayout Horizontal Figura 18: LinearLayout Vertical 20

Figura 18: LinearLayout Vertical

2.3.3 GridLayout

O GridLayout trabalha em formato de grade, definindo coordenadas(linha,coluna) para dispor os elementos na tela, para isso iremos incluir 2 propriedades em cada elemento:

android:layout_row: Define e linha que o componente ficará na grid

android:layout_column: Define a coluna que o componente ficará na grid.

As coordenadas da grid são definidas em formato de inteiro. Veja um exemplo a seguir:

– Figura 19: GridLayout –
Figura 19: GridLayout

o Exemplo do código gerado em XML vem a seguir:

<GridLayout

android:layout_width="match_parent"

android:layout_height="match_parent"

android:layout_alignParentTop="true"

android:layout_alignParentStart="true">

<TextView

android:text="TextView1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_row="0"

android:layout_column="0" />

android:id="@+id/textView" />

<Button

android:text="Button1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_row="0"

android:layout_column="1" />

android:id="@+id/button9" />

<CheckBox

android:text="CheckBox1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:id="@+id/checkBox"

android:layout_row="1"

android:layout_column="2" /> </GridLayout>

Agora que aprendemos a dispor os elementos e organizá-los em layouts, iremos capturar informações e trabalhar com eles em classes Java.

3 Manipulando Informações.

3.1 Evento de Click.

Para Criar um evento de Click, precisamos primeiro criar e definir um botão na camada de visão, então indo para nossa main_activity.xml criaremos um botão simples. O Processo é o mesmo que

. Além disso criaremos uma referência para esse botão, estou chamando-o

fizemos no tópico de “btnEvento”

2.2.2

estou chamando-o fizemos no tópico de “btnEvento” 2.2.2 Figura 20: Criando Botão com Evento Agora podemos

Figura 20: Criando Botão com Evento

Agora podemos ir até a nossa Classe Java. Como estão na tela principal, iremos até a Classe Java que faz sua criação, ela chama-se MainActivity nela implementaremos o seguinte código:

OBS:

através do AlertDialog.

Pata ativar o evento do botão, também aprenderemos como criar uma Caixa de Dialogo,

1. public class MainActivity extends AppCompatActivity implements View.OnClickListener {

2.

Button btnEvento;

3.

@Override

4.

protected void onCreate(Bundle savedInstanceState) {

5.

super.onCreate(savedInstanceState);

6.

setContentView(R.layout. activity_main );

7.

// Capturando informações do botão criado.

8.

this.btnEvento = (Button) findViewById(R.id. btnEvento );

9.

//Criando Evento para botão capturado

10.

this.btnEvento.setOnClickListener(this);

11.

}

12.

@Override

13.

public void onClick(View v) {

14.

AlertDialog.Builder cDialog = new AlertDialog.Builder(MainActivity.this);

15.

cDialog.setTitle("Título da Mensagem")

16.

.setMessage("Conteúdo da Mensagem")

17.

.setNeutralButton("Fechar", null)

18.

.show();

19.

}

20.

}

Inicialmente

criamos uma classe com uma implementação chamada “OnClickListener” que nos criamos uma referência ao

da tela chamada BtnEvento na linha 2, agora conseguimos capturar as informações através

Quando criamos qualquer elemento na tela, o

Dentro dela podemos

em seguida basta buscar o ID que definimos no

obriga a implementar o método “OnClick” da linha 13. Em seguida

botão

do método “findViewById” chamado na linha 8 .

Android Studio cria para nós uma referência em uma Classe chamada

fazer a busca apenas por Identificação, em botão.

“R.id”,

“R”.

Na Linha 10 chamamos o evento

desse botão. Inserimos como parâmetro o evento “OnClinck” da linha 13 criado na nossa implementação. Entre as linhas 14 até 18, criamos uma caixa de dialogo simples que contém um título, uma mensagem de texto e um botão que irá apenas fechar a caixa de dialogo.

responsável por acionar o evento ao click

“setOnClickListener”,

O resultado final temos:

Figura 21: Resultado Final Eventos Agora que criamos nosso primeiro evento de click de botão,

Figura 21: Resultado Final Eventos

Agora que criamos nosso primeiro evento de click de botão, estamos prontos para fazer a captura de informação de outros elementos e realizar processamento entre os dados capturamos.

3.2 Capturando e Gerando Informações da Tela.

O processo de capturar de informações de dados da tela é bem semelhante a

com o botão. Para isso, faremos uma aplicação simples que fará a Soma entre 2 números e mostrar em uma caixa de dialogo o resultado Veja a tela que será trabalhada:

o

que

fizemos

e mostrar em uma caixa de dialogo o resultado Veja a tela que será trabalhada: o

Figura 22: Tela Soma

Na Esquerda podemos perceber os elementos que foram criados e na direita podemos ver os Ids que foram definidos para cada elemento, isso é importante, pois precisaremos dessas informações na classe de controle. Na nossa nova implementação modularizaremos melhor nossa aplicação, assim aparecerão alguns elementos importantes para conhecermos ao manipular informações de uma tela. Inicialmente criaremos uma classe de controle que irá ser responsável por acionar o clique do botão e fazer a soma, então vamos criar uma classe chamada Calculadora, veja o código a seguir:

1. public class Calculadora {

2. //Método para Somar

3.

public static Integer soma(Integer n1,Integer n2){

4.

return n1 + n2;

5.

}

6.

//Método para converter um conteúdo de um EditText para Inteiro

7.

public static Integer convertNumber(EditText edNumber){

8.

return Integer.parseInt(edNumber.getText().toString().trim());

9.

}

10.}

Vamos explicar o que temos de novidade no código acima:

O método da

O método

novidade no código acima: • O método da • O método soma da linha 3, descreve

soma

da linha 3, descreve uma Soma simples entre 2 valores.

convertNumber

captura o conteúdo de um EditText e faz a conversão para

inteiro, precisaremos desse método, pois realizaremos uma soma.

Agora na nossa tela principal chamaremos classe Calculadora que fizemos.

1.

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

2.

Button btnEvento;

3.

EditText txt1,txt2;

4.

@Override

5.

protected void onCreate(Bundle savedInstanceState) {

6.

super.onCreate(savedInstanceState);

7.

setContentView(R.layout. activity_main );

8.

// Capturando informações do botão criado.

9.

this.btnEvento = (Button) findViewById(R.id. btnEvento );

10.

//Criando Evento para botão capturado

11.

this.btnEvento.setOnClickListener(this);

12.

}

13.

@Override

14.

public void onClick(View v) {

15.

//Capturando elementos da tela

16.

this.txt1 = (EditText) findViewById(R.id. txtN1 );

17.

this.txt2 = (EditText) findViewById(R.id. txtN2 );

18.

//Realizando Soma

19.

Integer resposta =

20.

Calculadora.soma(

21.

Calculadora.convertNumber(this.txt1),

22.

Calculadora.convertNumber(this.txt2));

23.

//Montando e execuando caixa de dialogo.

24.

AlertDialog.Builder cDialog = new AlertDialog.Builder(MainActivity.this);

25.

cDialog.setTitle("Título da Mensagem")

26.

.setMessage("Resposta = "+resposta)

27.

.setNeutralButton("Fechar", null)

28.

.show();

29.

}

30.

}

Veja o resultado final:

.show(); 29. } 30. } Veja o resultado final: Figura 23: Resultado Soma Com Evento 3.3

Figura 23: Resultado Soma Com Evento

3.3 Transição de Telas com Activity

A medida que seu aplicativo for crescendo, existe a necessidade de navegar entre as telas, isso é possível através das transições de Activity. Vamos preparar primeiro a nossa Janela Principal main_activity.xml.

das transições de Activity. Vamos preparar primeiro a nossa Janela Principal main_activity.xml. Figura 24: Tela 1

Figura 24: Tela 1

Observe que nomeamos nosso botão na Tela Principal de btnGoToJan2, esse botão acionará um evento para ir para uma, Nova tela

Para criar uma tela no Android Studio basta ir em res > layout layout e ir em

clicar com o botão direito na pasta

New > XML > Layout XML FILE. Com uma nova janela em branco, definiremos a

interface da tela 2.

nova janela em branco, definiremos a interface da tela 2. Figura 25: Tela2 Por padrão, o

Figura 25: Tela2

Por padrão, o Android Studio cria a classe MainActivity.java que irá se comunicar com a tela principal, como criamos uma tela, precisamos criar uma classe Java que irá se comunicar com essa segunda tela e para isso temos que criar uma classe ao lado de MainActivity.java que também herdará de AppCompatActivity, veja a Classe criada.

1.

public class Janela2 extends AppCompatActivity {

2.

@Override

3.

protected void onCreate(@Nullable Bundle savedInstanceState) {

4.

super.onCreate(savedInstanceState);

5.

setContentView(R.layout. janela2);

6.

}

7.

}

O que faremos de diferente é chamar a janela2 dentro de setContentView.

Importante:

e adicionar a janela2 como uma nova Activity. Veja o código abaixo:

Depois dessa Operação temos que ir no nosso arquivo AndroidManifest.xml do projeto

1.

<activity

2.

android:name="com.example.fabricionote.appaula.Janela2">

3.

</activity>

As definições de android:name mudará de acordo com as Configurações do seu Projeto. Com isso, temos nossas 2 telas configuradas, começaremos a criar nossa transição apenas utilizando o Objeto Intent. Veja o código abaixo:

1.

public

class

MainActivity

extends

AppCompatActivity

implements

View.OnClickListener {

 

2.

// Referência do botão criado

3.

private Button btnEvento;

4.

private EditText txtNome;

5.

@Override

6.

protected void onCreate(Bundle savedInstanceState) {

7.

super.onCreate(savedInstanceState);

8.

setContentView(R.layout. activity_main );

9.

this.btnEvento = (Button) findViewById(R.id. btnGoToJan1 );

10.

this.btnEvento.setOnClickListener(this);

11.

}

12.

@Override

13.

public void onClick(View v) {

14.

Intent intent = new Intent(this,Janela2.class);

15.

this.startActivity(intent);

16.

}

17.

}

O Objeto que será responsável pela transição é chamada de Intent, ela está declarada na linha 14. Para transitar entre as atividades, o objeto precisará da Activity atual e uma referência da classe que será responsável pela próxima tela. No construtor da nossa classe Intent está pedindo essas informações. Perceba que ainda na Linha 14 o processo de trilha entra a tela atual e a próxima é feita.

OBS:

navegador android, porém se realmente não precisar da tela que foi deixada, podemos encerrar da

memória ela. Para isso basta incluir o método

No efeito de transição a tela antiga não é perdida, é possível voltar para ela pelo próprio

finish().

3.4 Transferindo Informações entre Atividades

Quando trabalhamos com mais de uma tela, em vários momentos precisamos passar informações entre elas, para aprendermos, iremos aproveitar a implementação do tópico anterior. Primeiro vamos até o layout main_activity e adicionar uma Edit Text.

vamos até o layout main_activity e adicionar uma Edit Text. Figura 26: Informação entre Atividades 1

Figura 26: Informação entre Atividades 1

Nossa EditText foi criada com o nome de “txtInfo” como mostra a

é criar uma TextView na atividade que será carregada. Veja a imagem a seguir:

Figura 26

. Nosso próximo passo

Figura 27: Informação entre Atividades 1 na “janela2” criamos uma TextView chamada txtResposta, ela irá

Figura 27: Informação entre Atividades 1

na “janela2” criamos uma TextView chamada txtResposta, ela irá receber as informações digitadas da tela principal. Agora vamos para implementação em Java, começando pela MainActivity, veja o código a seguir.

1. public

class

MainActivity

extends

implements View.OnClickListener {

AppCompatActivity

2.

// Referência do botão criado

3.

private Button btnEvento;

4.

//Referência do campo QUe será digitado

5.

private EditText txtNome;

6.

@Override

7.

protected void onCreate(Bundle savedInstanceState) {

8.

super.onCreate(savedInstanceState);

9.

setContentView(R.layout. activity_main );

10.

this.btnEvento = (Button) findViewById(R.id. btnGoToJan2 );

11.

this.btnEvento.setOnClickListener(this);

12.

}

13.

@Override

14.

public void onClick(View v) {

15.

//Capturando a informação digitada na tela

16.

this.txtNome = (EditText) this.findViewById(R.id. txtInfo);

17.

Bundle dados = new Bundle();

18.

dados.putString("NOME",this.txtNome.getText().toString());

19.

Intent intent = new Intent(this,Janela2.class);

20.

intent.putExtras(dados);

21.

this.startActivity(intent);

22.

}

23.

}

As novidades estão entre as Linhas 16 e 21, vamos por etapas para entender o que foi feito. Na linha 16 capturamos as informações que o usuário digitou na MainActivity. O Objeto responsável por transferir uma informação de uma tela para outra é chamado de Bundle, ele está sendo criado na linha 17. Para Adicionarmos uma informação do tipo String, usaremos o método putString na linha 18. O método implementado irá pedir 2 parâmetros, uma chave, que poderá definir como desejar, e a informação digitada que irá representar o valor. O processo de armazenamento de uma Bundle é similar ao de um HashMap onde também é criado referencia por chave/valor.

Se tivermos mais informações a inserir, podemos abaixo da linha 18 chamar mais métodos “put”.

Na linha 20 preparamos nossa informação armazenada inserindo no nosso Intent através do método “putExtras()”, assim na linha 21, podemos garantir que a Intent irá fazer a transição da tela levando a informação da nossa tela atual.

Agora, na próxima tela, podemos capturar o Objeto Bundle que criamos, e realizar os mais diversos tipos de manipulação, veja o código abaixo:

1. public class Janela2 extends AppCompatActivity implements View.OnClickListener {

2.

private Bundle dados;

3.

private TextView tvResposta;

4.

@Override

5.

protected void onCreate(@Nullable Bundle savedInstanceState) {

6.

super.onCreate(savedInstanceState);

7.

setContentView(R.layout. janela2);

8.

this.tvResposta = (TextView) this.findViewById(R.id. txtResposta);

9.

this.dados = this.getIntent().getExtras();

10.

if(this.dados.containsKey("NOME")){

11.

this.tvResposta.setText(this.dados.getString("NOME"));

12.

}

13.

}

14.}

A novidade está entre as linhas 8 e 12, inicialmente capturamos a referência da nossa TextView criada na janela 2 na linha 8. Na linha 9 recebemos a Bundle que criamos na tela anterior. Através do Método “getExtras()” do método “getIntent()”. Podemos utilizar um método de verificação de chave pelo método “containsKey()” definido na linha 10. Por fim, na linha 11 capturamos as informações que armazenamos na tela anterior, através do método getString passando como parâmetro a chave que definimos. O Métodos “setText()” em tvResposta irá ser encarregado de alterar as informações para a digitada na tela inicial do nosso projeto.

Bem Pessoal, nosso curso de Introdução a Desenvolvimento Android está no Fim, o objetivo do curso é dar uma introdução para que vocês possam dar os próximos passos no desenvolvimento de aplicativos Móveis Android. Espera que tenha gostado do nosso Curso!

4 Bibliografia

ANDROID DEVELOPER. Documentação: Disponível em: <http://developer.android.com>.

15/10/2016

Macedo A. K19. Desenvolvimento Mobile com Android: Disponível em:

<http://www.k19.com.br/cursos/desenvolvimento-mobile-com-android> 12/10/2016

Rosal, F. S. Projeto e-Jovem. Introdução ao Desenvolvimento Android pra Mobile .2016