Android + Python e Pygame

Olá a partir desse post vamos instalar e configurar a JDK, depois iremos instalar o SDK do android, vamos instalar e configurar o Python com o Pygame, e por último vamos configurar e utilizar o PGS4A (Pygame Subset for Android) que vai gerar um apk para o Android a partir de um script em Python.

Arquivos necessários:

Instalando e configurando JDK 7

Vamos abrir o setup, escolheremos um outro local para o nosso jdk, vamos colocar no diretório “C:\java\jdk7”.

JDK - 1 JDK - 2
Depois disso vamos incluir nosso JAVA_HOME nas variáveis de ambiente.
Clique com o botão direito no ícone do “Meu Computador” e depois em “Propriedades”.

JDK - 3

Após isso vamos inserir uma nova variável de ambiente chamada JAVA_HOME, para isso clique em “Novo”.

Coloque o nome da variável como “JAVA_HOME” e seu valor será “C:\java\jdk7”, clique em “OK”. Após isso precisamos inserir a pasta bin do JAVA_HOME em nosso PATH, para que possamos usar os comandos da JDK pelo terminal do Windows.

JDK - 4JDK - 5  JDK - 6
Depois disso, você pode abrir o terminal usando “Ctrl + R” e depois digite o comando “cmd”. Com o terminal aberto digite “java -version”.
Verá algo semelhante.

JDK - 7
Isso finaliza a instalação e configuração da JDK.

Instalando e configurando SDK Android

Agora vamos instalar o SDK do Android e uma build tool. Lembre-se que essa instalação será para utilizar o PGS4A, por isso vamos instalar em um diretório específico.

Com a JDK já configurada fica fácil, só ir prosseguindo e depois alterar o local de instalação. Nosso local será o “C:\pgs4a\android-sdk”. Nessa pasta “C:\pgs4a” que vamos fazer a instalação do Pygame Subset 4 Android.

SDK - 1

Depois disso você verá o “Android SDK Manager”, que é onde instalaremos nosso build-tool (“Ferramenta de Construção”) que é quem vai gerar o APK. Aqui no caso essas são as build-tools mais atuais, irei escolher elas mesmas e clicarei em “Install X Packages” que a aplicação irá baixar as build-tools e instalar as mesmas.

SDK - 2
Esse processo irá demorar.
Após ele finalizar já está pronto a configuração.

Instalando e configurando Python

Agora vamos instalar o Python. Vamos deixar o diretório padrão mesmo que é “C:\Python27”. Vamos marcar também a opção “Add python.exe to Path”Python - 1
Podemos verificar a instalação da mesma forma que no JDK, abrindo o terminal e digitando “python –version”.
Python - 2

Instalando e configurando Pygame

Para a instalação do Pygame basta prosseguir com a instalação padrão. (Pygame 1.9.1 Windows 32 python 2.7)
Pygame - 1

Instalando e configurando PGS4A

Primeiramente vamos extrair o pgs4a e vamos copiar seu conteudo para a pasta “C:\pgs4a”. Que ficará dessa forma:
PGS4A - 1
Agora vamos abrir o Terminal, e ir na pasta “cd C:\pgs4a”, e vamos usar o comando “python android.py installsdk”, que vai começar a baixar as dependências e build-tools específicas do PGS4A.
PGS4A - 2
Depois de finalizado ainda no terminal ele irá perguntar sobre criar uma chave (key)
PGS4A - 3
Escolha “yes”, e depois você verá uma pergunta sobre o android.keystore “keep it in a safe place”, que é manter em um local seguro, responda “yes” também. Digite o nome da sua organização ou nick do desenvolvedor.
E pronto, tudo configurado.

Gerando APK de Exemplo

Primeiramente baixe as imagens utilizadas nesse exemplo link sprites.
O Código de exemplo que vamos utilizar é esse.

# *-* coding: utf-8 *-*
import pygame
from pygame.locals import *
# Importando o modulo android, específico para android
try:
    import android
except ImportError:
    android = None

TIMEREVENT = pygame.USEREVENT

# FPS
FPS = 30

#Cores
COR_TRANSPARENTE = (100,100,100,128)

RED = (255, 0, 0, 255)
GREEN = (0, 255, 0, 255)
BLUE = (0,0,255,255)
WHITE = (255,255,255,255)
BLACK = (0,0,0,255)
YELLOW = (255, 255, 0, 255)
AZUL_CLARO = (0, 255, 255, 255)
ROXO = (255, 0, 255, 255)

