UNIVERSIDADE DO OESTE DE SANTA CATARINA UNOESC CAMPUS DE XANXER

DOUGLAS MENDES CORSO

PONTINHO MANAGER: APLICATIVO EM ANDROID PARA GERENCIAMENTO DO JOGO DE CARTAS PONTINHO

XANXER 2011

DOUGLAS MENDES CORSO

PONTINHO MANAGER: APLICATIVO EM ANDROID PARA GERENCIAMENTO DO JOGO DE CARTAS PONTINHO

Monografia apresentada ao Curso de Tecnologia em Anlise e Desenvolvimento de Sistemas da Unoesc Campus de Xanxer, como requisito parcial para obteno do ttulo de Tecnlogo em Anlise e Desenvolvimento de Sistemas.

Orientador: Maurcio Bert

Xanxer 2011

DOUGLAS MENDES CORSO

PONTINHO MANAGER: APLICATIVO EM ANDROID PARA GERENCIAMENTO DO JOGO DE CARTAS PONTINHO

Monografia apresentada ao Curso de Tecnologia em Anlise e Desenvolvimento de Sistemas da Unoesc Campus de Xanxer, como requisito parcial para obteno do ttulo de Tecnlogo em Anlise e Desenvolvimento de Sistemas.

Orientador: Maurcio Bert

Aprovado em ...... de ......................... de 2011.

BANCA EXAMINADORA

_________________________________________ Maurcio Bert

________________________________________ Andr Luiz Forchesatto _________________________________________ Cristiano Agosti _________________________________________ Rosicler Felippi Puerari

Mas no basta pra ser livre, ser forte, aguerrido e bravo; povo que no tem virtude acaba por ser escravo. (Francisco Pinto da Fontoura)

AGRADECIMENTOS

Este trabalho dedicado a Deus. Dedicado minha famlia, principalmente aos meus pais, pela minha base e por toda a minha educao. Dedicado aos meus professores, por terem me ensinado e compartilhado suas sabedorias. Dedicado ao orientador Maurcio e coordenadora Rosicler, por toda a ajuda e contribuio nesta jornada. Em especial, dedicado minha namorada Bruna, por ter me proporcionado seu tempo, sempre estando ao meu lado, me dando foras, me apoiando, sendo a chave essencial de toda esta conquista. Bruna, dedico a voc no s este trabalho, mas tambm o meu corao, eu te amo.

RESUMO

Atravs de um jogo de cartas chamado Pontinho, surgiu a necessidade de automatizar, agilizar e tornar o marcador deste jogo mais interativo, levando em considerao o indcio de erros quando a anotao do placar realizado de forma manual e sabendo da grande quantidade de pessoas que aprecia o jogo Pontinho, por uma questo de cultura e lazer. Motivado por esse desafio, pensando na flexibilidade da recente e poderosa plataforma Android, ciente do enorme crescimento e evoluo do mercado tecnolgico, surgiu a oportunidade de desenvolver o aplicativo Pontinho Manager1, escrito especialmente para dispositivos mveis, buscando poupar a utilizao de papel, evitando no s o impacto ambiental, mas tambm qualquer tipo de falha na contagem de saldo e pontos. Palavras-chave: Android. Jogo. Pontinho. Celular.

Do ingls, significa gerenciador.

ABSTRACT Through a card game called Pontinho, it faced the need to automate, streamline and make this game more interactive marker, taking into account the sign of the taking 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 SUMRIO 1 INTRODUO .................................................................................................. 8 1.1 TEMA ............................................................................................................. 9 1.2 PROBLEMA ................................................................................................... 9 1.3 OBJETIVOS ................................................................................................. 10 1.3.1 Objetivo Geral .......................................................................................... 10 1.3.2 Objetivos Especficos ............................................................................. 10 1.4 JUSTIFICATIVA ........................................................................................... 10 2 REFERENCIAIS TERICOS .......................................................................... 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 PROGRAMAO ................................................. 18 3 METOLOGIA ........................................................................................... 20 4 DESENVOLVIMENTO ............................................................................. 21 5 CONSIDERAES FINAIS ............................................................................ 44 REFERNCIAS ............................................................................................ 45

8 1 INTRODUO

