2016/2017 - eventos caf | campus ufv...

2016/2017

1

NOTAS DA APOSTILA

Esta apostila foi criada apenas com intuito de ensinar, passar informações e dicas

sobre a programação para dispositivos móveis com sistema operacional Android, e estará

livre para ser distribuída gratuitamente não podendo ser comercializada a fim de

conseguir qualquer tipo de lucro em cima deste material, qualquer crédito que possa ser

dado por referências deverá ser bibliografado ao criador da apostila.

2

SOBRE A APOSTILA

Nesta apostila o leitor encontrará informações para aprender e entender a base

da programação Android, estará dividida em como configurar a IDE, explicação dos

componentes do Android Studio, Criando Programas e lista de exercícios.

3

SOBRE O AUTOR

Mateus Felipe da Silva é Técnico em Informática formado pela Universidade

Federal de Viçosa Campus de Florestal, tem conhecimento em domínio nas linguagens

de programação: C, JAVA, Pascal, Visual Studio VB, Visual Basic.Net (VB.NET), HTML/CSS,

JavaScript, PHP e Programação para dispositivos móveis Android (Android Studio). Já

atuou em sala de aula como monitor de programação JAVA pela UFV e participou de

projetos de extensão BIC-Junior voltados para programação de microprocessadores

Arduino, e desenvolvimento Android.

4

SUMÁRIO

APRESENTAÇÃO ..................................................................................................................... 5

DEDICATÓRIA ......................................................................................................................... 6

INTRODUÇÃO ......................................................................................................................... 7

CAPÍTULO 1: INSTALAÇÃO DA IDE ........................................................................................ 7

CAPÍTULO 2: CONFIGURANDO O ANDROID STUDIO ......................................................... 13

CAPÍTULO 3: INICIALIZANDO A PLATAFORMA VISUAL DO ANDROID STUDIO PARTE 1 ... 18

CAPÍTULO 4: INICIALIZANDO A PLATAFORMA VISUAL DO ANDROID STUDIO PARTE 2 ... 21

CAPÍTULO 5: COMPONENTES DA IDE ................................................................................. 22

CAPÍTULO 5.1: XML .............................................................................................................. 23

CAPÍTULO 5.2: JAVA ......................................................................................................... 26

CAPÍTULO 5.3: ACTIVITYS ................................................................................................ 27

CAPÍTULO 5.4: BARRA DE NAVEGAÇÃO De ARQUIVOS DO PROJETO I ......................... 28

CAPÍTULO 5.5: BARRA DE NAVEGAÇÃO De ARQUIVOS DO PROJETO II ........................ 28

CAPÍTULO 5.6: TELA DE DESIGN ...................................................................................... 29

CAPÍTULO: 6 EMULADOR ANDROID ................................................................................... 31

CAPÍTULO: 6.1 INICIANDO AVD PELA PLACA DE VÍDEO OFF-BOARD ............................ 33

CAPÍTULO 7: PROJETO 1 ...................................................................................................... 35



9.1: SITES EXTERNOS E DOWNLOADS ............................................................................. 63

9.2: FREE SQL DATA BASE ................................................................................................ 65

9.3: INICIANDO ................................................................................................................. 69

10: CONSIDERAÇÕES FINAIS ............................................................................................... 84

5

APRESENTAÇÃO

Com o advento dos smartphones na nova era digital (Século XXI) e com grande

necessidade de novas ideias e aplicativos para o mercado consumidor de mídias digitais,

é necessário haver uma demanda de novos programadores que possam atender esse

novo mercado. O incentivo a novos programadores faz-se demasiadamente necessário

quando a quantidade de técnicos com tal aprendizado não consegue suprir a demanda

necessária.

Visando a dificuldade de encontrar materiais gratuitos para o aprendizado de

linguagens de programação, a segunda parte do projeto consiste na criação de uma

apostila de desenvolvimento e tirocínio deste assunto. A apostila em questão tratará de

um tutorial rápido, prático e de fácil entendimento que abordará desde a instalação

detalhada de cada componente da IDE utilizada na linguagem Android até uma explicação

da funcionalidade de cada um destes recursos. Também abordará pequenos programas

que poderão ser aperfeiçoados de acordo com o aprofundamento do estudo.

Essa apostila terá foco em um público leigo, que nunca teve contato com a

linguagem nem com a IDE. Conterá as instruções básicas e programas simples. A ideia

inicial é disponibilizá-la gratuitamente para ajudar a comunidade estudantil interessada

no assunto, e contribuir para que outras pessoas não passem por um problema já

averiguado: A dificuldade de encontrar materiais gratuitos e de entendimento

simplificado para iniciantes em programação Android. Assim, este se torna o principal

objetivo do projeto.

6

DEDICATÓRIA

Este material a dedicado a todos usuários interessado em programação Android

que queiram aprender algum conteúdo sobre o assunto. Um pequeno conhecimento em

alguma linguagem base de programação como C ou JAVA pode fazer com que este

material se torne ainda mais fácil de ser entendido, porém o não conhecimentos destas

não impedirá que o usuário tenha o mesmo sucesso e desempenho.

Este material também é dedicado ao coordenador de nosso projeto Antônio

Carlos Fava de Barros que foi um dos homens mais importantes no decorrer dos anos em

que fui seu aluno. Agradeço para tudo que conseguimos alcançar para o mérito da minha

formação acadêmica.

Por fim, dedico também à minha família, meus amigos. Estes se fizeram presentes

na minha vida nos momentos altos e baixos, e me auxiliaram na tomada de todas as

decisões, junto também para com os incentivos que me impulsionaram para a carreira

qual estarei caminhando.

7

INTRODUÇÃO

Para se programar na maioria das linguagens existentes apenas se faz necessário

utilizar uma IDE ou editor de texto para que se possa desenvolver programas para

determinados fins.

Para o aprendizado à programação Android não é muito diferente, porém

necessitasse de mais alguns programas e plug-ins que irão ajudar e facilitar no

desenvolvimento do Aplicativo

CAPÍTULO 1: INSTALAÇÃO DA IDE

O conjunto IDE e Compilador que irá ser utilizado será o Android Studio. O

programa é gratuito e poderá ser baixado pelo site Android Developer.