color = RED

LARGURA = 800
ALTURA = 480

pygame.init()
screen = pygame.display.set_mode((LARGURA, ALTURA))
pygame.key.set_repeat(1, 10)


class Controle():

    def __init__(self, largura, altura):
        tamanho_botao = 80
        espacamento = 50
        X_CIMABAIXO = 150
        Y_BAIXO = altura - tamanho_botao
        Y_CIMA = altura - (2*tamanho_botao) - ( espacamento *2 )
        Y_ESQUERDADIREITA = altura - (2*tamanho_botao) - int(espacamento / 10)
        X_ESQUERDA = X_CIMABAIXO - ( espacamento *2 )
        X_DIREITA = X_CIMABAIXO + ( espacamento *2 )

        X_ACAO1 = LARGURA - ( espacamento *2 ) - int( tamanho_botao * 1.75 )
        X_ACAO2 = LARGURA - ( espacamento *2 )

        self.botao_cima = pygame.Rect(X_CIMABAIXO,Y_CIMA,tamanho_botao,tamanho_botao)
        self.botao_baixo = pygame.Rect(X_CIMABAIXO,Y_BAIXO,tamanho_botao,tamanho_botao)
        self.botao_esquerda = pygame.Rect(X_ESQUERDA,Y_ESQUERDADIREITA,tamanho_botao,tamanho_botao)
        self.botao_direita = pygame.Rect(X_DIREITA,Y_ESQUERDADIREITA,tamanho_botao,tamanho_botao)

        self.botao_acao1 = pygame.Rect(X_ACAO1,Y_ESQUERDADIREITA,tamanho_botao,tamanho_botao)
        self.botao_acao2 = pygame.Rect(X_ACAO2,Y_ESQUERDADIREITA,tamanho_botao,tamanho_botao)
        self.cor = None

    def evento(self, evento, cor):
        if evento.type == pygame.MOUSEBUTTONDOWN:
            pos = pygame.mouse.get_pos()
            if(self.botao_cima.collidepoint(pos)):
                self.cima()
            if(self.botao_baixo.collidepoint(pos)):
                self.baixo()
            if(self.botao_esquerda.collidepoint(pos)):
                self.esquerda()
            if(self.botao_direita.collidepoint(pos)):
                self.direita()
            if(self.botao_acao1.collidepoint(pos)):
                self.acao1()
            if(self.botao_acao2.collidepoint(pos)):
                self.acao2()
        elif evento.type == pygame.MOUSEBUTTONUP:
            self.botao_solto()
        elif evento.type == KEYDOWN:
            keys = pygame.key.get_pressed()
            if keys[K_UP]:
                self.cima()
            if keys[K_DOWN]:
                self.baixo()
            if keys[K_LEFT]:
                self.esquerda()
            if keys[K_RIGHT]:
                self.direita()
            if keys[K_LSHIFT]:
                self.acao1()
            if keys[K_LCTRL]:
                self.acao2()
        elif evento.type == KEYUP:
            self.botao_solto()

    def cima(self):
        self.cor = GREEN
    def baixo(self):
        self.cor = BLUE
    def esquerda(self):
        self.cor = YELLOW
    def direita(self):
        self.cor = BLACK
    def acao1(self):
        self.cor = AZUL_CLARO
    def acao2(self):
        self.cor = ROXO
    def botao_solto(self):
        self.cor = RED

    def desenha(self, screen):
        if(self.cor):
            screen.fill(self.cor)
        superficie = pygame.Surface((LARGURA, ALTURA))
        superficie.fill(COR_TRANSPARENTE)
        superficie.set_colorkey(COR_TRANSPARENTE)
        pygame.draw.rect(superficie, WHITE, self.botao_cima)
        pygame.draw.rect(superficie, WHITE, self.botao_baixo)
        pygame.draw.rect(superficie, WHITE, self.botao_esquerda)
        pygame.draw.rect(superficie, WHITE, self.botao_direita)
        pygame.draw.rect(superficie, WHITE, self.botao_acao1)
        pygame.draw.rect(superficie, WHITE, self.botao_acao2)
        superficie.set_alpha(60)
        screen.blit(superficie, (0, 0))