O contedo desse trabalho apresenta o desenvolvimento de um aplicativo para dispositivos mveis, chamado Pontinho Manager, que tem como funo a administrao de pontos, tal como saldo de um jogo de cartas conhecido como Pontinho. Segundo Huizinga (1938), jogo uma atividade voluntria exercida dentro de certos e determinados limites de tempo e espao, segundo regras livremente consentidas, mas absolutamente obrigatrias, dotado de um fim em si mesmo, acompanhado de um sentimento de tenso e alegria e de uma conscincia de ser diferente da vida cotidiana. Hoje em dia, muitas pessoas buscam jogos como meio de diverso e entretenimento, em funo disso, o objetivo do projeto tem como princpio preservar o jogo em sua forma natural, estimulando o convvio social entre pessoas, porm, com uma contagem de valores extremamente dinmica e inovadora. Com um crescente nmero de usurios de jogos, e principalmente de aparelhos mveis, criou-se uma oportunidade para um aplicativo diferenciado, que favorece a interao de pessoas e a integrao com o jogo Pontinho em momentos de lazer. O aplicativo ser destinado ao pblico jovem e adulto, na faixa de 18 a 30 anos, de classe social mdia e mdia-alta. So consumidores que buscam jogos e o convvio social como forma de lazer e diverso e esto em constante contato com a internet e novas tecnologias. O aplicativo Pontinho Manager estar disponvel ao pblico de forma gratuita e seu uso visa estabelecimentos comerciais e residenciais, tais como clubes sociais, bares e ambientes especficos para jogos em ambientes internos.

9 1.1 TEMA

Desenvolvimento de um aplicativo para a plataforma Android, compatvel com diversos celulares e tablets2, 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 mo, um mtodo 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 mtodo mais eficaz e que anule ao mximo qualquer erro de contagem. Por causa disso, surgiu a necessidade de criar um aplicativo que servisse para a soma automtica de pontos, facilitando aos jogadores a no desviarem a ateno do jogo ou desperdiarem 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 smartphones3 podem ser considerados praticamente como um computador de bolso. Alm disso, foi percebido que em rodas de amigos, muito comum que um ou mais indivduos possuam aparelho compatvel para a instalao desse tipo de aplicativo, alm de ser um objeto pessoal, com facilidade de acesso. Durante o desenvolvimento do aplicativo, foram necessrias adaptaes tanto no uso do software4 utilizado, quanto na linguagem de programao. O terceiro desafio considerado foi, ento, a implantao de um banco de dados para o armazenamento de informaes de dados do jogo, haja vista que tornaria o projeto ainda mais complexo.

2 3

Tablet um dispositivo mvel em forma de prancheta. Telefone celular com funcionalidades mais avanadas. 4 Do ingls, 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, compatvel com a plataforma Android, para o controle do placar de uma partida de Pontinho. 1.3.2 Objetivos Especficos Criar um aplicativo para Android, interativo, de fcil manuseio e entendimento Atravs de arquivo xml, desenvolver o layout claro e objetivo para interao com o usurio Detalhar funcionamento do aplicativo atravs de instrues Conforme regra do jogo, limitar o aplicativo para o mnimo de trs e mximo de oito jogadores Receber pontuao de cada jogador em cada rodada da partida, fazer a somatria 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 descontrao e utilizava de papel e caneta para anotao de placar. Foi a que surgiu a ideia de automatizar a contagem dos pontos, tal como o saldo de cada jogador, buscando evitar o desperdcio de papel, reduzindo o impacto ambiental, sem contar na praticidade nos clculos com o uso do aplicativo. O Pontinho, muito apreciado e conhecido na regio 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 adversrio, 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 crdito ou dbito dos jogadores. Baseado nisso, o aplicativo Pontinho Manager capacitado para, de forma dinmica, apresentar esses valores em tempo real, sem falar na reduo a zero de qualquer tipo de falha. Buscando a mobilidade, algumas plataformas para o desenvolvimento do aplicativo foram avaliadas. Chegou-se concluso de que o Google Android (criado especialmente para dispositivos mveis) seria o mais apropriado, levando em considerao os custos, benefcios e a total flexibilidade, tornando mais fcil a distribuio e o acesso ao aplicativo. Em virtude disso, o Pontinho Manager foi inteiramente produzido para ser compatvel com a verso 2.2 do Android. A escolha desta verso foi devida sua robustez, tal como, pela grande quantidade de celulares e tablets compatveis com ela, pois, segundo o site de notcias Terra, at maro deste ano, a verso conhecida como Froyo estaria presente em 61,3% de dispositivos mveis que utilizam o sistema Android.

12 2 REFERENCIAIS TERICOS

2.1 JOGOS DE CARTAS