(https://developer.android.com/index.html) (2016).

Página Inicial do Site Android Developers

A IDE poderá ser baixada gratuitamente no site abaixo, baste clicar no botão verde

escrito ‘Baixar o Android Studio’. (https://developer.android.com/studio/index.html)

https://developer.android.com/index.html

https://developer.android.com/studio/index.html

8

(2016). A versão que estaremos baixando e utilizando no decorrer da apostila será a 2.1.3,

a mais recente na data em que esta apostila foi escrita.

Em seguida será baixado um programa com aproximadamente 1,2 GB de

tamanho, dentro desses 1,2 GB, já constarão a IDE, o compilador e o Emulador Android.

O Emulador Android servirá para que possamos testar nossos aplicativos, pois o Windows

não consegue emular um arquivo do tipo ‘.apk’.

Antes de iniciar o Download você deverá aceitar os termos de uso propostos pela

Google já janela que irá aparecer, não assine sem antes ler.

9

Página para aceitar os termos e condições para utilização do Android Studio

Após ter realizado esse procedimento o download se inicializará.

Após o término do download, abra o arquivo executável que foi baixado, você

verá uma tela de instalação do Android Studio e seus demais componentes.

10

Tela inicial de instalação do Software

Clique em “Next” para prosseguir com a instalação e, na próxima tela, marque as

duas opções na caixa de checagem. Após feito isso, clique em “Next” novamente.

Não mude os diretórios de instalação dos arquivos por ao instalar alguns recursos

necessários, eles podem ser transferidos para pastas fantasmas causando mau

funcionamento da IDE.

11

Após esse procedimento você irá ver uma janela como a da imagem abaixo, e

então basta clicar “Install” para que a instalação se inicialize.

12

A instalação poderá ser um pouco demorada em razão do tamanho e dos vários

componentes, em um processador 3.0 GHZ com 4 Núcleos foram gastos 24 minutos até

que a extração dos arquivos fosse concluída.

Após esperar o termino do último procedimento, basta clicar “Next” e depois

“Finish” para terminar a instalação. Abre o programa instalado em seguida.

13

CAPÍTULO 2: CONFIGURANDO O ANDROID STUDIO

Após a instalação do Android Studio precisaremos configurá-lo para melhor

apresentação e para que tudo funcione corretamente.

Ao iniciar o Android Studio será mostrado uma janela como a da foto abaixo,

deveremos clicar no botão “CONFIGURE” e em seguida em “SDK MANAGER” para que

possamos baixar as APIs e os demais recursos que deveremos utilizar.

Tela inicial do Android Studio

Há duas formas para se baixar as APIs. A primeira delas, é marcar na Janela que

foi aberta ao clicar em “SDK MANAGER”, as APIs que serão utilizadas. As APIs serão os

esquemas de versão do Sistema Operacional Android que rodará em seu Smartphone (ou

então no seu emulador do Smartphone).

No decorrer desta apostila usaremos a API 19 que é a conhecida verão do Android

4.4 (Android KitKat) e a API 22, Android Lollipop. Você poderá escolher qualquer API para

utilizar em seu projeto, a maneira de programar será a mesma. Porém se você escolher

uma API muito recente, smartphones mais antigos não suportarão seu projeto. Por

14

exemplo, ao escolher a API 23 (Android 6.0 Marshmallow) qualquer dispositivo com S.O.

Android abaixo desta versão não irá suportar seu aplicativo, apenas a API 23 para cima,

ou seja, a versão 6.0 e a 7.0.

Ao escolher a API 8 (Android 2.2 Froyo) você poderá usar o aplicativo em qualquer

smartphone com S.O. acima ou equivalente ao Android 2.2, porém, você não haverá de

recursos mais recentes e atuais, recursos que utilizaremos durante o acompanhamento

da apostila.

O Site “Android Developers” mostra gráficos e tabelas com a quantidade de

dispositivos que suportarão os aplicativos em cada API. NA imagem pode-se ver que o

Android 6.0 Marshmallow apenas funcionará em 4,7% dos dispositivos, o Android 4.4

KitKat funcionará em 40,5% dos dispositivos, enquanto o Android 4.0 Ice Cream

abrangerá 95,2% dos dispositivos.

15

Além de baixar as APIs você terá que baixar alguns recursos para que o emulador

e o compilador funcione.

Na aba “SDK Tools” marque as opções descritas na imagem.

16

E por fim na aba “SDK Update sites”, marque todas as opções.

A segunda maneira (recomendada para usuários avançados) é baixar os recursos pelo

SDK Manager.

17

Ao clica em “Launch Standalone SDK Manager” será aberto uma janela, ou você

poderá escolher um a um, todos os recursos que desejar baixar, basta selecionar os

recursos previamente ditos nas imagens acima.

Tela inicial do Android SDK Manager

Leia e aceite os termos de uso, e clique em “Install”, a janela será fechada, depois

clica em “Install XX packages” para terminar a configuração.

Agora, basta esperar o termino do Download das APIs, do plug-ins e das

ferramentas.

18

CAPÍTULO 3: INICIALIZANDO A PLATAFORMA VISUAL DO ANDROID STUDIO PARTE 1

Após todos os componentes baixados, instalados e configurados, o software já

está pronto para que o usuário se possa desenvolver aplicativos.

Para começar, abra o aplicativo que foi instalado no computador. Ao inicia-lo,

deveremos ver uma janela como esta.

Esta janela aparecerá apenas na primeira vez que o Android Studio for iniciado,

esta, ainda não é a IDE. Para começarmos devemos clicar em “Star a new Android Studio

Project”.

19

Nesta Janela precisamos dar nome ao nosso primeiro projeto, colocar o nome da

companhia ou empresa a qual ele pertence, e escolher a pasta em que ele deverá ser

salvo.

Sempre ao iniciar um novo projeto, esse passo deverá ser feito.

Ao clicar “Next” você deverá escolher a API em que o aplicativo será criado. Como

já explicado no capítulo anterior, versão mais recentes tem menor número de

dispositivos compatíveis, e versões mais antigos tem menor número de recursos para

serem utilizados.

Na primeira opção, que deverá ser marcada, escolheremos a API. Será listado

todas as APIs instaladas no processo da página 13 (capítulo 2). Caso você queira que seu

aplicativo funcione em “Smart Watches” você deverá marcar a opção “Wear” e escolher

a API. O mesmo vale para Android TVs, dispositivos de bordo para carro (Android Auto),

e para óculos de realidade virtual (Google Glass ou SmartEye), respectivamente as

opções: “TV”, “Android Auto” e “Glass”.

Aqui será utilizado a opção “Phone and Tablet”, que funcionará em Smartphones

e Tablets com S.O. Android, e escolheremos a API 19 (Android 4.4 KitKat).

Na tela escolheremos o tipo de janela que será visualmente apresentada no

dispositivo Android em que o aplicativo será instalado. Selecionaremos “Empty Activity”

20

Na próxima janela devermos escolher o nome das classes (que usuário

usará para programar) e das Activitys (que serão as telas do Dispositivo).

Agora basta clicar “Finish” para que a IDE do Android Studio seja

inicializada.

21

CAPÍTULO 4: INICIALIZANDO A PLATAFORMA VISUAL DO ANDROID STUDIO PARTE 2

Ao iniciar o Android Studio conseguimos ver a barra de menus, onde poderemos

abrir, mudar configuração e realizar as mais diversas operações no projeto. As que forem

necessárias e importantes serão explicadas no decorrer da apostila.

A partir da segunda vez que o Android Studio for iniciado, não será possível ver a

janela mostrada na página 17. A IDE já abrirá na página abaixo.

Para iniciar um novo projeto, podemos clicar em “File > New > New Project”.

A janela abaixo irá aparecer, e então basta repetir os passos explicados a partir da

página 17.

22

CAPÍTULO 5: COMPONENTES DA IDE

Ao iniciar um projeto, na parte esquerda da IDE vemos um seletor no qual podemos abrir

vários arquivos dentro do projeto. Quem já trabalhou com a linguagem JAVA, já está bem

familiarizado com este tipo IDE.

Dentre os vários tipos de arquivos, podemos observar dois tipos de arquivos: os arquivos

XML e os .JAVA.

Os que serão mais importantes para nós e os que mais usaremos durante a apostila, serão

os seguintes arquivos:

Arquivo de configuração geral: AndroidManisfest.xml

Classe Java para programação: act1.JAVA (aqui chamada assim, por foi o nome que

demos para ela no início do projeto)

E na aba “layout”, a Activity do projeto: tela1.xml (aqui chamada assim, pois renomeamos

PARA ISSO).

23

CAPÍTULO 5.1: XML

Os arquivos XML dentro da plataforma Android Studio servem para configuração

dos componentes visuais ou não, que irão aparecer na tela do dispositivo ou não. A

formatação de tamanhos, fontes, estilos, design, permissões, categorias, identidade,

configuração, ordem e hierarquias, dentre outras coisas. Em outras palavras, os arquivos

XML servem para dar as características de todo e qualquer componente que poderá

aparecer ou não na tela do dispositivo.

O Android Manifest configurará a parte gráfica não ligadas diretamente a

programação. Por exemplo: O tema da janela, cabeçalhos e rótulos, também poderemos

mudar nesse XML a ordem de abertura das Janelas do aplicativo, poderemos adicionar

permissões (como acesso à internet) e escolher ícones e imagens para o aplicativo.

Cada linha dentro da tag application (“<application >”) adicionará uma

característica ao seu projeto. Para adicionar uma nova particularidade, basta adicionar a

palavra “android” seguida de dois-pontos “:”,escolher a característica a ser mudada, (por

exemplo o nome que aparecerá no cabeçalho - label - do aplicativo), “label” adicionar o

símbolo de igualdade “=” e escrever a característica.

24

Por exemplo:

android:label="Meu Aplicativo"

Essa linha alterará o label do aplicativo para “Meu aplicativo”.

Algumas características podem ser repassadas por meio de outro arquivo XML, o

de Strings.

Um exemplo disso é quando vemos no XML a seguinte configuração:

android:label="@string/app_name"

Isso quer dizer que no Label do Android será escrito a informação contida no XML

de Strings “app_name”.

No XML de Strings, assim como o do Manifest, terá a informação declarando um

valor para a String “app_name”, nela terá o nome que se deseja designar quando for

usado o termo “app_name”.

<string name="app_name">Aplicativo</string>

Por exemplo, nesta seção, foi declarado que a String “app_name” tem o valor

“Aplicativo”, portanto, toda vez que for utilizado o termo “app_name” será repassado ao

lugar onde ela for utilizada a palavra “Aplicativo”.

25

android:label="@string/app_name"

<string name="app_name">Aplicativo</string>

Neste exemplo o Label estará recebendo a String “app_name”.

A String “app_name” tem o valor “Aplicativo”.

Logo o Label terá o valor “Aplicativo”.

Existem muitos outros arquivos XML dentro do Android Studio, como Styles,

Dimen (Dimensions), Colors e caso for necessário, podem ser criados novos arquivos XML

dentro das pastas do projeto.

Exemplo de configuração XML para cor:

<color name="colorPrimary">#3F51B5</color>


<dimen name="activity_horizontal_margin">16dp</dimen>


<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">

Exemplo de configuração do Manifest XML para o tema:

android:theme="@style/AppTheme">

26

CAPÍTULO 5.2: JAVA

A linguagem base que deve ser utilizada para programar será a linguagem JAVA.

Os veteranos nessa linguagem já sabem que os arquivos são divididos em classes. Em

Android Não é diferente. Cada tela do aplicativo tem uma classe. A classe será o espaço

que utilizaremos para programar. Além da criação da classe, também será criado um

arquivo XML para cada tela. Como já sabemos, o arquivo XML é o arquivo de criação ou

de configuração dos componentes de cada tela, ou do projeto.

Quando iniciamos nosso projeto, chamamos a classe JAVA de “act1”. Essa classe

JAVA será responsável pela programação da tela vinculada ao XML “tela1”. A visualização

da tela do projeto poderá ser realizada no XML na aba “Layout”.

Ao dar um duplo clique no XML do layout (aqui chamado de “tela1”), será possível

ver o XML de configuração da tela, e ao trocar da aba “Text” para a aba “Design” é

possível ver como o aplicativo ficará na tela do dispositivo.

Nesta apostila trabalharemos mais com a parte de “Design”. A parte de texto do

XML das telas será disponibilizada para cópia a cada parte finalizada do projeto.

27

CAPÍTULO 5.3: ACTIVITYS

Daqui para frente usaremos o termo correto para se referir as janelas que serão

apresentadas no dispositivo com S.O. Android. O nome correto para uma tela visível é

Activity. Quando criamos uma nova Activity é criado automaticamente um XML para esta

Activity e uma classe JAVA. O XML será usado para posicionar, configurar e tematizar os

componentes nesta tela. E a classe JAVA será o espaço que utilizaremos para programar

os eventos que poderão acontecer nesta Activity. De certa forma, o XML da Activity e a

classe JAVA estão conectados, pois, antes de programar um componente na classe JAVA

é preciso adiciona-lo no XML. Como já dito antes, adicionaremos os componentes via

Design para facilitar o entendimento visual, mas também, disponibilizaremos o XML Text

caso o leitor queira uma cópia exata dos projetos que serão desenvolvidos.

28

CAPÍTULO 5.4: BARRA DE NAVEGAÇÃO DE ARQUIVOS DO PROJETO I

No canto superior esquerdo da janela veremos a barra de navegação do projeto.

Nela poderemos alternar entre os vários XML e classes JAVA do projeto. Na foto abaixo

podemos ver os 3 principais arquivos

selecionados, sendo elas: Manifest, a Activity

(act1) e o XML da Activity (tela1.xml).

É possivel adicionar filtros e mudar a

forma como esses arquivos são dispostos nesse

seletor. Para isso, basta clica em “Android” e

selecionar uma das outras opções.

A opção “Android” mostra a maioria das

pastas e tem todos os arquivos que iremos

utilizar durante o projeto, então caso seus

arquivos sumam inesperadamente do seletor,

fique calmo, você pode apenas estar fora da aba “Android” da paleta de seleção.

CAPÍTULO 5.5: BARRA DE NAVEGAÇÃO DE ARQUIVOS DO PROJETO II

Os arquivos que foram abertos recentemente poderão ser encontrados nas abas

acima da tela, abaixo da barra de ferramentas. Para reavê-los pasta clicar na aba desejada

para que se possa continuar com o desenvolvimento do projeto.

29

CAPÍTULO 5.6: TELA DE DESIGN

Esta será a tela em que iremos adicionar componentes nas Activitys do projeto e

configurá-los, também poderemos ter uma visualização de como eles ficarão em

dispositivos diferentes.

1: Paleta – Nessa paleta estão representados os componentes que poderão ser

adicionados à tela do projeto, como botões, caixas de texto (TextView), botões de seleção

(Radio Button), dentre vários outros.

2: Árvore de Componentes – Aqui poderemos alternar entre os componentes

adicionados na tela, ela não é muito utilizada, mas quando tivermos componentes

sobrepostos na tela, será mais fácil selecioná-los por aqui.

3: Propriedades – Aqui “editaremos” os componentes da tela, configuraremos

algumas funcionalidades como formatação de tamanhos, fontes, estilos, design,

permissões, categorias, identidade, ordem e hierarquias, dentre outras coisas. Tudo o

que for editado nas propriedades será adicionado ao XML Text da Activity e tudo o que

for adicionado via texto no XML Text será modificado na janela de propriedades. Em

30

outras palavras não é necessário haver de algum conhecimento de XML para que

possamos construir o design da tela, basta ler as propriedades e ver quais as

características que serão alteradas na tela.

4: Tela de Simulação – Aqui poderemos arrastar os componentes da paleta para

a tela e depois arranjá-los e organizá-los da maneira que quisermos.

5: Simulação de API – Nesta aba será possível alternar a visualização das versões

Android em que o projeto será construído, aqui apenas mudaremos o layout de

apresentação, não alterando nada no projeto.

6: Aqui Alteraremos o tema da tela, isso inclui, cores, botões, visualizações.

Podemos também estar alterando o tema da janela via XML. Aqui também alteraremos

como a Activity será apresentada, por exemplo, sem a barra de notificações, sem os

botões de navegação e etc.

7: Aqui podemos mudar o layout do Smartphone que é exibido na tela.

31

CAPÍTULO: 6 EMULADOR ANDROID

Para podermos colocar em prática e testar os projetos criados, poderemos utilizar

os Emulador Android que se encontra dentro do Android Studio. O nome que

provavelmente você verá na internet para esse componente é o AVD Manager, ou

Android Virtual Device Manager.

Para criarmos um Emulador, deveremos clicar no ícone da AVD Manager, que se

encontra na parte superior da janela do Android Studio.

Em seguida, esta janela abaixo se abrirá, e então deveremos clicar em:

“Create Virtual Device”

32

Na janela que irá se abrir, deveremos selecionar o tipo que dispositivo que

queremos emular, as opções variam de Android’s TVs a Android Wear’s. O tempo de

processamento dos aplicativos dependerá da potência do computador em que o

Emulador está rodando, e do quão pesado é o Emulador.

Os Emuladores com resoluções grandes, grandes memórias e armazenamento,

ficarão lentos, demorarão abrir e terão baixa performance, então, se o seu computador

é mais simples, opte por um AVD também simples.

Caso seu computador possua uma placa de vídeo Off-Board, mais tarde mostrarei

como configurá-la para executar o Emulador, tirando ainda mais performance do AVD.

Em nosso projeto na apostila será utilizado o NEXUS 6 com a API 22 (5.1

LOLLIPOP).

Caso o computador possua uma boa configuração de Hardware, podemos

aumentar a memória, e a velocidade do AVD clicando em “SHOW ADVANCED OPTIONS”.

Para terminar de configurar, basta clicar em “FINISH”. Após termos criado o AVD,

poderemos iniciá-lo a partir do triangulo verde.

33

A primeira vez que o AVD for iniciado, ele demorará um tempo para iniciar, pelo

fato dele estar configurando o novo dispositivo.

Crie também um AVD com a API 22 (5.1 LOLLIPOP) e configure-o de maneira

semelhante.

CAPÍTULO: 6.1 INICIANDO AVD PELA PLACA DE VÍDEO OFF-BOARD

Para usarmos uma placa de vídeo Off-Board da NVIDIA para processar o AVD,

deveremos acessar o “Painel de Controle da NVIDIA”, “Configuração do

Programa” e clicar em “Adicionar”.

Deveremos selecionar o Emulador, para que possamos selecionar com qual

processador gráfico ele será executado.

34

O do Emulador é: quem-system-i386.exe.

Ao selecioná-lo, basta escolher “Processador NVIDIA de alto desempenho” como

processador gráfico na janela anterior.

Após o procedimento, basta clicar

aplicar, e quando o emulador for executado

na próxima vez, ele estará rodando na sua

placa de vídeo.

35

CAPÍTULO 7: PROJETO 1

Daqui para a frente seguiremos com a criação de 3 grandes projetos, um inicial

mais simples para apresentação dos componentes do Android Studio, um mais complexo

e teremos o projeto final com conexão externa a Banco de Dados.

Como primeiro projeto estaremos desenvolvendo uma aplicação inicial com

alguns componentes, mostraremos como colocar funções em botões, e configurar uma

tela, que aqui serão chamadas de Activitys.

Começaremos no Design da nossa tela 1.

Muitas vezes, ao iniciar o Android Studio, nos deparamos com esse erro. Ele pode

ser facilmente solucionado, trocando o APP THEME para HOLO.LIGHT.

No Manifest, faremos uma alteração no tema do aplicativo também:

android:theme="@style/Theme.AppCompat.Light.NoActionBar"

36

Daremos o nome de ‘act1’ para a Activity 1 e o nome de ‘tela1’ para o Layout

inicial.

Na tela inicial teremos seis botões, duas caixas de texto, o aplicativo copiará o

texto de uma das caixas e transferirá para a outra, teremos também botões de apagar o

texto das caixas e de esconder o teclado do dispositivo o outro botão será de enviar os

dados.

Arrastaremos os botões e as

caixas de textos da paleta e

tentaremos posicionar como

na foto ao lado.

Os nomes dos botões

de cima serão: ‘b1’, ’b2’,’b3’

respectivamente, a caixa de

texto ‘cx’ e a barra de

progresso ‘p’. Os de baixo

‘bb1’, ‘bb2’, ‘bb3’e ‘cx2’.

37

Quando clicar no botão enviar, o texto será salvo em uma variável, as caixas de

textos serão apagadas e a outra caixa de texto receberá o texto após a barra de

carregamento completar.

Primeiro deveremos “linkar” o botão físico a uma variável, este procedimento

deverá ser realizado por não conseguimos programar o botão, programamos a variável

que se refere ao botão. Dessa forma quando nos referirmos a variável estaremos nos

referindo ao botão. As variáveis deverão ser declaradas na parte superior da classe

JAVA referida à tela que você está vendo.

Dê um duplo clique na classe JAVA que foi criada quando você criou a Activity.

Declararemos os botões, e iremos “liga-los” aos botões físicos, também iremos

declarar duas caixas de texto, uma variável de texto, e uma barra de progresso, como

mostrado na imagem abaixo.

38

A parte em que ligamos os componentes é a primeira a ser executada quando o

aplicativo é iniciado. Iremos colocar alguns componentes invisíveis, apenas quando eles

puderem ser utilizados eles serão reabilitados. Faremos da seguinte forma.

bb1.setVisibility(View.INVISIBLE);



cx2.setVisibility(View.INVISIBLE);

p.setVisibility(View.INVISIBLE);

Desta forma serão declarados como invisíveis, os botões de baixo, a caixa de

texto de baixa e a barra de progresso.

Quando o aplicativo for iniciado, então serão apresentados apenas os

componentes superiores, pois os inferiores estão invisíveis!!

39

Se iniciarmos o aplicativo, ao abrir ele deverá tomar esta forma:

Primeiro programaremos os botões “apagar”.

Eles limparão as caixas de texto e também as variáveis, como o usuário poderá

clicar nesse botão várias vezes, criaremos uma função que será acessada toda vez que o

usuário clicar no botão (o mesmo procedimento será feito com os outros botões).

Faremos da seguinte forma.

View.OnClickListener apagar = new View.OnClickListener() {

@Override

public void onClick(View v) {

cx1.setText("");

cx2.setText("");

texto = "";

}

};

40

A função apagar limpará as caixas de textos e a variável texto. Ela deverá ser

chamada quando clicarmos em um dos botões “APAGAR”. Então iremos chamar a função

quando clicar no botão, basta inserir o código no “OnCreate” após a linkagem das

variáveis.

b2.setOnClickListener(apagar);

bb2.setOnClickListener(apagar);

Agora programaremos os botões de esconder o teclado.

Utilizaremos o seguinte código na função que chamaremos de ‘teclado’:

View.OnClickListener teclado = new

View.OnClickListener() {

@Override


InputMethodManager inputMethodManager = (InputMethodManager)

getSystemService(Context.INPUT_METHOD_SERVICE);

inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindow

Token(), InputMethodManager.HIDE_NOT_ALWAYS);

}

};