def main():
    # Mapeando o botao voltar do android como K_ESCAPE (ESC)
    if android:
        android.init()
        android.map_key(android.KEYCODE_BACK, pygame.K_ESCAPE)

    # Usando timer para controlar os FPS
    pygame.time.set_timer(TIMEREVENT, 1000 / FPS)

    # A cor da tela
    global color
    controle = Controle(LARGURA,ALTURA)
    while True:

        ev = pygame.event.wait()

        # Especifico para android
        if android:
            if android.check_pause():
                android.wait_for_resume()

        if ev.type == TIMEREVENT:
            screen.fill(color)
            controle.desenha(screen)
            pygame.display.flip()
        else:
            controle.evento(ev, color)

        if (ev.type == pygame.KEYDOWN and ev.key == pygame.K_ESCAPE) or ev.type == pygame.QUIT:
            break

if __name__ == "__main__":
    main()

Link do Projeto Github

Vamos criar a pasta do nosso projeto, vamos criar nossa pasta em “C:\projeto”, após isso vamos colocar os nossos sprites (imagens) nessa pasta, e vamos criar o arquivo principal que é o “main.py”, basta criar um arquivo com esse nome em branco, utilize o notepad, sublime, ou notepad++. Depois você pode colar o código acima, e então vamos configurar a estrutura do projeto para o PGS4A.

Vamos abrir o terminal e ir até a pasta “C:\pgs4a”. Vamos utilizar o comando “python android.py configure C:\projeto”, onde o C:\projeto é onde se encontra o nosso projeto com o arquivo main.py e nossos sprites.
Logo após o terminal irá perguntar qual o nome completo de sua aplicação. Aqui no caso vou utilizar “Exemplo”.

Após isso outra pergunta referente ao nome reduzido de sua aplicação, ele que aparecerá nos atalhos e no launcher.Vou só apertar Enter, que ele irá pegar a resposta anterior.

Depois vem uma pergunta referente ao pacote da aplicação, quem conhece Java sabe que os arquivos fonte são organizados em pacotes, vamos usar “br.org.exemplo”.

A próxima pergunta é referente a versão da aplicação. Vamos colocar “1.0.0”.

A próxima pergunta é referente a versão numérica inteira, vamos utilizar “1”.

A próxima pergunta é referente ao modo de exibição da tela. Se será em modo Paisagem (“Landscape”) escolha 1, se for Retrato (“Portrait”) escolha 2, em nosso exemplo você pode escolher “1”.

A próxima pergunta é se você gostaria de criar um APK de expansão. Em nosso exemplo vamos escolher a opção “1”.

A pergunta agora é referente ao armazenamento dos arquivos da aplicação. Vamos escolher a opção “1”.

O próximo questionamento é referente se você deseja embutir o arquivo python (“.py”) dentro de sua aplicação, vamos escolher “no”.

A próxima pergunta é referente as permissões necessárias de sua aplicação, as escolhas possíveis são VIBRATE e INTERNET, em nosso caso vamos passar com o Enter.

A próxima pergunta é se desejamos incluir SQLite3 a nossa aplicação, que é um banco de dados, nosso exemplo não precisa disso, então vamos marcar “no”.

A próxima pergunta é se desejamos incluir a biblioteca Python Image Library (PIL), nossa aplicação de exemplo não utiliza esse cara então vamos marcar “no” também, e assim finaliza a configuração de nosso projeto.

CONFIG - 1

Depois de configurado e com nosso arquivo main.py e os sprites na pasta e nosso projeto configurado podemos gerar nosso primeiro APK.

Ainda no terminal vamos digitar o seguinte comando “python android.py build C:\projeto release” e depois nosso apk estará compilado na pasta “C:\pgs4a\bin”.

Resultado

Detalhe importante, também é possível fazer a geração do APK e já fazer a instalação em seu dispositivo, com ele conectado em modo depuração e com os devidos drivers instalados. Só or curiosidade o comando seria “python android.py build C:\projeto release install”.

Também é possível utilizar o Logcat que é uma aplicação para visualizar o log da aplicação em tempo real com o dispositivo conectado, você pode utilizar o comando “python android.py logcat”.

Bem esse foi o tutorial de uma aplicação de exemplo utilizando Python + Pygame e o PGS4A para gerar o APK.
Espero que deem uma olhada no código fonte, para ver a construção dos botões que estão recebendo os cliques, e a aplicação também pode ser executada no computador basta digitar “python main.py” dentro do diretório “C:\projeto”.

Espero que tenham gostado.

Anúncios

Um comentário sobre “Android + Python e Pygame

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s