Foi em meados do sculo XIV que as cartas de jogar difundiram-se pela Europa e s a partir do sculo XVI que ficaram conhecidas em todo o mundo. O grande atrativo do baralho sua adaptabilidade, podendo ser jogado de inmeras formas. Os jogos podem ser simples, indicados para crianas (rouba monte, burro, mico, etc) ou jogos com maior nvel de dificuldade, como pontinho, buraco, bridge (este considerado o xadrez dos jogos de cartas) pquer, truco, etc. Independente do material do baralho (pode ser de papelo ou plstico) inegvel a sua versatilidade. O formato mundialmente conhecido: 52 cartas retangulares, com o verso igual. A combinao destas cartas, normalmente em sequncias, cria as possibilidades dos diversos jogos. (HISTRIA, 2007) 2.1.1 Pontinho

Pontinho um jogo semelhante ao Pif, onde se utilizam dois baralhos de 52 cartas cada, com a remoo dos curingas, totalizando 104 cartas. Aps o baralho estar embaralhado, o distribuidor de cartas passa o baralho para o jogador sua esquerda, para que este faa o corte e vire a carta debaixo, descobrindo assim o Curinga. O Curinga passa a ser a carta de mesmo nmero da descoberta, porm, com o naipe de cor contrria. So distribudas nove cartas para cada membro da partida. O jogador direita do distribuidor dever comear 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 sequncia de trs ou mais cartas. Ao passar a vez, o jogador dever descartar uma carta no lixo, no 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 podero juntar a carta do lixo, no 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 deixaro de debitar o valor da Batidinha e tambm no recebero pontos. Diferente do Pif, no jogo de Pontinho possvel descer cartas nos jogos dos adversrios ou queimar uma carta, quando esta repetida a alguma carta de alguma trinca que est na mesa. Tambm permitido baixar jogos de trs ou mais cartas, lembrando-se que o Curinga, quando no estiver no seu lugar, no 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 mo, 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 mo, sendo que o Curinga vale 20 pontos, o s vale 15 pontos, cada figura vale 10 pontos, e da carta nmero 2 ao nmero 10, equivale o seu devido valor. Vale lembrar-se da exceo do s, que quando sozinho na mo, 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 so 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 cada adversrio, exceto daqueles que baterem pela mesma carta.

14 2.1.1.3 Sistema de placar

A figura abaixo serve para exemplificar o mtodo utilizado no placar da partida, juntamente com o sistema de valores.

Figura 1: Esboo de uma anotao de placar de Pontinho

I- Somatria do placar geral da partida. II- Dbito e crdito dos jogadores. III- Marcao da primeira rodada. IV- Marcao da segunda rodada. 2.2 GOOGLE ANDROID

Android uma plataforma de desenvolvimento para aplicativos mveis, gerada atravs de uma grande evoluo tecnolgica, com um ambiente de trabalho bastante arrojado e flexvel. Quando lanada, causou grande impacto para os usurios de telefonia mvel, atraindo a ateno no s destes, mas tambm dos que vieram a ter conhecimento sobre esta revoluo na tecnologia mvel. Isso se deu porque por trs dele est a empresa revolucionria da internet a Google -, como tambm outras empresas lderes 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 cdigo aberto, para superar e atender as expectativas e tendncias do mercado, que fosse moderna e flexvel

15 para a criao de aplicativos corporativos, entretanto, foi a que surgiu o Android. (LECHETA, 2009) As funcionalidades e recursos do Android so realmente impressionantes, desde uma perfeita resoluo de jogos, at o reconhecimento de cdigo de barras. Alm disso, o Android traz mais um benefcio, a linguagem de programao Java, bastante prtica e conhecida, o que facilita e muito para os desenvolvedores de aplicaes. O Android chama ateno principalmente no sentido de a plataforma ser totalmente livre, possuir um cdigo aberto, permitindo aos fabricantes fazerem alteraes no cdigo-fonte, podendo deixar seus produtos customizados, e o que de certa forma inusitado: no h custo. Os fabricantes no precisam divulgar as alteraes a ningum, nem sequer pagar algo por isso. Possuir o cdigo aberto traz ao Android aperfeioamentos a cada verso, uma vez que desenvolvedores do mundo inteiro podem fazer alteraes, realizando melhorias, trazendo novos recursos, ou o fato importante de corrigir possveis falhas. Outra vantagem do sistema, que a plataforma baseada em Linux, sendo que ele mesmo gerencia a memria, tal como os processos, permitindo que mais de uma aplicao seja executada ao mesmo tempo. Desenvolver para Android necessita de conhecimento da linguagem Java, como tambm de xml para a criao das telas, porm, no necessrio possuir um smartphone nem sequer um tablet, pois os testes so fielmente realizados atravs de um emulador que acompanha o kit de desenvolvimento da Google. 2.2.1 Android Market Da mesma forma que a Apple App Store5, a Google lanou o Android Market6, como forma de divulgao da plataforma Android, e claro, para o auxlio na distribuio de aplicativos desenvolvidos para Android. A inteno do site disponibilizar aos desenvolvedores um local para concentrar todos os aplicativos criados para Android e, sem qualquer restrio,