Deveremos chamar essa função ao clicarmos nos botões de esconder o teclado.

b3.setOnClickListener(teclado);

bb3.setOnClickListener(teclado);

Também adicionaremos o seguinte código:

p.setMax(2);

Estaremos definindo com ele, o tamanho máximo que a barra de progresso pode alcançar, que será nosso próximo passo.

41

Teclado Aberto

Teclado fechado ao clicar

no Botão

Texto Apagado ao clicar

no botão

Por último os botões “enviar”, eles farão o trabalho mais pesado do projeto!

42

Primeiro eles deverão salvar o texto da caixa de texto na variável;

Após, ele deverá apagar a caixa de texto;

Colocar invisível os componentes de cima;

Zerar a barra de carregamento.

Colocar visível a barra de carregamento;

Completar a porcentagem de carregamento;

Colocar invisível a barra de carregamento;

Colocar visível os componentes de baixo;

Preencher a segunda caixa de texto;

Utilizaremos a seguinte programação:

View.OnClickListener enviarSUP = new View.OnClickListener() {

@Override


texto = String.valueOf(cx1.getText());

cx1.setText("");

b1.setVisibility(View.INVISIBLE);




p.setVisibility(View.VISIBLE);

p.setProgress(0);

p.setProgress(100);


bb1.setVisibility(View.VISIBLE);



cx2.setVisibility(View.VISIBLE);

cx2.setText(texto);

}};

