tcc douglas

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



1



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



2



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



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)



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

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



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.



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



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.



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.



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



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 .



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



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.



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



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.



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.



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.



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.



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.



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 .



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.



22

Figura 3: Eclipse IDE , finalizando a criação de um novo projeto Android



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.



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 ’



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.



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.



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’



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.



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’



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:



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’



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



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’



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.



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



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:



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" /> <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 ’.



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.



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



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



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.



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



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.



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.



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.

tcc douglas

Documents