5 6

Loja de aplicativos da empresa Apple. Mercado de aplicativos da Google.

16 possvel publicar qualquer aplicativo mediante cadastro, semelhante ao site You Tube, possuindo inclusive sistema de classificao e comentrios. O nico impasse de que o desenvolvedor necessita pagar uma taxa de 25 dlares para enviar seu aplicativo ao mercado, porm, a vantagem de que 70% dos lucros com os aplicativos vendidos so entregues ao seu criador. J aos usurios, apenas necessrio 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 necessria a instalao do Android SDK7. A ferramenta fornecida gratuitamente pela Google e possui todas as bibliotecas para o entrosamento com a linguagem Java, trazendo as classes responsveis para a criao das aplicaes. O SDK conta tambm com um emulador, chamado de AVD8 Manager, o que facilita e muito para testar os aplicativos, pois no necessrio possuir aparelho com o sistema operacional Android, o prprio emulador faz esse papel, pois idntico a um celular, com todos os recursos. No mesmo kit, existe um plugin chamado ADT9 (Android Development Tools), o qual faz com que o emulador seja executado automaticamente atravs do prprio Eclipse. As aplicaes Android constituem-se em um arquivo de extenso .apk, e da mesma forma que um aparelho celular ou tablet, necessrio instalar esse arquivo tambm no emulador, portanto, outra vantagem de que o prprio plugin10 se encarrega de fazer essa instalao.

7 8

Kit de desenvolvimento de software. Emulador de Dispositivo Mvel 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 aplicaes em Java, C++ e diversas outras linguagens de programao. Porm, o Eclipse no limita-se apenas em suportar variadas linguagens de programao, sendo compatvel com ferramentas para controle de verso como o CVS11, e pode executar internamente servidores web ou servidores de aplicaes para a depurao de objetos distribudos. (ECLIPSE, 2002) O Eclipse foi adotado pela Google para ser o principal ambiente de desenvolvimento para Android, facilitando no s no desenvolvimento, como tambm nos testes e inclusive na compilao do projeto. Com a utilizao do plugin ADT, fornecido pela Google, possvel executar o emulador do Android atravs do prprio Eclipse, podendo usufruir de todos os recursos do dispositivo virtual. (LECHETA, 2009) 2.4 BANCO DE DADOS SQLITE

Quando desenvolvida uma aplicao, um dos fatores fundamentais que deve ser levado em considerao o armazenamento de dados. Sem ele, os dados so perdidos aps a execuo do programa, ficando disponveis apenas durante o tempo de execuo.
Antigamente, o armazenamento era feito em sistemas de arquivos do sistema operacional, resultando numa complexidade desnecessria e que no fazia parte das regras de negcio da aplicao, prejudicando a produtividade dos desenvolvedores. (SQLITE, 2011)

A plataforma Android, alm de uma srie 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 12

Sistema de verses concorrentes. Linguagem de consulta estruturada.

18 O desenvolvedor tem a flexibilidade de criar o banco de dados e as tabelas, como tambm ter o controle sobre os dados atravs de comandos DDL13 (Data Definition Language) e DML14 (Data Manipulation Language) do SQL padro. Esse mecanismo capaz de aumentar a produtividade, tendo em vista que os servios para resguardar os dados so ministrados pelo SQLite, permitindo que seus usurios no precisem fornecer seus dados a cada execuo do programa. (SQLite, 2011) No Android, o banco de dados pode ser criado de diferentes maneiras, porm, a mais recomendada utilizar a API do Android para o SQLite, ou seja, faz-lo via programao, para que a prpria aplicao 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 permanecero no banco mesmo aps novas instalaes do aplicativo, at mesmo porque o sistema entende que as futuras instalaes so apenas atualizaes, mantendo assim os dados antigos. Para os fins de criar novamente o banco de dados, necessrio que primeiramente seja feita a remoo do aplicativo, para posteriormente instal-lo novamente no dispositivo. 2.5 JAVA, LINGUAGEM DE PROGRAMAO