43

Para os botões de baixo faremos a mesma programação que os decima, exceto

para o de enviar, deveremos fazer algumas alterações.

Deverão salvar o texto da segunda caixa de texto na vaiável;

Apagar a caixa de texto;

Colocar invisível os componentes de baixo;

Colocar visível a barra de carregamento;

Completar a porcentagem de carregamento;

Colocar invisível a barra de carregamento;

Colocar visível os componentes de cima;

Preencher a primeira caixa de texto;

Utilizaremos o seguinte código:

View.OnClickListener enviarINF = new View.OnClickListener() {

@Override


texto = String.valueOf(cx1.getText());

cx2.setText("");

b1.setVisibility(View.VISIBLE);



cx1.setVisibility(View.VISIBLE);

p.setVisibility(View.VISIBLE);

p.setProgress(0);

p.setProgress(100);






cx1.setText(texto);

}

};

44

Basta então adicionarmos as funções de clique nos botões!

b1.setOnClickListener(enviarSUP);

bb1.setOnClickListener(enviarINF);

O código no OnCreate deverá ficar parecido com este:

Agora só falta testar o aplicativo!

Tente enviar mensagens de uma caixa para a outra, esconder o teclado, e apagar

as caixas de texto. Teste todas as funcionalidades!

45


O segundo projeto apresentará novos componentes, e troca de telas, criação de

