View
3.274
Download
0
Category
Preview:
DESCRIPTION
Trabalho de Conclusão de Curso Marcador para Jogo de Pontinho em Android
Citation preview
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 1/46
UNIVERSIDADE DO OESTE DE SANTA CATARINA
UNOESC CAMPUS DE XANXERÊ
DOUGLAS MENDES CORSO
PONTINHO MANAGER: APLICATIVO EM ANDROID PARA GERENCIAMENTODO JOGO DE CARTAS “PONTINHO”
XANXERÊ2011
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 2/46
1
DOUGLAS MENDES CORSO
PONTINHO MANAGER: APLICATIVO EM ANDROID PARA GERENCIAMENTODO JOGO DE CARTAS “PONTINHO”
Monografia apresentada ao Curso deTecnologia em Análise e Desenvolvimentode Sistemas da Unoesc Campus deXanxerê, como requisito parcial paraobtenção do título de Tecnólogo em Análisee Desenvolvimento de Sistemas.
Orientador: Maurício Berté
Xanxerê
2011
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 3/46
2
DOUGLAS MENDES CORSO
PONTINHO MANAGER: APLICATIVO EM ANDROID PARA GERENCIAMENTODO JOGO DE CARTAS “PONTINHO”
Monografia apresentada ao Curso deTecnologia em Análise e Desenvolvimentode Sistemas da Unoesc Campus deXanxerê, como requisito parcial paraobtenção do título de Tecnólogo em Análisee Desenvolvimento de Sistemas.
Orientador: Maurício Berté
Aprovado em ...... de ......................... de 2011.
BANCA EXAMINADORA
_________________________________________ Maurício Berté
________________________________________ André Luiz Forchesatto
_________________________________________ Cristiano Agosti
_________________________________________ Rosicler Felippi Puerari
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 4/46
3
“Mas não basta pra ser livre, ser forte,
aguerrido e bravo; povo que não tem virtude
acaba por ser escravo.” (Francisco Pinto da
Fontoura)
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 5/46
4
AGRADECIMENTOS
Este trabalho é dedicado a Deus.
Dedicado à minha família, principalmente aos meus pais, pela minha base
e por toda a minha educação.
Dedicado aos meus professores, por terem me ensinado e compartilhado
suas sabedorias.
Dedicado ao orientador Maurício e à coordenadora Rosicler, por toda a
ajuda e contribuição nesta jornada.
Em especial, é dedicado à minha namorada Bruna, por ter me
proporcionado seu tempo, sempre estando ao meu lado, me dando forças, me
apoiando, sendo a chave essencial de toda esta conquista. Bruna, dedico a você
não só este trabalho, mas também o meu coração, eu te amo.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 6/46
5
RESUMO
Através de um jogo de cartas chamado ‘Pontinho’ , surgiu a necessidade de
automatizar, agilizar e tornar o marcador deste jogo mais interativo, levando em
consideração o indício de erros quando a anotação do placar é realizado de
forma manual e sabendo da grande quantidade de pessoas que aprecia o jogo
Pontinho, por uma questão de cultura e lazer. Motivado por esse desafio,
pensando na flexibilidade da recente e poderosa plataforma Android , ciente do
enorme crescimento e evolução do mercado tecnológico, surgiu a oportunidade
de desenvolver o aplicativo ‘Pontinho Manager 1’ , escrito especialmente para
dispositivos móveis, buscando poupar a utilização de papel, evitando não só o
impacto ambiental, mas também qualquer tipo de falha na contagem de saldo e
pontos.
Palavras-chave: Android. Jogo. Pontinho. Celular.
1 Do inglês, significa „gerenciador‟.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 7/46
6
ABSTRACT
Through a card game called „Pontinho‟, it faced the need to automate, s treamline
and make this game more interactive marker, taking into account the sign of thetaking notes errors when the score is performed manually and knowing the large
amount of people who like the game called „Pontinho‟ as a matter of culture and
leisure. Motivated by this challenge, flexibility in mind the recent and powerful
Android platform, aware of the enormous growth and evolution of the technology
market, the opportunity arose to develop application „Pontinho Manager‟, written
especially for mobile devices, trying to save paper usage, avoiding not only the
environmental impact but also any failure to balance and count points.Keywords: Android. Game. Pontinho. Mobile.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 8/46
7
SUMÁRIO
1 – INTRODUÇÃO ..................................................................................................8
1.1 – TEMA ............................................................................................................. 9
1.2 – PROBLEMA ................................................................................................... 9
1.3 – OBJETIVOS ................................................................................................. 10
1.3.1 – Objetivo Geral ..........................................................................................10
1.3.2 – Objetivos Específicos .............................................................................10
1.4 – JUSTIFICATIVA ........................................................................................... 10
2 – REFERENCIAIS TEÓRICOS .......................................................................... 12
2.1 – JOGOS DE CARTAS ........................................................................... 12
2.1.1 – Pontinho .......................................................................................... 12
2.1.1.1 – Contagem dos pontos ............................................................................ 13
2.1.1.2 – Sistema de valores ................................................................................. 13
2.1.1.3 – Sistema de placar ................................................................................... 14
2.2 – GOOGLE ANDROID .................................................................................... 14
2.2.1 – Android Market ........................................................................................ 15
2.2.2 – Android SDK ............................................................................................ 16
2.3 – ECLIPSE ...................................................................................................... 17
2.4 – BANCO DE DADOS SQLITE ....................................................................... 17
2.5 – JAVA, LINGUAGEM DE PROGRAMAÇÃO ................................................. 18
3 – METOLOGIA ........................................................................................... 20
4 – DESENVOLVIMENTO ............................................................................. 21
5 – CONSIDERAÇÕES FINAIS ............................................................................ 44
REFERÊNCIAS ............................................................................................ 45
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 9/46
8
1 – INTRODUÇÃO
O conteúdo desse trabalho apresenta o desenvolvimento de um aplicativo
para dispositivos móveis, chamado ‘Pontinho Manager’ , que tem como função a
administração de pontos, tal como saldo de um jogo de cartas conhecido como
‘Pontinho’ .
Segundo Huizinga (1938), jogo é uma atividade voluntária exercida dentro
de certos e determinados limites de tempo e espaço, segundo regras livremente
consentidas, mas absolutamente obrigatórias, dotado de um fim em si mesmo,
acompanhado de um sentimento de tensão e alegria e de uma consciência de ser
diferente da vida cotidiana.
Hoje em dia, muitas pessoas buscam jogos como meio de diversão e
entretenimento, em função disso, o objetivo do projeto tem como princípio
preservar o jogo em sua forma natural, estimulando o convívio social entre
pessoas, porém, com uma contagem de valores extremamente dinâmica e
inovadora.
Com um crescente número de usuários de jogos, e principalmente de
aparelhos móveis, criou-se uma oportunidade para um aplicativo diferenciado,
que favorece a interação de pessoas e a integração com o jogo Pontinho em
momentos de lazer.
O aplicativo será destinado ao público jovem e adulto, na faixa de 18 a 30
anos, de classe social média e média-alta. São consumidores que buscam jogos
e o convívio social como forma de lazer e diversão e estão em constante contato
com a internet e novas tecnologias.
O aplicativo Pontinho Manager estará disponível ao público de forma
gratuita e seu uso visa estabelecimentos comerciais e residenciais, tais como
clubes sociais, bares e ambientes específicos para jogos em ambientes internos.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 10/46
9
1.1 TEMA
Desenvolvimento de um aplicativo para a plataforma Android , compatível
com diversos celulares e tablets 2 , com o objetivo de administrar uma partida de
„Pontinho‟.
1.2 PROBLEMA
O primeiro desafio, o qual gerou a ideia de criar um marcador de pontos
como aplicativo para celular, foi a desordem na contagem de pontos feitos à mão,
um método comum usado em jogos de cartas que exigem um marcador.
O jogo Pontinho tem um sistema de valores incluso na contagem de
pontos, o que faz com que seja um pouco mais complexo e necessite de um
método mais eficaz e que anule ao máximo qualquer erro de contagem. Por
causa disso, surgiu a necessidade de criar um aplicativo que servisse para a
soma automática de pontos, facilitando aos jogadores a não desviarem a atenção
do jogo ou desperdiçarem tempo entre uma rodada e outra para realizar a
contagem dos pontos manualmente.
Atualmente a tecnologia nesses aparelhos possibilita sua ampla utilidade,
grande parte – os conhecidos smartphones 3 – podem ser considerados
praticamente como um computador de bolso. Além disso, foi percebido que em
rodas de amigos, é muito comum que um ou mais indivíduos possuam aparelho
compatível para a instalação desse tipo de aplicativo, além de ser um objeto
pessoal, com facilidade de acesso.
Durante o desenvolvimento do aplicativo, foram necessárias adaptações
tanto no uso do software 4 utilizado, quanto na linguagem de programação. O
terceiro desafio considerado foi, então, a implantação de um banco de dados para
o armazenamento de informações de dados do jogo, haja vista que tornaria o
projeto ainda mais complexo.
2 Tablet é um dispositivo móvel em forma de prancheta.3 Telefone celular com funcionalidades mais avançadas.4 Do inglês, consiste em um programa para computador, celular, tablet, etc.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 11/46
10
1.3 OBJETIVOS
1.3.1 – Objetivo Geral
Desenvolver um aplicativo para celular e/ou tablet , compatível com a
plataforma Android , para o controle do placar de uma partida de Pontinho.
1.3.2 – Objetivos Específicos
Criar um aplicativo para Android , interativo, de fácil manuseio e
entendimento
Através de arquivo ‘xml’ , desenvolver o layout claro e objetivo para
interação com o usuário
Detalhar funcionamento do aplicativo através de instruções
Conforme regra do jogo, limitar o aplicativo para o mínimo de três e
máximo de oito jogadores
Receber pontuação de cada jogador em cada rodada da partida, fazer a
somatória dos pontos e apresentá-los atualizados
Calcular e apresentar o saldo de cada jogador
Encerrar a partida, trazendo o vencedor
1.4 – JUSTIFICATIVA
O Pontinho Manager , primeiramente surgiu da necessidade de um grupo
de pessoas, que rotineiramente jogava Pontinho como forma de descontração e
utilizava de papel e caneta para anotação de placar. Foi aí que surgiu a ideia de
automatizar a contagem dos pontos, tal como o saldo de cada jogador, buscando
evitar o desperdício de papel, reduzindo o impacto ambiental, sem contar na
praticidade nos cálculos com o uso do aplicativo.
O Pontinho, muito apreciado e conhecido na região Oeste do Estado de
Santa Catarina, regionalmente possui um sistema de apostas, no qual delimita-se
valores para a compra (entrar na partida), recompra (para retornar à partida se
caso atingir 100 pontos ou mais) e batidinha (para o jogador que bater, receber
este valor de cada adversário, exceto daquele(s) que bater(em) pela mesma
carta). Desta forma, esse sistema de apostas, um pouco complexo, acabava
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 12/46
11
gerando certas dificuldades ao final da partida, para determinar o saldo de crédito
ou débito dos jogadores. Baseado nisso, o aplicativo Pontinho Manager é
capacitado para, de forma dinâmica, apresentar esses valores em tempo real,
sem falar na redução a zero de qualquer tipo de falha.
Buscando a mobilidade, algumas plataformas para o desenvolvimento do
aplicativo foram avaliadas. Chegou-se à conclusão de que o Google Android
(criado especialmente para dispositivos móveis) seria o mais apropriado, levando
em consideração os custos, benefícios e a total flexibilidade, tornando mais fácil a
distribuição e o acesso ao aplicativo. Em virtude disso, o Pontinho Manager foi
inteiramente produzido para ser compatível com a versão 2.2 do Android . A
escolha desta versão foi devida à sua robustez, tal como, pela grande quantidade
de celulares e tablets compatíveis com ela, pois, segundo o site de notícias Terra,
até março deste ano, a versão conhecida como Froyo estaria presente em 61,3%
de dispositivos móveis que utilizam o sistema Android .
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 13/46
12
2 – REFERENCIAIS TEÓRICOS
2.1 – JOGOS DE CARTAS
Foi em meados do século XIV que as cartas de jogar difundiram-se pela
Europa e só a partir do século XVI que ficaram conhecidas em todo o mundo.
O grande atrativo do baralho é sua adaptabilidade, podendo ser jogado de
inúmeras formas. Os jogos podem ser simples, indicados para crianças (rouba
monte, burro, mico, etc) ou jogos com maior nível de dificuldade, como pontinho,
buraco, bridge (este considerado o xadrez dos jogos de cartas) pôquer, truco, etc.
Independente do material do baralho (pode ser de papelão ou plástico) é inegável
a sua versatilidade. O formato é mundialmente conhecido: 52 cartas retangulares,
com o verso igual. A combinação destas cartas, normalmente em sequências, cria
as possibilidades dos diversos jogos. (HISTÓRIA, 2007)
2.1.1 – Pontinho
Pontinho é um jogo semelhante ao Pif, onde se utilizam dois baralhos de
52 cartas cada, com a remoção dos curingas, totalizando 104 cartas.
Após o baralho estar embaralhado, o distribuidor de cartas passa o baralho
para o jogador à sua esquerda, para que este faça o corte e vire a carta debaixo,
descobrindo assim o Curinga. O Curinga passa a ser a carta de mesmo número
da descoberta, porém, com o naipe de cor contrária. São distribuídas nove cartas
para cada membro da partida.
O jogador à direita do distribuidor deverá começar a partida, ou fazendo
uso da carta virada, ou pescando uma carta do monte. Ao optar por fazer uso da
carta virada, o jogador deverá descer um jogo na mesa, fazendo uma sequência
de três ou mais cartas.
Ao passar a vez, o jogador deverá descartar uma carta no lixo, não
podendo ser Curinga, nem carta colocada. O jogador à sua direita continua a
partida, pescando ou fazendo uso da carta do lixo. Para bater, todos os jogadores
poderão juntar a carta do lixo, não necessariamente respeitando a ordem. A
ordem apenas influenciará se dois ou mais jogadores baterem ao mesmo tempo,o que implica para que seja creditado o valor da Batidinha apenas para o primeiro
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 14/46
13
jogador, os demais que baterem, apenas deixarão de debitar o valor da Batidinha
e também não receberão pontos.
Diferente do Pif, no jogo de Pontinho é possível descer cartas nos jogos
dos adversários ou queimar uma carta, quando esta é repetida a alguma carta de
alguma trinca que está na mesa. Também é permitido baixar jogos de três ou
mais cartas, lembrando-se que o Curinga, quando não estiver no seu lugar, não
pode ser usado em trinca, e exceto ao bater, deverá estar sempre enforcado,
nunca nas pontas.
Se algum jogador possuir uma carta que seja substituta do Curinga
presente em algum jogo, poderá substituir o Curinga apenas se fizer uso dele.
O objetivo do jogo é livrar-se de todas as cartas da mão, com o intuito de
se desfazer da maior quantidade de pontos.
2.1.1.1 – Contagem dos pontos
Exceto o jogador ou os jogadores que baterem, cada jogador recebe a
soma das cartas que sobrarem em sua mão, sendo que o Curinga vale 20 pontos,
o Ás vale 15 pontos, cada figura vale 10 pontos, e da carta número 2 ao número
10, equivale o seu devido valor. Vale lembrar-se da exceção do Ás, que quando
sozinho na mão, equivale a apenas 1 ponto.
Permanece no jogo todo o jogador que fizer menos de 100 pontos. Para
aquele jogador que atingir mais de 100 pontos e estourar, lhe é permitido retornar
ao jogo com a mesma quantidade de pontos do jogador que mais tiver pontos na
partida.
A partida só termina quando sobrar apenas 1 jogador com menos de 100
pontos.
2.1.1.2 – Sistema de valores
O jogo de Pontinho possui um sistema de valores, no qual são combinados
o valor da Compra, que serve para ingressar na partida; o valor da Recompra,
para aquele jogador que atingir 100 pontos ou mais retornar à partida; e o valor da
Batidinha, para que aquele jogador que bater, receba este valor de cadaadversário, exceto daqueles que baterem pela mesma carta.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 15/46
14
2.1.1.3 – Sistema de placar
A figura abaixo serve para exemplificar o método utilizado no placar da
partida, juntamente com o sistema de valores.
Figura 1: Esboço de uma anotação de placar de Pontinho
I- Somatória do placar geral da partida.
II- Débito e crédito dos jogadores.
III-Marcação da primeira rodada.
IV-Marcação da segunda rodada.
2.2 – GOOGLE ANDROID
Android é uma plataforma de desenvolvimento para aplicativos móveis,
gerada através de uma grande evolução tecnológica, com um ambiente de
trabalho bastante arrojado e flexível. Quando lançada, causou grande impacto
para os usuários de telefonia móvel, atraindo a atenção não só destes, mas
também dos que vieram a ter conhecimento sobre esta revolução na tecnologia
móvel. Isso se deu porque por trás dele está a empresa revolucionária da internet
– a Google -, como também outras empresas líderes no mercado de telefonia:
Samsung , Sony Ericsson , LG , Toshiba , Motorola e muitas outras. Esse grupo,
denominado Open Handset Alliance (OHA) foi criado justamente com o intuito de
padronizar uma plataforma livre para celulares, de código aberto, para superar e
atender as expectativas e tendências do mercado, que fosse moderna e flexível
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 16/46
15
para a criação de aplicativos corporativos, entretanto, foi aí que surgiu o Android .
(LECHETA, 2009)
As funcionalidades e recursos do Android são realmente impressionantes,
desde uma perfeita resolução de jogos, até o reconhecimento de código de
barras. Além disso, o Android traz mais um benefício, a linguagem de
programação Java , bastante prática e conhecida, o que facilita e muito para os
desenvolvedores de aplicações.
O Android chama atenção principalmente no sentido de a plataforma ser
totalmente livre, possuir um código aberto, permitindo aos fabricantes fazerem
alterações no código-fonte, podendo deixar seus produtos customizados, e o que
de certa forma é inusitado: não há custo.
Os fabricantes não precisam divulgar as alterações a ninguém, nem sequer
pagar algo por isso. Possuir o código aberto traz ao Android aperfeiçoamentos a
cada versão, uma vez que desenvolvedores do mundo inteiro podem fazer
alterações, realizando melhorias, trazendo novos recursos, ou o fato importante
de corrigir possíveis falhas.
Outra vantagem do sistema, é que a plataforma é baseada em Linux ,
sendo que ele mesmo gerencia a memória, tal como os processos, permitindo
que mais de uma aplicação seja executada ao mesmo tempo.
Desenvolver para Android necessita de conhecimento da linguagem Java ,
como também de xml para a criação das telas, porém, não é necessário possuir
um smartphone nem sequer um tablet , pois os testes são fielmente realizados
através de um emulador que acompanha o kit de desenvolvimento da Google.
2.2.1 – Android Market
Da mesma forma que a Apple App Store 5 , a Google lançou o Android
Market 6 , como forma de divulgação da plataforma Android , e é claro, para o
auxílio na distribuição de aplicativos desenvolvidos para Android .
A intenção do site é disponibilizar aos desenvolvedores um local para
concentrar todos os aplicativos criados para Android e, sem qualquer restrição, é
5 Loja de aplicativos da empresa Apple.6 Mercado de aplicativos da Google.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 17/46
16
possível publicar qualquer aplicativo mediante cadastro, semelhante ao site You
Tube , possuindo inclusive sistema de classificação e comentários.
O único impasse é de que o desenvolvedor necessita pagar uma taxa de
25 dólares para enviar seu aplicativo ao mercado, porém, a vantagem é de que
70% dos lucros com os aplicativos vendidos são entregues ao seu criador.
Já aos usuários, apenas é necessário acessar o Android Market via celular
ou tablet , fazer a escolha do aplicativo e assim baixá-lo para seu dispositivo.
(LECHETA, 2009)
2.2.2 – ANDROID SDK
Para conseguir desenvolver aplicativos para Android , é totalmente
necessária a instalação do Android SDK 7 . A ferramenta é fornecida gratuitamente
pela Google e possui todas as bibliotecas para o entrosamento com a linguagem
Java , trazendo as classes responsáveis para a criação das aplicações. O SDK
conta também com um emulador, chamado de AVD 8 Manager , o que facilita e
muito para testar os aplicativos, pois não é necessário possuir aparelho com o
sistema operacional Android , o próprio emulador faz esse papel, pois é idêntico a
um celular, com todos os recursos.
No mesmo kit, existe um plugin chamado ADT 9 (Android Development
Tools ), o qual faz com que o emulador seja executado automaticamente através
do próprio Eclipse .
As aplicações Android constituem-se em um arquivo de extensão .apk , e
da mesma forma que um aparelho celular ou tablet , é necessário instalar esse
arquivo também no emulador, portanto, outra vantagem é de que o próprio
plugin 10 se encarrega de fazer essa instalação.
7 Kit de desenvolvimento de software.8 Emulador de Dispositivo Móvel do Android.9 Ferramentas de Desenvolvimento do Android.10 Programa utilizado para adicionar funcionalidades a outros programas maiores.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 18/46
17
2.3 – ECLIPSE
Eclipse é uma ferramenta escrita em Java , de desenvolvimento integrado
(IDE), patrocinado pela IBM , que fornece um ambiente para desenvolvimento de
aplicações em Java , C++ e diversas outras linguagens de programação.
Porém, o Eclipse não limita-se apenas em suportar variadas linguagens de
programação, sendo compatível com ferramentas para controle de versão como o
CVS 11, e pode executar internamente servidores web ou servidores de aplicações
para a depuração de objetos distribuídos. (ECLIPSE, 2002)
O Eclipse foi adotado pela Google para ser o principal ambiente de
desenvolvimento para Android , facilitando não só no desenvolvimento, como
também nos testes e inclusive na compilação do projeto.
Com a utilização do plugin ADT , fornecido pela Google, é possível executar
o emulador do Android através do próprio Eclipse , podendo usufruir de todos os
recursos do dispositivo virtual. (LECHETA, 2009)
2.4 – BANCO DE DADOS SQLITE
Quando é desenvolvida uma aplicação, um dos fatores fundamentais que
deve ser levado em consideração é o armazenamento de dados. Sem ele, os
dados são perdidos após a execução do programa, ficando disponíveis apenas
durante o tempo de execução.
Antigamente, o armazenamento era feito em sistemas de arquivosdo sistema operacional, resultando numa complexidadedesnecessária e que não fazia parte das regras de negócio da
aplicação, prejudicando a produtividade dos desenvolvedores.(SQLITE, 2011)
A plataforma Android , além de uma série de recursos e facilidades, trouxe
suporte nativo ao SQLite , um banco de dados baseado em SQL12 (Structured
Query Language ), considerado uma biblioteca muito influente e poderosa, que
pode controlar diversos bancos de dados que contenham diversas tabelas.
11 Sistema de versões concorrentes. 12 Linguagem de consulta estruturada.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 19/46
18
O desenvolvedor tem a flexibilidade de criar o banco de dados e as tabelas,
como também ter o controle sobre os dados através de comandos DDL13 (Data
Definition Language ) e DML14 (Data Manipulation Language ) do SQL padrão.
Esse mecanismo é capaz de aumentar a produtividade, tendo em vista que os
serviços para resguardar os dados são ministrados pelo SQLite , permitindo que
seus usuários não precisem fornecer seus dados a cada execução do programa.
(SQLite, 2011)
No Android , o banco de dados pode ser criado de diferentes maneiras,
porém, a mais recomendada é utilizar a API do Android para o SQLite , ou seja,
fazê-lo via programação, para que a própria aplicação crie o banco de dados de
forma automatizada. (LECHETA, 2009)
Vale salientar que o banco de dados do celular é persistente, ou seja, os
mesmos dados permanecerão no banco mesmo após novas instalações do
aplicativo, até mesmo porque o sistema entende que as futuras instalações são
apenas atualizações, mantendo assim os dados antigos. Para os fins de criar
novamente o banco de dados, é necessário que primeiramente seja feita a
remoção do aplicativo, para posteriormente instalá-lo novamente no dispositivo.
2.5 – JAVA, LINGUAGEM DE PROGRAMAÇÃO
Java constitui-se em uma linguagem de programação orientada a objetos
que possui um programa para execução conhecido como máquina virtual ou
virtual machine .
A tecnologia começou a ser desenvolvida no ano de 1991 através de um
projeto chamado de Green Project , porém foi só em maio de 1995 que a
linguagem Java passou a ser oficialmente lançada na SunWorldExpo 95 . Com afé da Netscape em investir no projeto, possibilitando o desenvolvimento de
aplicativos Java , integrados ao seu navegador, que a linguagem passou a
avançar muito.
Hoje, Java consiste em uma das linguagens mais utilizadas no planeta,
possuindo um dos maiores repositórios de projetos de código-aberto do mundo, o
java.net . Por questão de sua portabilidade, ao ser programado apenas uma vez, o
13 Linguagem de definição de dados.
14 Linguagem de manipulação de dados.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 20/46
19
aplicativo Java é capaz de rodar em qualquer tipo de aplicação, entre elas:
aplicativos móveis, jogos, web 15 , servidores, desktop 16 , etc. (JAVA, 2009)
Com o surgimento do Android , Java passou a ser sua principal linguagem
de programação, facilitando e muito o entendimento para a maioria dos
desenvolvedores, e influenciando também na expansão da linguagem.
15 Rede de alcance mundial.16 Computador de mesa.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 21/46
20
3 – METODOLOGIA
Como já sabemos, o objetivo deste trabalho é demonstrar o
desenvolvimento de um aplicativo para a administração de uma partida de
Pontinho, que de forma objetiva, controle os pontos, juntamente com o saldo dos
jogadores.
De tal forma, o aplicativo foi desenvolvido especialmente para a plataforma
Android , que possui código aberto, tal como ambiente de desenvolvimento,
bibliotecas e emulador para teste totalmente grátis, sem contar que o aplicativo
pode ser utilizado sem restrições em celulares e tablets configurados com a
versão 2.2 do Android . O sistema possui inclusive um banco de dados nativo (o
que facilita o armazenamento de dados) chamado de SQLite . Portanto, o
desenvolvimento foi feito utilizando o ambiente de desenvolvimento Eclipse , em
conjunto com as bibliotecas Android SDK e emulador para teste Avd Manager ,
ambos para Eclipse .
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 22/46
21
4 – DESENVOLVIMENTO
O primeiro passo para começar a desenvolver para Android é configurar o
ambiente de desenvolvimento. Para executar esta etapa, existem diversos
tutoriais espalhados pela internet , como por exemplo, o tutorial encontrado no site
MobileIn , disponível no seguinte endereço: http://mobilein.com.br/?p=14.
A primeira etapa para o desenvolvimento do aplicativo Pontinho Manager
será criar um novo projeto Android , para isso, no Eclipse , clicar em File > New >
Android Project , conforme a Figura 2.
Figura 2: Eclipse IDE , dando início a um novo projeto Android
Feito isso, na próxima tela (Figura 3) deveremos colocar o nome do projeto,
que será ‘ PontinhoManager ’ . Escolheremos a versão do Android , que será a
Android 2.2 . Será necessário criar uma package , nomeada de ‘ pontinho.manager ’.
Deixaremos selecionado ‘ Create Activity ’ com o intuito de criar uma Activity 17
principal e, nomear essa Activity , que no nosso caso será chamada de ‘ Main ’ . Por
último, clicar em Finish .
17 Classe da linguagem Java que define a tela que irá interagir com o usuário.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 23/46
22
Figura 3: Eclipse IDE , finalizando a criação de um novo projeto Android
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 24/46
23
A primeira etapa do projeto será criar a tela principal do aplicativo, a qual
deverá receber as intenções do usuário, através de determinadas opções,
disponibilizadas em cinco botões, sendo eles:
Nova Partida: responsável por iniciar o controle de uma nova partida.
Apostas: levará o usuário para configurar os valores das Apostas, ou seja,
os valores da Compra, da Recompra, e da Batidinha.
Instruções: mostrará ao usuário as instruções de utilização do aplicativo.
Sobre: informações sobre a autoria do projeto.
Sair: responsável apenas para finalizar o aplicativo.
Para a criação deste menu (Figura 4), primeiramente foi necessário editar o
arquivo de layout 18 ‘main.xml’.
Figura 4: Menu principal do Pontinho Manager
18 Desenho e formato da tela que aparecerá para o usuário.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 25/46
24
Sendo assim, no arquivo ‘ /res/layout/main.xml ‟ (Quadro1) temos as
seguintes informações:
<Button android:id="@+id/btNovaPartida" android:layout_width="fill_parent"
android:layout_height="wrap_content" android:text="Nova Partida" /> <Button android:id="@+id/btAposta" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Apostas" />
<Button android:id="@+id/btInstrucoes" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Instruções" />
<Button android:id="@+id/btSobre" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Sobre" />
<Button android:id="@+id/btSair" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Sair" />
Quadro 1: Arquivo de layout ‘main.xml’
Para que esta tela seja apresentada para o usuário, é necessário criar a Activity ‘Main.java’ (Quadro 2), classe que fará comunicação com o arquivo xml e
apresentará o menu para o usuário.
Desta forma, no arquivo ‘ src/pontinho.manager/Main.java ’ temos:
(...)//chama o arquivo de layout xml setContentView(R.layout. main);
//faz a ligação com o arquivo de layout, trazendo os botões para a tela View btNovaPartida = findViewById(R.id.btNovaPartida);btNovaPartida.setOnClickListener(this);View btAposta = findViewById(R.id.btAposta);btAposta.setOnClickListener(this);View btInstrucoes = findViewById(R.id.btInstrucoes);btInstrucoes.setOnClickListener(this);View btSobre = findViewById(R.id.btSobre);btSobre.setOnClickListener(this);View btSair = findViewById(R.id.btSair);btSair.setOnClickListener(this);
Quadro 2: Exibição dos botões na classe ‘ Main.java ’
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 26/46
25
Agora precisamos informar para cada botão, qual será a intenção do
usuário, para isso temos as Intents 19 (Quadro 3):
//ações para o clique de cada botão
public void onClick(View v) {switch (v.getId()) {case R.id.btNovaPartida:
Intent novaPartida = new Intent (this,NovaPartidaActivity.class);startActivity(novaPartida);break;
case R.id.btAposta:Intent aposta = new Intent(this, ApostaActivity.class);startActivity(aposta);break;
case R.id.btInstrucoes:Intent instrucoes = new Intent(this, Instrucoes.class);startActivity(instrucoes);
break;case R.id.btSobre:
Intent sobre = new Intent(this, Sobre.class);startActivity(sobre);break;
case R.id.btSair:android.os.Process.killProcess(android.os.Process. myPid ());break;
(...)
Quadro 3: Intenções dos botões, correspondente à classe ‘Main.java’
Vamos para a ação do botão ‘Sair’ , responsável apenas para finalizar oaplicativo. Neste caso utilizamos o seguinte comando:
android.os.Process.killProcess(android.os.Process.myPid());
Poderíamos utilizar também o comando super.finish(); que a princípio
teria a mesma função, porém este último não finaliza o processo.
Agora vamos para o objetivo do botão ‘Sobre’ , que apenas apresentará ao
usuário as informações sobre a autoria do projeto (Figura 5).
Para isso temos o arquivo „sobre.xml’ (Quadro 4), responsável pelo layout .
19 São as intenções do usuário. Comandos enviados ao sistema operacional Android para realizar alguma ação.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 27/46
26
Figura 5: Texto sobre a autoria do aplicativo
No arquivo ‘ res/layout/sobre.xml ’ (Quadro 4) teremos apenas um
TextView 20 que conterá as informações sobre a autoria em forma de texto:
<TextView android:id="@+id/sobre_conteudo" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Aplicativo desenvolvido por Douglas Mendes Corso,graduando no curso de Tecnologia em Análise e Desenvolvimento de Sistemas, na Universidade do Oeste de Santa
Catarina - Campus de Xanxerê, sob orientação do Prof. MaurícioBerté." />
Quadro 4: Arquivo de layout ‘sobre.xml’
Agora teremos que editar a classe que será responsável por exibir a tela aousuário. Este arquivo somente irá chamar o layout , visualizando o arquivo
‘sobre.xml’ (Quadro 5). Para isso, na classe ‘ src/pontinho.manager/Sobre.java ’
temos:
(...)setContentView (R.layout.sobre);(...)
Quadro 5: Classe Activity ‘Sobre.java’
20 Classe utilizada para exibir um texto na tela.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 28/46
27
Desta vez é necessário configurar o arquivo ‘ AndroidManifest.xml ’ (Quadro
6) situado na raiz do projeto. Neste arquivo é obrigatório informar todas as
Activities contidas no aplicativo, e também, através dele, é possível declarar o
formato de apresentação do layout, através do comando ‘theme’ :
<activity android:name=".Sobre" android:label="@string/sobre" android:theme="@android:style/Theme.Dialog"></activity>
Quadro 6: Declaração da Activity ‘Sobre.java’ no „ AndroidManisfest.xml’
Agora vamos para ação do botão ‘Instruções’ , que apenas apresentará
para o usuário, um texto que contém as instruções de uso do aplicativo.
Para isso temos o arquivo ‘ instrucoes.xml ’ (Quadro 7), responsável pelo
layout . Neste arquivo apenas teremos um TextView que conterá as instruções em
forma de texto:
<TextView android:id="@+id/instrucoes_conteudo" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Ao primeiro uso do aplicativo, será necessário configurar
os valores das Apostas, para isso volte ao menu principal e selecione a opção
'Apostas'. Informe os novos valores e clique em 'Salvar'. Configurados osvalores, selecione a opção 'Nova Partida', que o levará a próxima tela, na qual
você deverá informar..." />
Quadro 7: Arquivo de layout ‘instrucoes.xml’
Agora teremos que editar a classe que é responsável por exibir a
mensagem ao usuário. Este arquivo, da mesma forma que a classe ‘Sobre.java’
somente irá chamar o layout , visualizando o arquivo ‘instrucoes.xml’ . Para isso, na
classe ‘ src/pontinho.manager/Instrucoes.java ’ (Quadro 8) temos:
(...)setContentView (R.layout.instrucoes);(...)
Quadro 8: Classe Activity ‘Instrucoes.java’
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 29/46
28
É necessário também declarar a Activity ‘Instrucoes’ no arquivo de
manifesto. Para isso, no arquivo ‘ AndroidManifest.xml ’ (Quadro 9), informamos:
<activity android:name=".Instrucoes" android:label="@string/instrucoes" android:theme="@android:style/Theme.Dialog"></activity>
Quadro 9: Declaração da Activity ‘ Instrucoes .java’ no „ AndroidManisfest.xml’
Com determinadas configurações, deveremos visualizar a tela da seguinte
forma:
Figura 6: Tela de instruções do aplicativo.
Desta vez, vamos ao botão ‘Apostas’ , responsável por levar o usuário à
tela de cadastro dos valores da Compra, Recompra e Batidinha (Figura 7). Ambos
os valores serão gravados em banco de dados.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 30/46
29
Figura 7: Tela de configuração das apostas
Para esta intenção, temos o arquivo de layout que conterá três campos
para que o usuário informe os valores; e o botão ‘Salvar’ , responsável por gravar
os valores no banco de dados. Desta forma, no arquivo ‘ res/layout/aposta.xml ’
temos:
<TextView android:layout_width="wrap_content" android:textAppearance="?android:attr/textAppearanceMedium" android:text="Compra:" android:id="@+id/tvCompra" android:layout_height="wrap_content"></TextView>
<EditText android:id="@+id/etCompra" android:layout_width="match_parent" android:layout_height="wrap_content" android:inputType="number"> <requestFocus></requestFocus>
</EditText> <TextView android:layout_width="wrap_content"
android:textAppearance="?android:attr/textAppearanceMedium" android:text="Recompra:" android:id="@+id/tvRecompra" android:layout_height="wrap_content"></TextView>
<EditText android:id="@+id/etRecompra" android:layout_width="match_parent" android:layout_height="wrap_content" android:inputType="numberDecimal"></EditText>
<TextView android:layout_width="wrap_content" android:textAppearance="?android:attr/textAppearanceMedium" android:text="Batidinha" android:id="@+id/tvBatidinha" android:layout_height="wrap_content"></TextView>
<EditText android:id="@+id/etBatidinha" android:layout_width="match_parent" android:layout_height="wrap_content" android:inputType="numberDecimal" android:layout_marginBottom="25dip"></EditText>
<Button android:id="@+id/btSalvar" android:layout_width="fill_parent"
android:layout_height="wrap_content" android:text="Salvar" />Quadro 10: Arquivo de layout ‘aposta.xml’
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 31/46
30
Após informar os valores para a Compra, Recompra e também Batidinha, o
botão ‘Salvar’ será o responsável para fazer a gravação destes valores no banco
de dados.
Para isso, primeiramente teremos uma classe responsável pela criação do
banco de dados, tal como, a tabela que receberá todas as informações do
aplicativo. Esta classe, chamada de ‘DBHelper’ (Quadro 11), ficará situada na
nova package ‘ pontinho.manager.model ’ e conterá o seguinte conteúdo:
//nome do banco de dados public static final String NOME_DO_BANCO = "pontinho_manager";//nome da tabela a ser criada public static final String TBL_PARTIDA = "partida";
//criação da tabela private final String SCRIPT_TABELA_PARTIDA = "CREATE TABLE " +
TBL_PARTIDA + " (id INTEGER PRIMARY KEY AUTOINCREMENT, " + "compra FLOAT NOT NULL, " + "recompra FLOAT NOT NULL, " + "batidinha FLOAT NOT NULL, " + "data DATE, " + "hora TIME, " + "vencedor TEXT, " + "finalizada BOOLEAN, " + "nome_jogador1 TEXT...";
//faz a execução e cria o banco de dados public DBHelper(Context ctx) {
super(ctx, NOME_DO_BANCO, null, 1);}
//faz a execução do script e cria a tabela public void onCreate(SQLiteDatabase db) {
db.execSQL(SCRIPT_TABELA_PARTIDA);}
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){
//Nada para fazer na primeira versão...
}}
Quadro 11: Classe ‘DBHelper’ , responsável pela criação do Banco de Dados
Agora, temos a classe ‘ApostaActivity.java’ (Quadro 12) que fará a ligação
com o arquivo de layout , mostrando a tela de cadastro das apostas para o
usuário, bem como, este arquivo trará para seus determinados campos, os
valores gravados no banco de dados, ou, se esses ainda não existirem,
inicializará com os campos zerados:
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 32/46
31
(...) //declara qual será o layout apresentado setContentView(R.layout.aposta); //faz a ligação com os elementos do layout etCompra = (EditText) findViewById(R.id.etCompra);etRecompra = (EditText) findViewById(R.id.etRecompra);
etBatidinha = (EditText) findViewById(R.id.etBatidinha);
btSalvar = (Button) findViewById(R.id.btSalvar);
//coloca vida ao Botão btSalvar.setOnClickListener( new View.OnClickListener() {
//ação para quando clicar no Botão public void onClick(View arg0) {
btSalvarOnClick();}
} );//carrega valores existentes no Banco de Dados ou valores em branco seainda não existe nada gravado //instancia a classe Aposta que contém os getters e setters com os valoresdas Apostas Aposta ap = new Aposta();
//chama o método 'carregaApostas' ap = RepositorioAposta.getInstance(getApplicationContext()).carregaApostas();
//seta os valores dentro dos EditTexts etCompra.setText(Double.toString(ap.getCompra()));etRecompra.setText(Double.toString(ap.getRecompra()));etBatidinha.setText(Double.toString(ap.getBatidinha()));
}
Quadro 12: Classe ‘ApostaActivity.java’
Para inicializar os valores de cada campo, é executado o método
‘carregaApostas’ (Quadros 13 e 14), localizado na classe
src/pontinho.manager.model/RepositorioAposta.java .
//MÉTODO RESPONSÁVEL PELA RECUPERAÇÃO DOS VALORES DAS APOSTAS
public Aposta carregaApostas() {db.beginTransaction();Aposta ap = new Aposta();
try {//busca no Banco pelos dados com 'id' igual a '1' Cursor c = db.query(DBHelper.TBL_PARTIDA, null,"id = 1", null, null,null, null, null);
c.moveToFirst();
//se existe algum valor, traz os valores do Banco e faz os 'Sets' if (c.getCount() > 0) {
Quadro 13: Método ‘carregaApostas’ referente à classe ‘RepositorioAposta.java’
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 33/46
32
ap.setBatidinha(Double. parseDouble(c.getString(3)));ap.setCompra(Double. parseDouble(c.getString(1)));ap.setRecompra(Double. parseDouble(c.getString(2)));ap.setId(c.getInt(0));//se ainda não existe nenhum valor, traz por padrão, os valores das
Apostas zerados }else{
ap.setBatidinha((double) 0);ap.setCompra((double) 0);ap.setRecompra((double) 0);ap.setId(1);
}}finally{db.endTransaction();}return ap;
}
Quadro 14: Continuação do método ‘carregaApostas’
Agora vamos para a ação do botão ‘Salvar’ (Quadro 15). Este botão deverá
pegar os valores digitados pelo usuário e enviá-los ao banco de dados. Para isto,
na mesma ‘ ApostaActivity ’ , ainda temos:
//método do clique do botão Salvar private void btSalvarOnClick() {
Aposta ap = new Aposta();//se são campos válidos if(saoCamposValidos()){//pega os valores digitados e manda-os para a classe Aposta ap.setCompra(Double. parseDouble(etCompra.getText().toString()));ap.setRecompra(Double. parseDouble(etRecompra.getText().toString()));ap.setBatidinha(Double. parseDouble(etBatidinha.getText().toString()))ap.setId(1);
//executa o método gravarAposta, responsável por inserir os dados noBanco de DadosRepositorioAposta.getInstance(getApplicationContext()).gravarAposta(ap);
//após executada a gravação, dizemos qual é a próxima Intenção doaplicativo //neste caso, volta para o Menu Principal (Main) Intent aposta = new Intent(this, Main.class);startActivity(aposta);
}}
Quadro 15: Intenção do botão ‘Salvar’ , referente à classe ‘ApostaAct ivity,java ’
Como visto acima, o botão ‘Salvar’ executa o método chamado
‘gravarAposta’ (Quadro 16). Este método, também localizado na classe
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 34/46
33
‘ src/pontinho.manager.model/RepositorioAposta.java ’ é quem enviará os valores
para o banco. Necessariamente, o método inclusive irá gravar os pontos de cada
jogador, com valor igual a zero, tal como, inicializará o saldo em débito, de cada
participante, com o valor da Compra.
public Aposta gravarAposta (Aposta ap) {long retorno;db.beginTransaction();try {
ContentValues cv = new ContentValues();
//grava o 'id' de valor igual a '1', o valor digitado da Compra,Recompra e Batidinhacv.put(CAMPOS_PARTIDA[0], ap.getId());cv.put(CAMPOS_PARTIDA[1], ap.getCompra());
cv.put(CAMPOS_PARTIDA[2], ap.getRecompra());cv.put(CAMPOS_PARTIDA[3], ap.getBatidinha());
//seta valores zerados para os Pontos de cada Jogador cv.put(CAMPOS_PARTIDA[16], 0.0);cv.put(CAMPOS_PARTIDA[17], 0.0);(...)
//inicialmente seta o Saldo de cada Jogador com o valor da Compranegativo cv.put(CAMPOS_PARTIDA[24], -ap.getCompra());cv.put(CAMPOS_PARTIDA[25], -ap.getCompra());(...)
//busca no banco por algum dado com 'id' igual a '1' Cursor c = db.query(DBHelper.TBL_PARTIDA, null,"id = 1", null, null,null, null, null);
c.moveToFirst();
//se não existe nenhum dado gravado, ou seja, primeira execução doaplicativo, ele faz o Insert e inclusive faz a criação do Banco deDados if (c.getCount() == 0) {
retorno = db.insert(DBHelper.TBL_PARTIDA, null, cv);db.setTransactionSuccessful();
//se já existe dados com 'id' igual a '1', faz-se o Update,atualizando os valores das Apostas }else{
retorno = db.update(DBHelper.TBL_PARTIDA, cv,Double.toString(ap.getId()), null);db.setTransactionSuccessful();
}}finally {
db.endTransaction();}return ap;
}Quadro 16: Método ‘gravarAposta’ referente à classe ‘RepositorioAposta.java’
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 35/46
34
Enfim vamos ao botão que dará início ao controle da partida de Pontinho.
Como visto lá no começo, o botão ‘Nova Partida’ chamará a classe
‘NovaPartidaActivity .java’ . Esta classe será responsável por mostrar o arquivo de
layout ‘novapartida.xml’ (Figura 8) que consiste em apenas um EditText 21 que
receberá o número de jogadores que farão parte da partida e um botão para
avançar para a próxima etapa.
Figura 8: Tela que exibe o EditText que receberá o número de jogadores
Para o desenvolvimento desta tela, no arquivo ‘res/layout/novapartida.xml’
(Quadro 17) teremos:
<EditText android:layout_width="match_parent" android:id="@+id/etNumJogadores"
android:layout_height="wrap_content" android:layout_marginBottom="25dip" android:inputType="number"> <requestFocus></requestFocus>
</EditText> <Button android:id="@+id/btAvancar"
android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Avançar" />
Quadro 17: Arquivo de layout ‘ novapartida .xml’
21 Caixa de texto para o usuário inserir as informações.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 36/46
35
Agora vamos à classe ‘NovaPartidaActivity’ (Quadro 18), a qual chamará o
arquivo de layout ‘novapartida.xml’ . Para isso, na classe
‘src/pontinho.manager/NovaPartidaActivity.java’ teremos:
(...)setContentView(R.layout.novapartida);
etNumJogadores = (EditText) findViewById(R.id.etNumJogadores);
btAvancar = (Button) findViewById(R.id.btAvancar);(...)
Quadro 18: Classe Activity ‘NovaPartidaActivity.java’
Conforme a regra do jogo, a partida deverá conter entre três e oito
jogadores, para isso, dentro da intenção do botão ‘Avançar’ teremos o método
‘saoCamposValidos’ (Quadro 19) que fará a verificação:
(...)private boolean saoCamposValidos() {
if (etNumJogadores.getText().toString().equals("")) {Toast. makeText(this, "Digite o número de jogadores.", 1000 ).show();return false;
}
int numeroTeste = Integer. parseInt(etNumJogadores.getText().toString());
if (numeroTeste < 3) {Toast. makeText(this, "É necessário ter no mínimo 3 jogadores.", 1000).show();return false;
}
if (numeroTeste > 8) {Toast. makeText(this, "A partida pode ter no máximo 8 jogadores.", 1000).show();return false;
}return true;
}(...)
Quadro 19: Método que valida o número de jogadores
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 37/46
36
Se o valor digitado for válido, conforme a Figura 8, levaremos o usuário à
próxima tela, para isso, na ação do botão ‘Avançar’ (Quadro 20) temos:
(...)
if (saoCamposValidos()) {Intent jogadores = new Intent(this, JogadoresActivity.class);startActivity(jogadores);
} (...)
Quadro 20: Intenção do botão ‘Avançar’
Como visto acima, o botão ‘Avançar’ levará o usuário à classe
‘JogadoresActivity.java’ (Quadro 21). Esta classe chamará o arquivo de layout
‘jogadores.xml’ (Figura 9) conforme trecho abaixo:
(...)setContentView(R.layout. jogadores);(...)
Quadro 21: Classe ‘JogadoresActivity.java’
Figura 9: Tela responsável por receber os nomes dos jogadores
Por sua vez, no arquivo de layout (Quadro 22) existirão os campos de texto
para que o usuário digite os nomes dos jogadores; e o botão ‘Começar’ , que
levará o usuário à tela do controle da partida:
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 38/46
37
<EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador1" android:layout_height="40dp" android:layout_marginBottom="7dip"> <requestFocus></requestFocus>
</EditText> <EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador2"
android:layout_height="40dp" android:layout_marginBottom="7dip" /> <EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador3"
android:layout_height="40dp" android:layout_marginBottom="7dip" /> <EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador4"
android:layout_height="40dp" android:layout_marginBottom="7dip" /> <EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador5"
android:layout_height="40dp" android:layout_marginBottom="7dip" /> <EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador6"
android:layout_height="40dp" android:layout_marginBottom="7dip" /> <EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador7"
android:layout_height="40dp" android:layout_marginBottom="7dip" /> <EditText android:layout_width="match_parent" android:id="@+id/etNomeJogador8"
android:layout_height="40dp" android:layout_marginBottom="7dip" /> <Button android:text="Começar" android:id="@+id/btComecar" android:layout_width="match_parent" android:layout_height="wrap_content" />
Quadro 22: Arquivo de layout ‘jogadores.xml’
Como visto, no arquivo de layout existem oito EditTexts para receber os
valores digitados. Porém, a classe ‘JogadoresActivity.java’ receberá o valor
digitado (com o número de jogadores) anteriormente pelo usuário, e exibirá
apenas a quantidade de EditTexts necessária.
Após digitar os respectivos nomes, conforme a Figura 9, o usuário deveráclicar no botão ‘Começar’ que é responsável por chamar o método
‘gravarJogadores’ existente na classe
‘ src/pontinho.manager.model/RepositorioJogadores.java ’ que enviará os nomes
dos jogadores para o banco de dados.
Depois de executar o método ‘gravarJogadores’ , o botão ‘Começar’ enviará
(Quadro 23) o usuário para a próxima tela:
(...)Intent comecaPartida = new Intent(this, PartidaActivity.class);startActivity(comecaPartida); (...)
Quadro 23: Intenção do botão ‘Começar’
Como descrito acima, a intenção do usuário, através do botão ‘Começar’ é
chegar na tela de controle da partida (Figura 10), chamando a classe
‘Partid aActivity.java ’.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 39/46
38
Figura 10: Tela de controle da partida de Pontinho
Como exibido na figura acima, a pontuação inicializará zerada e o saldo de
cada jogador aparecerá negativo, com o valor da Compra.
Após jogar a primeira rodada, o usuário que estiver anotando o placar
através do aplicativo, deverá clicar em ‘Marcar Rodada’. O botão será
responsável por exibir os EditTexts relativos a cada jogador, para que os pontos
sejam informados (Figura 11), inclusive mostrar o botão ‘Salvar’ , que fará todos os
testes e enviará os pontos ao banco de dados.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 40/46
39
Figura 11: Simulação da marcação da primeira rodada da partida
Conforme a figura acima, o jogador „João‟ bateu na primeira rodada, ou
seja, o aplicativo deverá somar ao seu saldo o valor da Batidinha (R$ 0,50),
multiplicado pelo número de adversários. Aos outros jogadores, o aplicativo
atribuirá os devidos pontos inseridos, tal como, descontará deles, o valor da
Batidinha, como mostra a Figura 12.
Figura 12: Resultado da primeira rodada
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 41/46
40
Após o término da segunda rodada, cabe ao usuário clicar novamente em
‘Marcar Rodada’ e informar os novos valores.
Figura 13: Marcação da segunda rodada
Conforme a Figura 13, novamente o jogador „João‟ bateu. Distinto da
primeira rodada, o jogador „Pedro‟ acabou batendo pela mesma carta, e como não
estava na vez, lhe foi atribuído o valor zero. Este detalhe implica no desconto da
Batidinha no saldo do jogador „Pedro‟, o qual fica isento. De tal forma, o jogador
„João‟, não receberá o valor da Batidinha do seu adversário. Para este feito, o
aplicativo consegue verificar o número de jogadores que bateram ao mesmo
tempo, para que aquele que bater receba a Batidinha apenas dos outros
jogadores.
Outro detalhe foi o fato do jogador „José‟, que continha 55 pontos na
primeira rodada, ao somar mais 70 pontos, acabou ultrapassando 100 pontos, o
que implica que o jogador recompre para retornar à partida, ou seja, além do valor
da Batidinha, também lhe será descontado o valor da Recompra (R$ 1,00) e será
atribuído a ele a mesma quantidade de pontos daquele jogador que tiver o maior
número de pontos. Portanto, ao receber o clique no botão ‘Salvar’ , o aplicativo
primeiramente faz a somatória da rodada atual com a rodada anterior. Depois,
guarda o maior valor de pontos desde que seja menor que 100. Atribui àquele(s)
jogador(es) que atingirem mais de 100 pontos o maior ponto que foi guardado e
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 42/46
41
inclusive desconta o valor da Recompra. Nesta etapa o aplicativo inclusive conta
a quantidade de jogadores com os pontos maiores que 100, para que, se sobrar
apenas um, a partida se dê como encerrada.
Figura 14: Resultado da segunda rodada
A figura acima demonstra os dados atualizados após a segunda rodada.
Como visto, o aplicativo somou ao saldo de „João‟, o valor da Batidinha,
multiplicado por apenas três jogadores, isentando o jogador „Pedro‟ que havia
batido junto. Por sua vez, o jogador „Pedro‟ continuou com a mesma quantia de
pontos da rodada anterior e do seu saldo nada foi descontado.
O jogador „José‟, como visto, atingiu mais de 100 pontos, portanto ele
retornou à partida com a mesma quantidade de pontos do jogador „André‟, e além
da Batidinha, também lhe foi descontado o valor da Recompra.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 43/46
42
Figura 15: Simulação da partida sendo encerrada
Supondo que na terceira rodada da partida o jogador „Pedro‟ acabou
batendo, e por acaso nenhum outro jogador escapou com menos de 100 pontos,
coube, ao usuário, ao invés de informar os pontos de cada jogador, apenas
informar a letra ‘x’ , conforme a figura acima.
Como resultado, ao clicar novamente no botão ‘Salvar’ , o aplicativo faz a
verificação e percebe que o número de jogadores com a quantidade de pontos
menor que 100 é de apenas um. Contudo, o aplicativo dá a partida como
encerrada, trazendo o vencedor (Figura 16).
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 44/46
43
Figura 16: Partida encerrada
A figura acima faz a demonstração de quando a partida está encerrada.
Como visto, o aplicativo verifica qual jogador foi o único que sobrou com menos
de 100 pontos e lhe atribui a palavra ‘Venceu’ no lugar dos pontos. Aos outros
jogadores, o ‘X’ significa que estes foram derrotados.
Ao clicar no botão ‘Nova Partida’ , o aplicativo zera novamente o banco de
dados, retomando a pontuação com valores zerados, e o saldo novamente com o
valor da Batidinha debitado. Da mesma forma, se o usuário clicar no botão ‘V oltar
ao Menu’ , a única diferença é que o levará ao menu principal.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 45/46
44
5 – CONSIDERAÇÕES FINAIS
Através do presente trabalho posso afirmar que desenvolver para a
plataforma Android, apesar de suas particularidades, não deixa de ser prático,
sem mistérios, pela questão de envolver a linguagem de programação Java ,
bastante conhecida e muito utilizada a nível mundial.
Além do mais, o Android possui o SQLite, um banco de dados nativo que
não necessita de qualquer tipo de instalação, o qual se torna bastante útil no
sentido de o usuário poder recuperar seus dados antigos, sem a necessidade de
informá-los novamente a cada execução do aplicativo.
Por ser de código aberto, facilita muito para que os programadores possam
reutilizar códigos, não precisando programar do zero. Inclusive, para osdesenvolvedores de dispositivos móveis, há a possibilidade de fazer alterações no
próprio sistema operacional, trazendo melhorias, corrigindo falhas, deixando o
sistema aprimorado e cada vez mais moderno.
Além dessas vantagens, por ser totalmente livre, o Android não possui
nenhuma restrição quanto à utilização ou distribuição de aplicativos
desenvolvidos, não precisando passar por avaliação da Google , nem mesmo
necessitando divulgar o aplicativo no Android Market , bastando apenas transferir via USB o arquivo de instalação (gerado facilmente via Eclipse ) para o disposivo
móvel e executá-lo a partir do celular ou tablet. Desta maneira, pude ver o quanto
é gratificante programar para Android, podendo ver meu aplicativo já em
experimento em um disposivo móvel.
O único obstáculo encontrado, é que por ser uma tecnologia ainda recente,
o Android possui pouca documentação, ou seja, existem poucas referências a
respeito da tecnologia.
5/12/2018 TCC Douglas - slidepdf.com
http://slidepdf.com/reader/full/tcc-douglas 46/46
45
REFERÊNCIAS
ANDROID 2.2 é a mais popular versão do sistema do Google. Terra, mar. 2011.Disponível em: <http://tecnologia.terra.com.br/noticias/0,,OI4998005-EI15607,00- Android+e+a+mais+popular+versao+do+sistema+do+Google.html>. Acesso em:18 out. de 2011.
ECLIPSE inicial uma introdução ao popular IDE livre. Java Magazine, n. 4, ano 1,2002. Disponível em: <http://www.devmedia.com.br/post-8906-Artigo-Java-Magazine-04-Eclipse-inicial-uma-introducao-ao-popular-IDE-livre.html>. Acessoem: 15 out. 2011.
HISTÓRIA do Baralho. Regras dos Jogos, 2007. Disponível em:<http://www.regrasdosjogos.com.br/ntc/default.asp?Cod=2>. Acesso em: 08 out.2011.
HUINZINGA, Johan. Homo Ludens. 4. ed. São Paulo: Perspectiva S.A., 1938.
JAVA, O que é. JavaFree, 2009. Disponível em:<http://javafree.uol.com.br/artigo/871498/>. Acesso em: 13 out. 2011.
LECHETA, Ricardo R. Google Android: aprenda a criar aplicações paradispositivos moveis com o Android SDK. São Paulo: Novatec Editora, 2009.
PREPARANDO o ambiente de desenvolvimento Android e primeira App Android.MobileIn, dez. 2010. Disponível em: <http://mobilein.com.br/?p=14>. Acesso em:
15 ago. 2011.
SQLITE no Android: trabalhando com a persistência de dados no Android. MobileMagazine, n. 34, ano 5, mar. 2011. Disponível em:<http://www.devmedia.com.br/post-19201-SQLite-no-Android.html>. Acesso em:03 set. 2011.
TUTORIAL Programa em Android – Parte 1. MobileIn, dez. 2010. Disponível em:<http://mobilein.com.br/?p=86>. Acesso em: 16 ago. 2011.
Recommended