Java constitui-se em uma linguagem de programao orientada a objetos que possui um programa para execuo conhecido como mquina virtual ou virtual machine. A tecnologia comeou a ser desenvolvida no ano de 1991 atravs de um projeto chamado de Green Project, porm foi s em maio de 1995 que a linguagem Java passou a ser oficialmente lanada na SunWorldExpo 95. Com a f da Netscape em investir no projeto, possibilitando o desenvolvimento de aplicativos Java, integrados ao seu navegador, que a linguagem passou a avanar muito. Hoje, Java consiste em uma das linguagens mais utilizadas no planeta, possuindo um dos maiores repositrios de projetos de cdigo-aberto do mundo, o java.net. Por questo de sua portabilidade, ao ser programado apenas uma vez, o
13 14

Linguagem de definio de dados. Linguagem de manipulao de dados.

19 aplicativo Java capaz de rodar em qualquer tipo de aplicao, entre elas: aplicativos mveis, jogos, web15, servidores, desktop16, etc. (JAVA, 2009) Com o surgimento do Android, Java passou a ser sua principal linguagem de programao, facilitando e muito o entendimento para a maioria dos desenvolvedores, e influenciando tambm na expanso da linguagem.

15 16

Rede de alcance mundial. Computador de mesa.

20 3 METODOLOGIA

Como

sabemos,

objetivo

deste

trabalho

demonstrar

desenvolvimento de um aplicativo para a administrao 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 cdigo aberto, tal como ambiente de desenvolvimento, bibliotecas e emulador para teste totalmente grtis, sem contar que o aplicativo pode ser utilizado sem restries em celulares e tablets configurados com a verso 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 comear 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, disponvel no seguinte endereo: 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 incio a um novo projeto Android

Feito isso, na prxima tela (Figura 3) deveremos colocar o nome do projeto, que ser PontinhoManager. Escolheremos a verso do Android, que ser a Android 2.2. Ser necessrio criar uma package, nomeada de pontinho.manager. Deixaremos selecionado Create Activity com o intuito de criar uma Activity17 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 usurio.

22

Figura 3: Eclipse IDE, finalizando a criao de um novo projeto Android

23 A primeira etapa do projeto ser criar a tela principal do aplicativo, a qual dever receber as intenes do usurio, atravs de determinadas opes, disponibilizadas em cinco botes, sendo eles: Nova Partida: responsvel por iniciar o controle de uma nova partida. Apostas: levar o usurio para configurar os valores das Apostas, ou seja, os valores da Compra, da Recompra, e da Batidinha. Instrues: mostrar ao usurio as instrues de utilizao do aplicativo. Sobre: informaes sobre a autoria do projeto. Sair: responsvel apenas para finalizar o aplicativo.

Para a criao deste menu (Figura 4), primeiramente foi necessrio editar o arquivo de layout18 main.xml.

Figura 4: Menu principal do Pontinho Manager

18

Desenho e formato da tela que aparecer para o usurio.

24 Sendo assim, no arquivo /res/layout/main.xml (Quadro1) temos as seguintes informaes:

<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="Instrues" /> <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 usurio, necessrio criar a Activity Main.java (Quadro 2), classe que far comunicao com o arquivo xml e apresentar o menu para o usurio. Desta forma, no arquivo src/pontinho.manager/Main.java temos:

(...) //chama o arquivo de layout xml setContentView(R.layout.main); //faz a ligao com o arquivo de layout, trazendo os botes 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: Exibio dos botes na classe Main.java

25 Agora precisamos informar para cada boto, qual ser a inteno do usurio, para isso temos as Intents19 (Quadro 3):
//aes para o clique de cada boto 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: Intenes dos botes, correspondente classe Main.java Vamos para a ao do boto Sair, responsvel apenas para finalizar o aplicativo. Neste caso utilizamos o seguinte comando:
android.os.Process.killProcess(android.os.Process.myPid());

Poderamos utilizar tambm o comando super.finish(); que a princpio teria a mesma funo, porm este ltimo no finaliza o processo. Agora vamos para o objetivo do boto Sobre, que apenas apresentar ao usurio as informaes sobre a autoria do projeto (Figura 5). Para isso temos o arquivo sobre.xml (Quadro 4), responsvel pelo layout.

19

So as intenes do usurio. Comandos enviados ao sistema operacional Android para realizar alguma ao.

26

Figura 5: Texto sobre a autoria do aplicativo res/layout/sobre.xml (Quadro 4) teremos apenas um

No arquivo

TextView20 que conter as informaes 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 Anlise e Desenvolvimento de Sistemas, na Universidade do Oeste de Santa Catarina - Campus de Xanxer, sob orientao do Prof. Maurcio Bert." />

Quadro 4: Arquivo de layout sobre.xml