novas tela e a chamada destas.

Na primeira tela teremos 6 botões, sendo 3 numerados de 1 a 3, e 3 botões

coloridos (azul, vermelho e amarelo). A clicar nos botões, serão escritos nos campos de

texto (chamados de Text View) o nome da cor, e o número escolhido.

Também teremos um botão para fechar o aplicativo.

Para começar iremos arrastar da paleta para a tela 6 “Buttons”, botões. Podemos

trocar o texto, a cor a fonte, tamanho e etc. na janela de propriedades do projeto, se

quisermos apenas alterar o rótulo dos botões também apertar a tecla “F2” e trocar o

texto que existe lá.

46

O projeto que trabalharemos agora será em base um sistema de avaliação onde

usuário poderá entrar com a nota de 0 a 5 estrelas. Após avaliado caso o usuário dê uma

nota boa no aplicativo, será pedido para usuário deixar um feedback sobre a nota e caso

a nota for baixa aplicativo pedir ao usuário que deixa um comentário sobre o que ele

poderá melhorar para que a nota aumente. Será possível após acessar os comentários

positivos e negativos junto com as notas das avaliações do usuário após a avaliação.

Na tela inicial teremos um botão que iniciará a o

aplicativo. Para adicionar o botão basta que cliquemos e

arrastemos ele para a tela. Também adicionaremos uma

imagem de boas vindas, para isso, antes deveremos salvar

a nossa imagem dentro da pasta “mipmap” para que

possamos acessar-la mais tarde, e adicionaremos o

componte “IMAGE VIEW”.

Para inserirmos a imagem dentro desta pasta, podemos clicar e arrastá-la para lá,

ou então, clicar com direito em cima desta, ir até a opção “SHOW IN EXPLORER” neste

momento, a pasta se abrirá, e você poderá salvar a imagem lá dentro.

47

Clique no ImageView e aperte “F2” para que as opções se abram. Clique “SRC” e

procure pela imagem que você escolher dentro da pasta “mipmap” que você salvou.

Após, renomearemos o botão, na janela das propriedades, ou no XML, a

propriedade “TEXT” é a que estará no rótulo do botão, colocaremos a palavra

“COMEÇAR”, e a propriedade “ID”, é a que utilizaremos para nos referir a este botão

quando formos programação. O chamaremos de BTNinicia.

Ao final teremos uma tela semelhante a essa.

O botão “começar” que chamamos de BTNinicia abrirá uma nova tela

(Activity) no aplicativo, que criaremos em seguida. Chamaremos ela de tela2. Ela

também terá uma Activity (act2). Para realizar este procedimento basta clicar

48

em cima da Activity da tela o que chamamos de act1 e ir em “New” > “Activity” >

“Empty Activity”.

Para selecionar uma

Activity como sendo a Activity

inicial, basta clicar em “LAUNCHER

ACTIVITY”, porém não é nosso

caso.

Já criada a nova “tela”, adicionaremos nela, um “TextView”, uma “RATING

BAR” e outro botão.

Renomearemos:

“TextView” para “Escolha sua nota”.

E o “Button” para “Votar.

Daremos o ID de “BTNvotar” ao nosso botão.

E para a Rating Bar, daremos o ID de “voto”.

Teremos um resultado parecido com este no

final.

49

Agora faremos a primeira programação. Chamaremos a tela2 quando clicarmos

no botão “COMEÇAR” da tela1.

Como estaremos programando a tela1, abriremos a Activity correspondente, no

caso a act1, e declararemos uma variável do tipo “Button” e daremos o nome a ela de

“b1”.

Em seguida, deveremos importar a classe Button, para isso basta dar

“ALT+ENTER” quando for solicitado. Ou escrever manualmente no topo da act1:

import android.widget.Button;

Em seguida colocaremos o seguinte codigo:

b1 = (Button) findViewById(R.id.BTNinicia);

A variável b1 recebe um botão, botão este que eu vou encontrar pelo ID BTNinicia.

Lembrando, que BTNinicia foi o nome demos ao nosso botão no início, caso você tenha

dado outro nome para ele, basta substituir.

b1.setOnClickListener(click);

Após daremos uma função de clique para o botão ligado a variável b1.

No caso, para ligarmos os botões, ou quaisquer outros componentes nas

variáveis, basta especificarmos qual seu nome, tipo e id que deverão ser conectados.

VARIÁVEL = (TIPO) findViewById(R.id.ID_DO_COMPONENTE);

50

E por fim criaremos a função click

View.OnClickListener click = new View.OnClickListener() {

@Override


}

};

Quando clicar no botão, queremos que a act2 se abra, então dentro da função click,

devemos inserir o seguinte código

Intent intent = new Intent(getApplicationContext(), act2.class);

startActivity(intent);

A Intent receberá qual janela deverá ser aberta (No caso a act2.class) e ela abrirá quando

dermos o “START” na acitvity.

No final seu código estará assim:

package android.aplicativo;

import android.content.Intent;

import android.support.v7.app.AppCompatActivity;

import android.os.Bundle;

import android.view.View;

import android.widget.Button;

public class act1 extends AppCompatActivity {

Button b1;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.tela1);



}


@Override


Intent intent = new Intent(getApplicationContext(),

act2.class);


}

};

}

51

Basta rodar, para testarmos a primeira parte. Para isso, temos que clicar no