Agora teremos que editar a classe que ser responsvel por exibir a tela ao usurio. 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 necessrio configurar o arquivo AndroidManifest.xml (Quadro 6) situado na raiz do projeto. Neste arquivo obrigatrio informar todas as Activities contidas no aplicativo, e tambm, atravs dele, possvel declarar o formato de apresentao do layout, atravs do comando theme:

<activity android:name=".Sobre" android:label="@string/sobre" android:theme="@android:style/Theme.Dialog"></activity>

Quadro 6: Declarao da Activity Sobre.java no AndroidManisfest.xml Agora vamos para ao do boto Instrues, que apenas apresentar para o usurio, um texto que contm as instrues de uso do aplicativo. Para isso temos o arquivo instrucoes.xml (Quadro 7), responsvel pelo layout. Neste arquivo apenas teremos um TextView que conter as instrues 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 necessrio configurar os valores das Apostas, para isso volte ao menu principal e selecione a opo 'Apostas'. Informe os novos valores e clique em 'Salvar'. Configurados os valores, selecione a opo 'Nova Partida', que o levar a prxima tela, na qual voc dever informar..." />

Quadro 7: Arquivo de layout instrucoes.xml

Agora teremos que editar a classe que responsvel por exibir a mensagem ao usurio. 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 necessrio tambm 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: Declarao da Activity Instrucoes.java no AndroidManisfest.xml

Com determinadas configuraes, deveremos visualizar a tela da seguinte forma:

Figura 6: Tela de instrues do aplicativo. Desta vez, vamos ao boto Apostas, responsvel por levar o usurio tela de cadastro dos valores da Compra, Recompra e Batidinha (Figura 7). Ambos os valores sero gravados em banco de dados.

29

Figura 7: Tela de configurao das apostas Para esta inteno, temos o arquivo de layout que conter trs campos para que o usurio informe os valores; e o boto Salvar, responsvel 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 Aps informar os valores para a Compra, Recompra e tambm Batidinha, o boto Salvar ser o responsvel para fazer a gravao destes valores no banco de dados. Para isso, primeiramente teremos uma classe responsvel pela criao do banco de dados, tal como, a tabela que receber todas as informaes do aplicativo. Esta classe, chamada de DBHelper (Quadro 11), ficar situada na nova package pontinho.manager.model e conter o seguinte contedo:

//nome public //nome public

do banco de dados static final String NOME_DO_BANCO = "pontinho_manager"; da tabela a ser criada static final String TBL_PARTIDA = "partida";

//criao 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 execuo e cria o banco de dados public DBHelper(Context ctx) { super(ctx, NOME_DO_BANCO, null, 1); } //faz a execuo 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 verso... } }

Quadro 11: Classe DBHelper, responsvel pela criao do Banco de Dados

Agora, temos a classe ApostaActivity.java (Quadro 12) que far a ligao com o arquivo de layout, mostrando a tela de cadastro das apostas para o usurio, bem como, este arquivo trar para seus determinados campos, os valores gravados no banco de dados, ou, se esses ainda no existirem, inicializar com os campos zerados:

31
(...) //declara qual ser o layout apresentado setContentView(R.layout.aposta); //faz a ligao 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 Boto btSalvar.setOnClickListener( new View.OnClickListener() { //ao para quando clicar no Boto public void onClick(View arg0) { btSalvarOnClick(); } } ); //carrega valores existentes no Banco de Dados ou valores em branco se ainda no existe nada gravado //instancia a classe Aposta que contm os getters e setters com os valores das Apostas Aposta ap = new Aposta(); //chama o mtodo '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 mtodo carregaApostas (Quadros 13 e 14), localizado na classe

src/pontinho.manager.model/RepositorioAposta.java.

//MTODO RESPONSVEL PELA RECUPERAO 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: Mtodo 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 no existe nenhum valor, traz por padro, 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: Continuao do mtodo carregaApostas Agora vamos para a ao do boto Salvar (Quadro 15). Este boto dever pegar os valores digitados pelo usurio e envi-los ao banco de dados. Para isto, na mesma ApostaActivity, ainda temos:
//mtodo do clique do boto Salvar private void btSalvarOnClick() { Aposta ap = new Aposta(); //se so campos vlidos 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 mtodo gravarAposta, responsvel por inserir os dados no Banco de Dados RepositorioAposta.getInstance(getApplicationContext()).gravarAposta(ap); //aps executada a gravao, dizemos qual a prxima Inteno do aplicativo //neste caso, volta para o Menu Principal (Main) Intent aposta = new Intent(this, Main.class); startActivity(aposta); } }

Quadro 15: Inteno do boto Salvar, referente classe ApostaActivity,java Como visto acima, o boto Salvar executa o mtodo chamado gravarAposta (Quadro 16). Este mtodo, tambm localizado na classe

33 src/pontinho.manager.model/RepositorioAposta.java quem enviar os valores para o banco. Necessariamente, o mtodo inclusive ir gravar os pontos de cada jogador, com valor igual a zero, tal como, inicializar o saldo em dbito, 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 Batidinha cv.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 Compra negativo 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 no existe nenhum dado gravado, ou seja, primeira execuo do aplicativo, ele faz o Insert e inclusive faz a criao do Banco de Dados 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: Mtodo gravarAposta referente classe RepositorioAposta.java

34 Enfim vamos ao boto que dar incio ao controle da partida de Pontinho. Como visto l no comeo, o boto Nova Partida chamar a classe NovaPartidaActivity.java. Esta classe ser responsvel por mostrar o arquivo de layout novapartida.xml (Figura 8) que consiste em apenas um EditText21 que receber o nmero de jogadores que faro parte da partida e um boto para avanar para a prxima etapa.

Figura 8: Tela que exibe o EditText que receber o nmero 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="Avanar" />

Quadro 17: Arquivo de layout novapartida.xml

21

Caixa de texto para o usurio inserir as informaes.

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 trs e oito jogadores, para isso, dentro da inteno do boto Avanar teremos o mtodo saoCamposValidos (Quadro 19) que far a verificao:
(...) private boolean saoCamposValidos() { if (etNumJogadores.getText().toString().equals("")) { Toast.makeText(this, "Digite o nmero de jogadores.", 1000 ).show(); return false; } int numeroTeste = Integer.parseInt(etNumJogadores.getText().toString()); if (numeroTeste < 3) { Toast.makeText(this, " necessrio ter no mnimo 3 jogadores.", 1000 ).show(); return false; } if (numeroTeste > 8) { Toast.makeText(this, "A partida pode ter no mximo 8 jogadores.", 1000 ).show(); return false; } return true; } (...)

Quadro 19: Mtodo que valida o nmero de jogadores

36 Se o valor digitado for vlido, conforme a Figura 8, levaremos o usurio prxima tela, para isso, na ao do boto Avanar (Quadro 20) temos:
(...) if (saoCamposValidos()) { Intent jogadores = new Intent(this, JogadoresActivity.class); startActivity(jogadores); } (...)

Quadro 20: Inteno do boto Avanar Como visto acima, o boto Avanar levar o usurio 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 responsvel por receber os nomes dos jogadores

Por sua vez, no arquivo de layout (Quadro 22) existiro os campos de texto para que o usurio digite os nomes dos jogadores; e o boto Comear, que levar o usurio 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" /> <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="Comear" 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. Porm, a classe JogadoresActivity.java receber o valor digitado (com o nmero de jogadores) anteriormente pelo usurio, e exibir apenas a quantidade de EditTexts necessria. Aps digitar os respectivos nomes, conforme a Figura 9, o usurio dever clicar no boto Comear que responsvel por chamar o mtodo 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 mtodo gravarJogadores, o boto Comear enviar (Quadro 23) o usurio para a prxima tela:
(...) Intent comecaPartida = new Intent(this, PartidaActivity.class); startActivity(comecaPartida); (...)

Quadro 23: Inteno do boto Comear Como descrito acima, a inteno do usurio, atravs do boto Comear chegar na tela de controle da partida (Figura 10), chamando a classe PartidaActivity.java.

38

Figura 10: Tela de controle da partida de Pontinho Como exibido na figura acima, a pontuao inicializar zerada e o saldo de cada jogador aparecer negativo, com o valor da Compra. Aps jogar a primeira rodada, o usurio que estiver anotando o placar atravs do aplicativo, dever clicar em Marcar Rodada. O boto ser responsvel por exibir os EditTexts relativos a cada jogador, para que os pontos sejam informados (Figura 11), inclusive mostrar o boto Salvar, que far todos os testes e enviar os pontos ao banco de dados.

39

Figura 11: Simulao da marcao da primeira rodada da partida Conforme a figura acima, o jogador Joo bateu na primeira rodada, ou seja, o aplicativo dever somar ao seu saldo o valor da Batidinha (R$ 0,50), multiplicado pelo nmero de adversrios. 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 Aps o trmino da segunda rodada, cabe ao usurio clicar novamente em Marcar Rodada e informar os novos valores.