triângulo verde, e selecionar o AVD que criamos no capítulo 6.

Como nosso aplicativo foi feito com a API 4.4, ele rodará em qualquer API igual ou

superior a 4.4, como criamos um Emulador na API 5.1, não teremos problemas em utilizar

nosso aplicativo.

52

Clicando no botão, a segunda tela se abre.

Teremos um resultado parecido com este:

Programaremos agora, a tela que deverá ser aberta, após o usuário der uma nota.

Se a nota for igual ou maior de 2.5 , a tela que se abrirá será a do feedback para

a satisfação do usuário.

Se a nota for menor que 2.5 , a tela que se abrirá será a do comentário para a

da insatisfação do usuário.

Na tela para satisfação do cliente teremos “Rádio Buttons”. Apenas um rádio

Button pode ser marcado por tela. Teremos cinco “Rádio Buttons” e um TextView

perguntando qual a melhor experiência do usuário no aplicativo, também teremos um

botão para finalizar o aplicativo.

No caso da nota menor que 2,5 estrelinhas abrirá uma tela com um TextView

perguntando o motivo da insatisfação em um TextField para que o usuário possa digitar

o que ele deseja que o aplicativo fosse melhor. Também contará com o botão para que a

aplicação termine.

53

Detalhe: Antes de adicionarmos os RADIOBUTTONS teremos que adicionar

um RadioGroup. Caso esse procedimento não seja realizado, será possível marcar mais

de um RadioButton na tela.

No final seu projeto deverá se parecer com este:

54

O Nome dos Ids que utilizaremos para programar são:

TELA 3

TELA 4

55

Teremos que verificar antes de sair da act2, quantas estrelas o usuário marcou,

para isso utilizaremos um condicional. Primeiramente, declararemos o botão com a

função click e a Rating Bar,

Button b1;



}

RatingBar r1;


@Override


r1 = (RatingBar) findViewById(R.id.voto);

}

};

Quando a usuário acionar a função clicar, verificaremos a quantidade de estrela

da RatingBar.

Detalhe, teremos que declarar a Rating Bar r1 fora da classe click, pois ela será

utilizada nas duas classes, dessa forma, permitiremos que ela seja utilizada em qualquer

outra classe ou função de clique que criarmos dentro da act2.

Utilizaremos o comando ‘GetRating’, para sabermos quantas estrelas o usuário

marcou. Teremos que salvar a quantidade de estrelas numa variável, que é do tipo

DOUBLE, ou seja, ela aceita números inteiros e decimais. Após variável do tipo DOUBLE

que no projeto foi chamada de ‘Nestrelas’ (NUMERO DE ESTRELAS), receber o valor de

quantas estrelas foram marcadas, verifica-se qual tela deverá se abrir:

Se Nestrelas maior ou igual a 2.5 abre a tela 3;

Se Nestrelas menor que 2.5 abre a tela 4;

56

O Método para abrir a tela é o mesmo já explicado na tela, basta substituirmos a

Activity que queremos que seja aberta. Por fim, o código fica da seguinte maneira:


@Override


double Nestrelas;

Nestrelas = r1.getRating();

if(Nestrelas >= 2.5){


act3.class);


}else

if(Nestrelas < 2.5){


act4.class);


}

}

};

No final a classe act2, ficará parecida com esta:

57

Se testarmos o aplicativo nesse momento, já verificaremos que se a nota dada

for igual ou maior que 2.5, a Activity 3 se abrirá, for menor que 2.5, a Activity 4 se

abrirá.

Na act3, que é a Activity de Satisfação do cliente, será mostrada uma mensagem

de saudação na tela após o usuário escolher a melhor experiência que ele obteve no

aplicativo.

Declararemos as os RadioButtons e o botão BTN3:

b3 = (Button)findViewById(R.id.BTN3);


r1 = (RadioButton) findViewById(R.id.r1);

r1.setOnClickListener(habilita);





Para mostrar a mensagem usaremos um “TOAST”. O Toast é uma mensagem em

‘POP UP’ que aparece por determinado período na tela do usuário. O conteúdo da

mensagem pode ser editado, e daremos um exibiremos um Toast diferente para cada

opção que o usuário escolher.

Para escolhermos as mensagens, criaremos uma String chamada “saudacao”.

Para cada RadioButton que escolhermos, um valor diferente é atribuído para a variável

saudacao.

if (r1.isChecked())

saudacao = "Ficamos felizes em saber que nosso aplicativo oferece

uma facilidade em seu uso! Obrigado";

if (r2.isChecked())

saudacao = "Ficamos felizes em saber que nosso aplicativo é rápido

no que faz! Obrigado";

if (r3.isChecked())

saudacao = "Ficamos felizes em saber que nosso aplicativo é claro

no seu objetivo! Obrigado";

58

Lembrando que r1, r2 e r3 são as variáveis ligadas aos RadioButtons.

Para evitar que o usuário saia do aplicativo sem ter votado, desabilitaremos o

botão BTN3, e apenas vamos reabilitá-lo, após o usuário escolher uma das opções.

Para desabilitar o botão, podemos inserir a seguinte linha no XML da act3:

android:enabled="false"

Ou então selecionar a opção “FALSE” nas propriedades do botão BTN3 no item

“ENABLED”.

Quando declaramos as variáveis do tipo RadioButton chamamos a função

“habilita” quando clicamos em um deles

“r3.setOnClickListener(habilita);”

A função “habilita” habilitará o botão para que o usuário possa sair do aplicativo.

View.OnClickListener habilita = new View.OnClickListener() {

@Override


b3.setEnabled(true);

}

};

Por fim teremos que mostrar a mensagem que será exibida.

Toast mensagem;

mensagem = Toast.makeText(getApplicationContext(),"Olá,

"+saudacao,Toast.LENGTH_LONG);

mensagem.show();

Criamos uma variável do tipo Toast, após atribuímos para ela os valores: qual tela ele

aparecerá, a mensagem, e a duração.

59

Como resultado final teremos o seguinte código:

package android.aplicativo;

import ...


Button b2;

@Override




b2 = (Button)findViewById(R.id.BTN2);


r1 = (RatingBar)findViewById(R.id.voto);

}

RatingBar r1;


@Override


double Nestrelas;

Nestrelas = r1.getRating();

if(Nestrelas >= 2.5){


act3.class);


}else if(Nestrelas < 2.5){


act4.class);


}

}

};

}

60

Note que inserimos um código a mais após a mensagem ser exibida:

Intent intent = new Intent(Intent.ACTION_MAIN);

intent.addCategory(Intent.CATEGORY_HOME);

intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);


Este código irá simular o toque no botão “HOME” do Smartphone, fazendo com

que você saia da aplicação.

Na parte final do nosso projeto, programaremos a act4.

Iremos declarar o botão BTN4, e criar a função “sair”. A função sair, agradecerá o

feedback do usuário, e fechará o Aplicativo.


Button b4;

@Override




b4 = (Button) findViewById(R.id.BTN4);

b4.setOnClickListener(sair);

}

View.OnClickListener sair = new View.OnClickListener() {

@Override


Toast toast = Toast.makeText(getApplicationContext(),"Olá,

Obrigado pelo seu FeedBack, tentaremos sempre melhorar!

Obrigado!",Toast.LENGTH_LONG);

toast.show();

Intent intent = new Intent(Intent.ACTION_MAIN);

intent.addCategory(Intent.CATEGORY_HOME);

intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);


}

};

}

61

Ao término, sua tela se parecerá com esta:

Pronto! Seu projeto está terminado, teste as várias possibilidades de resultados, ou seja:

Nota maior que 2.5 e Radio Button de FACILIDADE DO USO;

Nota maior que 2.5 e Radio Button de RAPIDEZ;

Nota maior que 2.5 e Radio Button de CLAREZA;

Nota maior que 2.5 E FEEDBACK.

62


Esta talvez será o projeto mais complexo, onde ensinaremos a realizar uma

conexão com banco de dados externo ao aplicativo, existem inúmeras maneiras de se

realizar esses passos, com diferentes bancos de dados, e programas, porém utilizaremos

métodos gratuitos, e que qualquer um pode fazer em casa.

Faremos um aplicativo de compras, onde será possível comprar, e ver suas

compras.

Teremos que criar um banco de dados para salvar essas informações.

Para isso utilizaremos um site externo.

Nosso banco de dados terá duas tabelas, uma para guardar os produtos e outra

para guardar os pedidos.

Será necessário baixar um conector que ligará o aplicativo no banco de dados.

Também será necessário adicionar permissão ao aplicativo para que ele utilize a

internet do celular (Dados móveis ou Wi-fi)

63

9.1: SITES EXTERNOS E DOWNLOADS

Para facilitar e adiantar o andamento do processo, baixaremos um projeto

já com os arquivos nos locais adequados, basta baixa-lo para iniciarmos o projeto.

https://goo.gl/3GcCM0

Caso baixe no link acima você poderá saltar para a página 65.

Mas se você quiser criar um, deverá fazer as seguintes alterações:

Colar a permissão no XML do Manifest do projeto.

<uses-permission android:name="android.permission.INTERNET" />

Adicionar na pasta “libs” (Bibliotecas) os conectores MySQL.

Baixe através deste link

https://goo.gl/oy0PL4

64

Adicionar as classes de Conexão e a classes para que possamos trocar valores

entre elas.

Você poderá baixa-los aqui:

https://goo.gl/69e7NK

https://goo.gl/69e7NK

65

9.2: FREE SQL DATA BASE

Iremos criar uma conta gratuita no site FREESQLDATABASE.

http://www.freesqldatabase.com/

Neste site faremos upload da nossa base de dados, e obteremos acesso a

ela pelo aplicativo Android.

Crie uma conta, confirme o e-mail e inicie uma DataBase.

Clique em MySQL DashBoard, selecione o País e complete o

registro.

Faça Login na conta, selecione o Local do Servidor, clique em “SAVE

LOCATION” e depois clique em “Start New Database”

http://www.freesqldatabase.com/

66

Após isso, copie o “DATABASE HOST” para a classe “DB” no Android Studio.

Ao fazer isso você receberá um e-mail, com todos os dados para entrar na sua Base de

dados, incluindo a senha.

67

this.conn =

DriverManager.getConnection("jdbc:mysql://sql10.freesqldatabase.com:33

06/sql10159921", "sql10159921", "S8Sp9Pvv1l");

OBS: Esta senha é a que você recebeu no e-mail!

Vá para a classe DB no Android e preencha com os dados que você recebeu na tela

acima, você provavelmente receberá dados diferentes desses.

Agora basta entrar no PHPMYADMIN do site

http://www.phpmyadmin.co

Usando este link, entre e logue na sua conta com os dados que você recebeu.

OBS: Esta senha é a que você recebeu no e-mail!

http://www.phpmyadmin.co/

68

Após Logar, clique em importar e escolhe o arquivo deste link:

https://goo.gl/F5gEi0

Pronto, sua base de dados já está ONLINE!!!!

https://goo.gl/F5gEi0

69

9.3: INICIANDO

Criaremos o layout inicial com dois botões, um para comprar e outro para

ver compras.

Os nome dos botões são: ‘bComprar’ e ‘bVer’.

Programaremos a tela de ver as compras que já fizemos.

Criaremos outra Activity que será chamada quando clicarmos no botão

“Ver compras”. Para isso, crie a função e declare o botão como já fizemos.

Button b1;

@Override



setContentView(R.layout.te1);

b1 = (Button)findViewById(R.id.bVer);

b1.setOnClickListener(ver);

}

View.OnClickListener ver = new View.OnClickListener() {

@Override



ac2.class);


70

}

};

A função “ver” chama a Activity2 que aqui chamamos de ac2.

Nessa Activity, teremos um campo para identificação, no qual você deverá

se identificar para ver sua última compra. Teremos o botão pesquisar, e uma caixa

de texto dando a informação, teremos também mais 3 caixas de textos que darão

informações da compra.

Nomes:

Email: (editText)

bVer2 (Button) “Avançar”

hello (TextView) “Olá”

item (TextView) “[Nome do Item]”

bVoltar2 (Button) “Voltar”

Quando a Acitivity Abrir os botões de baixo estarão invisíveis.

Declararemos eles, e colocaremos o código:

71

Button bAvan,bVol;

EditText email;

TextView nome,produto,tx1,tx2;

@Override




bAvan = (Button)findViewById(R.id.bVer2);

bAvan.setOnClickListener(pedido);

bVol = (Button)findViewById(R.id.bVoltar2);

bVol.setOnClickListener(voltar);

email = (EditText)findViewById(R.id.email);

nome = (TextView)findViewById(R.id.nome);

produto = (TextView)findViewById(R.id.produto);

tx1 = (TextView)findViewById(R.id.tx1);

tx2 = (TextView)findViewById(R.id.tx2);

tx1.setVisibility(View.VISIBLE);

email.setVisibility(View.VISIBLE);

bAvan.setVisibility(View.VISIBLE);

nome.setVisibility(View.INVISIBLE);

tx2.setVisibility(View.INVISIBLE);

produto.setVisibility(View.INVISIBLE);

bVol.setVisibility(View.INVISIBLE);

}

Programaremos agora a função de ver o pedido, teremos que usar Try e

Catch para isso. Com ‘Try’ e Catch, caso ocorra algum erro, o Catch impede que o

aplicativo se corrompa, ou feche, por exemplo: ao digitarmos um e-mail errado.

O ‘Try’ irá rodar caso tiver sucesso no código, o Catch caso não ocorra

sucesso.

72

Usaremos o seguinte código para programar a função de clique do botão:

View.OnClickListener pedido = new View.OnClickListener() {

@Override


DB db = new DB();

Toast.makeText(getApplicationContext(),email.getText(),Toast.LENGTH_LO

NG).show();

ResultSet rs = db.select("SELECT MAX(id),venda,nome FROM

`compras` where email = '"+email.getText()+"'");


email.setVisibility(View.INVISIBLE);

bAvan.setVisibility(View.INVISIBLE);

try{

rs.next();

String prod = rs.getString("venda");

String nom = rs.getString("nome");

nome.setVisibility(View.VISIBLE);


produto.setVisibility(View.VISIBLE);

bVol.setVisibility(View.VISIBLE);

produto.setText(prod);

nome.setText(nom);

if((prod == null) && (nom == null)){

Toast.makeText(getApplicationContext(),"Não foi

possível localizar uma compra com estes

dados",Toast.LENGTH_LONG).show();








}

}catch (Exception e){

Toast.makeText(getApplicationContext(),"Não foi

possível localizar uma compra com estes

dados",Toast.LENGTH_LONG).show();





73




}

}

};

Usaremos um Toast (uma mensagem que irá aparecer na tela caso não

exista pedido.

Também programaremos a função do botão voltar, que volta pra Activity1.

View.OnClickListener voltar = new View.OnClickListener() {

@Override



ac1.class);


}

};

Pronto! Já podemos ver as compras que fizermos no Aplicativo!

Tente digitar o e-mail : [email protected]

Este é um e-mail válido.

Agora tente digitar um e-mail diferente deste.

Você não achará pedido para este e-mail!

74

Agora programaremos o Botão comprar da tela inicial, criaremos a função

de clique, e iremos inserir o código:

View.OnClickListener comprar = new View.OnClickListener() {

@Override



ac3.class);


}

};