Figura 13: Marcao da segunda rodada Conforme a Figura 13, novamente o jogador Joo bateu. Distinto da primeira rodada, o jogador Pedro acabou batendo pela mesma carta, e como no estava na vez, lhe foi atribudo o valor zero. Este detalhe implica no desconto da Batidinha no saldo do jogador Pedro, o qual fica isento. De tal forma, o jogador Joo, no receber o valor da Batidinha do seu adversrio. Para este feito, o aplicativo consegue verificar o nmero 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, alm do valor da Batidinha, tambm lhe ser descontado o valor da Recompra (R$ 1,00) e ser atribudo a ele a mesma quantidade de pontos daquele jogador que tiver o maior nmero de pontos. Portanto, ao receber o clique no boto Salvar, o aplicativo primeiramente faz a somatria 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 aps a segunda rodada. Como visto, o aplicativo somou ao saldo de Joo, o valor da Batidinha, multiplicado por apenas trs 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 alm da Batidinha, tambm lhe foi descontado o valor da Recompra.

42

Figura 15: Simulao 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 usurio, ao invs de informar os pontos de cada jogador, apenas informar a letra x, conforme a figura acima. Como resultado, ao clicar novamente no boto Salvar, o aplicativo faz a verificao e percebe que o nmero 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 demonstrao 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 boto Nova Partida, o aplicativo zera novamente o banco de dados, retomando a pontuao com valores zerados, e o saldo novamente com o valor da Batidinha debitado. Da mesma forma, se o usurio clicar no boto Voltar ao Menu, a nica diferena que o levar ao menu principal.

44 5 CONSIDERAES FINAIS Atravs do presente trabalho posso afirmar que desenvolver para a plataforma Android, apesar de suas particularidades, no deixa de ser prtico, sem mistrios, pela questo de envolver a linguagem de programao Java, bastante conhecida e muito utilizada a nvel mundial. Alm do mais, o Android possui o SQLite, um banco de dados nativo que no necessita de qualquer tipo de instalao, o qual se torna bastante til no sentido de o usurio poder recuperar seus dados antigos, sem a necessidade de inform-los novamente a cada execuo do aplicativo. Por ser de cdigo aberto, facilita muito para que os programadores possam reutilizar cdigos, no precisando programar do zero. Inclusive, para os desenvolvedores de dispositivos mveis, h a possibilidade de fazer alteraes no prprio sistema operacional, trazendo melhorias, corrigindo falhas, deixando o sistema aprimorado e cada vez mais moderno. Alm dessas vantagens, por ser totalmente livre, o Android no possui nenhuma restrio quanto utilizao ou distribuio de aplicativos

desenvolvidos, no precisando passar por avaliao da Google, nem mesmo necessitando divulgar o aplicativo no Android Market, bastando apenas transferir via USB o arquivo de instalao (gerado facilmente via Eclipse) para o disposivo mvel 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 mvel. O nico obstculo encontrado, que por ser uma tecnologia ainda recente, o Android possui pouca documentao, ou seja, existem poucas referncias a respeito da tecnologia.

45 REFERNCIAS ANDROID 2.2 a mais popular verso do sistema do Google. Terra, mar. 2011. Disponvel em: <http://tecnologia.terra.com.br/noticias/0,,OI4998005-EI15607,00Android+e+a+mais+popular+versao+do+sistema+do+Google.html>. Acesso em: 18 out. de 2011. ECLIPSE inicial uma introduo ao popular IDE livre. Java Magazine, n. 4, ano 1, 2002. Disponvel em: <http://www.devmedia.com.br/post-8906-Artigo-JavaMagazine-04-Eclipse-inicial-uma-introducao-ao-popular-IDE-livre.html>. Acesso em: 15 out. 2011. HISTRIA do Baralho. Regras dos Jogos, 2007. Disponvel em: <http://www.regrasdosjogos.com.br/ntc/default.asp?Cod=2>. Acesso em: 08 out. 2011. HUINZINGA, Johan. Homo Ludens. 4. ed. So Paulo: Perspectiva S.A., 1938. JAVA, O que . JavaFree, 2009. Disponvel em: <http://javafree.uol.com.br/artigo/871498/>. Acesso em: 13 out. 2011. LECHETA, Ricardo R. Google Android: aprenda a criar aplicaes para dispositivos moveis com o Android SDK. So Paulo: Novatec Editora, 2009. PREPARANDO o ambiente de desenvolvimento Android e primeira App Android. MobileIn, dez. 2010. Disponvel em: <http://mobilein.com.br/?p=14>. Acesso em: 15 ago. 2011. SQLITE no Android: trabalhando com a persistncia de dados no Android. Mobile Magazine, n. 34, ano 5, mar. 2011. Disponvel 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. Disponvel em: <http://mobilein.com.br/?p=86>. Acesso em: 16 ago. 2011.