Iremos inserir na tela um “LIST VIEW”, uma lista, que receberá os produtos

que você poderá comprar,

Iremos adicionar um botão comprar também.

O Layout ficará assim:

75

Programaremos o list View, quando entrarmos nessa tela. O ListView Receberá os

dados que foram passados do Banco de dados, o usuário poderá clicar e escolher o

produto desejado, após isso o botão avançar se habilitará. Este botão enviará para classe

“Valor” o valor que o usuário escolheu, ou seja, o produto que ele escolheu. Depois

acessaremos esse valor na próxima tela, onde o usuário confirmará os dados.

public class ac3 extends AppCompatActivity {

List<String> items;

ArrayAdapter<String> adapter;

ListView lv;

String nome;

String produto;

Button b1;

DB db = new DB();

valores val = valores.getInstance();

@Override




Toast.makeText(getApplicationContext(), "Passou",

Toast.LENGTH_LONG).show();

lv = (ListView) findViewById(R.id.lv);

b1 = (Button) findViewById(R.id.bComprar);

b1.setOnClickListener(compra);


lv.setOnItemClickListener(new

AdapterView.OnItemClickListener() {

public void onItemClick(AdapterView<?> parent, View view,

int position, long id) {

Object o = lv.getItemAtPosition(position);

produto = (String) o;


}

});

items = new ArrayList<String>();

try {

ResultSet rs = db.select("SELECT nome FROM `produtos`

ORDER BY `produtos`.`id` ASC ");

while (rs.next()) {

nome = rs.getString("nome");

76

items.add(nome);

}

adapter = new

ArrayAdapter<String>(getApplicationContext(),

android.R.layout.simple_expandable_list_item_1, items);

lv.setChoiceMode(ListView.CHOICE_MODE_SINGLE);

lv.setAdapter(adapter);

} catch (Exception e) {

Toast.makeText(getApplicationContext(), "Não foi Possivel

carregar os produtos!", Toast.LENGTH_LONG).show();

}

}

View.OnClickListener compra = new View.OnClickListener() {

@Override


val.setEscolha(produto);


ac4.class);


}

};

} Em val.setEscolha, enviamos um valor para a variável em outra classe, quando

quisermos acessar tal valor basta fazer val.getEscolha. E para enviar um novo valor basta

dar val.SetEscolha.

Na classe Valores, deveremos inserir o seguinte código para funcionar:

private String escolha;

public String getEscolha() {

return escolha;

}

public void setEscolha(String escolha) {

this.escolha = escolha;

}

Pronto! Não pare por ai, caso precise de mais variável, basta seguir este modelo!

Para acessar um enviar valores numa classe basta inserir o seguinte nela:


Agora é só utilizar onde precisar!!!

77

Na quarta Activity iremos inserir no banco de dados o produto comprado, o nome

e o email, também verificaremos se o usuário deixou algum campo em branco.

Também deveremos usar a classe valores, pois iremos recuperar esses dados na

última tela.

O campo do email tem o nome “mail”.

O campo do nome tem o nome “nome”.

78


Button b1;

EditText tNome,tEmail;

DB db = new DB();


String n,m;

@Override




b1 = (Button)findViewById(R.id.bFim);

b1.setOnClickListener(fim);

tNome = (EditText)findViewById(R.id.nome);

tEmail = (EditText)findViewById(R.id.mail);

}

View.OnClickListener fim = new View.OnClickListener() {

@Override


n = ""+tNome.getText();

m = ""+tEmail.getText();

if (m != "" & n != "") {

db.execute("INSERT INTO `compras`(`id`, `nome`,

`venda`, `email`) VALUES

(null,'"+tNome.getText()+"','"+val.getEscolha()+"','"+tEmail.getText()

+"')");

val.setNom(""+tNome.getText());

val.setMail(""+tEmail.getText());


ac5.class);


}else{

Toast.makeText(getApplicationContext(), "Preencha

Todos os campos!", Toast.LENGTH_LONG).show();

}

}

};

}

79

Por fim a quinta Activity, nela apresentaremos os dados e o resultado da

compra, conteremos com TextView para realizar tal operação, um botão para terminar,

e a classe Valores, para recuperar os dados de nome, e-mail e o que foi comprado.

Utilizaremos uma última programação para preencher os TextView e um botão

para sair

Os TextView serão preenchidos por “setText”, funcionando da mesma maneira

da classe valores.

O botão abrirá a ac1 (Activity1)

80

Usaremos o código:


TextView n1,m1,v1;

Button b1;


@Override




n1 = (TextView)findViewById(R.id.n1);

m1= (TextView)findViewById(R.id.m1);

v1 = (TextView)findViewById(R.id.v1);

n1.setText("Nome: "+val.getNom());

m1.setText("E-mail: "+val.getMail());

v1.setText("Você comprou: "+val.getEscolha());

b1 = (Button)findViewById(R.id.inicia);

b1.setOnClickListener(inicia);

}

View.OnClickListener inicia = new View.OnClickListener() {

@Override



ac1.class);


}

};

}

81

Pronto! Você chegou ao fim do terceiro projeto! Teste todas as funcionalidades do

aplicativo!!

Tela Inicial Tela para escolher o produto

82

Tela para inserir os dados Tela Final

83

Mensagem de Erro caso algum campo seja deixado em Branco

https://goo.gl/3GcCM0

No link acima poderemos baixar projeto finalizado!

84

9.4: EXPORTANDO APK

Antes de terminar a apostila, mostrarei como exportar o aplicativo para que ele

seja usado em um smartphone Android.

No Android Studio, clique em Build, e espera a mensagem aparecer no canto

superior direito da tela:

Clique em ‘Show in Explorer’.

O Aplicativo com nome menor é o que você projetou!

Você poderá alterar o nome do aplicativo apenas renomeando este arquivo.apk

para o nome que desejar!

85

10: CONSIDERAÇÕES FINAIS

Agradeço a todos que acompanharam a apostila e puderam alcançar um pouco

de conhecimento a partir dela. Não se prenda apenas ao básico, não ache que você não

dará conta, todos somos inteligentes e capazes para estar realizando os nossos sonhos.

Persista e Batalhe! Caso você tenha ficado com alguma dúvida no decorrer da apostila,

poderá me contatar através de meu endereço de e-mail: [email protected].

Espero que o objetivo da apostila seja minimamente alcançado, mesmo não

sendo um grande livro com milhões de cópias vendidas, ela foi feita com o mesmo carinho

e dedicação de todos os livros que hoje estão no ápice das vendas.

“A única certeza da vida, é que ela sempre termina em morte. Não viva sem força

de vontade, não se desincentive, sonhe alto, mas com os pés no chão, aprecie e faça cada

momento valer a pena para no final ser majestoso o resultado de todos os seus esforços”

Mateus Felipe, 2017.

“O futuro pertence àqueles que acreditam na beleza de seus sonhos. ”

Eleanor Roosevelt

“Tudo o que um sonho precisa para ser realizado é alguém que acredite que ele possa

ser realizado. ”

Roberto Shinyashiki

mailto:[email protected]

https://pensador.uol.com.br/autor/eleanor_roosevelt/

2016/2017 - eventos caf | campus ufv...

Documents