Curso de Kivy Framework: Persistência de Dados

Vamos construir uma Classe de Temas para o Kivy, que continua até mesmo para quando fechar o Aplicativo e abrir novamente, preservando o tema aplicado.

Vamos personalizar a interface do Kivy para que ele receba cores vivas e intuitivas e realçar botões e textos com cores pré estabelecidas.

O que vamos aprender por aqui:

• Criação de Widgets como Buttons, Labels, Layouts
• Extendendo classes já presentes no Kivy por padrão
• Criação de Base de Dados local com SQLite3
• Codificação de Classes e Métodos em Python
• Lançar o App para testar e ver a Aplicação em Tempo de Execução
• Usar o ScreenManager e Screens para gerir as Telas
• Usar a Kv Language: Linguagem oficial do Kivy Framework

Estrutura Física e Lógica do Aplicativo

O Aplicativo terá três arquivos:

• main.py -> classe principal do projeto
• temas.kv -> interface gráfica do projeto
• data.db -> base de dados criada ao longo do projeto

Estes arquivos acima com exceção do "data.db" são criados fisicamente na pasta do projeto por você mesmo quando começar a codificar este projeto proposto.
O arquivo "data.db" é criado ao longo da evolução do aplicativo, automaticamente quando o algoritmo criar as estruturas da tabela de banco de dados SQL.

As bibliotecas que vamos Utilizar

Edite o arquivo main.py com seu editor de texto favorito, em seguida escreva estas linhas abaixo para você poder editar as bibliotecas necessárias para funcionamento do projeto proposto:

from kivy.app import App 	
from kivy.lang.builder import Builder
from kivy.uix.screenmanager import Screen, ScreenManager
from kivy.properties import StringProperty, ColorProperty
import sqlite3

Agora vamos entender para que cada linha acima serve:
primeiro importamos a classe de Aplicativo Kivy, é a classe base principal do framework.

Em seguida temos classe Builder, que serve além de outras coisas para podermos importar o código da Kv Language, que é a composição e ordenamentos dos elementos "widgets" da interface gráfica do Kivy.

Depois na próxima linha seguinte temos a importação da classe ScreenManager, que é o gestor de Telas do Kivy, que permite a transição de telas por meio desta classe, da classe Screen: cada tela, com a possibilidade de eleger a tela atual, e a animação ou efeito de transição de uma tela para a outra.

Na penultima linha acima temos a importação das classes de proprieades StringProperty: para criação de variáveis do tipo texto e ColorProperty esta classe permite a criação de objetos do tipo Cor que como valor se escreve o endereço da respectiva cor em hexadecimal. Vamos utilizar ambas ao longo do projeto de apliação proposta.

Em seguida temos aqui a classe que lida com o SQLite, a base de dados local da aplicação, para inserir tabelas (linhas e colunas) com a estrutura de dados, modelagem e definição dos dados gerados ao longo do uso da aplicação.

Estrutura completa do Aplicativo

from kivy.app import App 	
from kivy.lang.builder import Builder
from kivy.uix.screenmanager import Screen, ScreenManager
from kivy.properties import StringProperty, ColorProperty
import sqlite3

Builder.load_file("temas.kv")

class ScreenManager(ScreenManager):
	pass
	
class Sc_Temas(Screen):	
	def __init__(self, **kwargs):
		super(Sc_Temas, self).__init__(**kwargs)
		pass
		
	def setar_tema(self, pl, color):
		pass
		
	def setar_claridade(self, claridade):
		pass
	
	def inserir_tema(self):
		pass
		
	def criar_tabelas_de_tema(self):
		pass

class eBook(App):
	cor_primaria = ColorProperty("#00CCDD")
				
	def aplicar_tema(self):
		pass
								
	def build(self):			
		self.cor_primaria = "#CF00FD"
		self.scm = ScreenManager() 
		self.aplicar_tema()
		self.scm.current = "sc_temas"
		return self.scm
		
if __name__ == "__main__":
	eBook().run()		

Esta é apenas a estrutura lógica da aplicação, não lance ainda o Aplicativo porque ainda falta preencher estas estruturas e adicionar a interface gráfica por meio da Kv Language.

O Método build()

Note que apenas deixei agora por completo o método build da classe App. Intencionalmente porque esta classe é onde se lança todo a estrutua do Aplicativo pela primeira vez que será inicializado.

Estabelecemos o objeto cor_primaria que será a cor escolhida para o tema principal da aplicação, uma vez estabelecida aqui, esta cor poderá ser utilizada para definir a aparência de fundo de layouts, fundo de botões e a cor ou fundo de textos em rótulos, os Labels.

Estabelecemos o objeto que inicializa o ScreenManager

Aplicamos o tema escolhido previamente por padrão para lançar a aplicação já com o novo tema.

Estabelecemos qual será a tela atual a tela da Sc_Temas, que por seguinte possui o id sc_temas e name: "sc_temas".

E finalmente lançamos o Screen Manager para exibir a tela que já criamos no algoritmo.

A Kv Language importa a Interface Gráfica do Projeto

Vamos conhecer agora a Linguagem oficial do Kivy para a criação de Interface Gráfica: A Kv Language, que por meio da classe Build, podemos de várias formas criar os elementos que vão compor a parte visual do Kivy, é uma importante e principa classe destacada entre as demasi porque o Kivy é um framework Gráfico, e esta solução está integrada no framework com estes recursos e funcionalidade.

Builder.load_file("temas.kv")

Que escrita opcionalmente fora do escopo das classes e objetos, pode estar localizada imediatamente após a importação das classes principais. Que, nesta linha acima importa para dentro da aplicação o arquivo "temas.kv" para compor a interface gráfica da tela Sc_Temas, que vamos escrever em detalhes logo mais.

O ScreenManager e a Screen Principal

Mas então, Agora vamos conhecer como funciona o ScreenManager, da mesma classe do ScreenManager, podemos importar também do mesmo código a classe Screen, em seguida vamos criar a tela que queremos para ser a tela de seleção de Temas, para a escolha da cor preferida e principal do Aplicativo:

class Sc_Temas(Screen):	
	pass

Que cria a estrutura lógica da tela Sc_Temas. No entanto a tela ainda possui alguns métodos que você pode verificar os nomes de inicialização nas linhas mais acima já escritas brevemente neste presente Curso. Que após termos evoluido na implementação vamos discorrer com mais profundidade sobre cada método.

Agora vamos adicionar o código do arquivo "temas.kv":

#:import hex kivy.utils.get_color_from_hex

<ScreenManager>:
	Sc_Temas:
		id: sc_temas
		name: "sc_temas"

<Sc_Temas>:
	VerticalLayout:		
		ScrollView:
			size_hint_y: 0.9
			height: 2000
			GridLayout:
				cols: 2
				margin: "5dp"
				padding: "5dp"
				spacing: "5dp"
				ColorButton:
					id: btn_red
					text: "Vermelho"

A primeira linha do código acima importa um método utilitário do Kivy para lidar com valores hexadecimais, que será muito útil para nós criarmos objetos do tipo Cores por meio da ColorProperty, e adicionarmos esta cor principal em algum Widget do Kivy.

No código acima foi adicionamento sumariamente um código inicial para a composição da tela Sc_Temas, e adicionamos esta tela Sc_Temas ao ScreenManager, note que esta tela tem o id: sc_temas e name: "sc_temas". Que já possui alguns poucos Widgets de demonstração que abordaremos em mais detalhes logo mais.

Note esta estrutura: criamos a importação do ScreenManager na classe principal em Python, criamos a classe do ScreenManager com o id que vamos utilizar, em seguida partimos para o arquivo .kv que adicionamos a classe do ScreenManager que deve ter o mesmo nome de identificação que já criamos e adicionamos nesta classe as telas que vamos utilizar.

Extendendo a classe BoxLayout

Agora, no arquivo temas.kv", vamos criar uma implementação altamente relevante do Kivy, que é a extensão de determinada classe, aqui vamos criar duas classes que de forma customizada teremos os efeitos que desejamos: Aplicar o tema da cor de fundo que desejarmos. O Kivy possui uma classe de layout que tem o nome BoxLayout, este Widget do Kivy permite adicionar e organizar objetos (outros Widgets) de forma que empilha elementos (BoxLayout vertical) e enfileira objetos (BoxLayout horizontal).

Com esta abordagem podemos criar as classes VerticalLayout e HorizontalLayout que são as novas BoxLayouts que vamos extender e reutilizar com este novo comportamento e atributos.

Então, teremos a seguinte implementação na Kv Language para a extensão e criação de VerticalLayout e HorizontalLayout, que não existiam, mas agoram ganham vida com nossa própria expertize no Kivy Framework:

	

<VerticalLayout@BoxLayout>:
	orientation: "vertical"
	margin: "5dp"
	padding: "5dp"
	margin: "5dp"	
	canvas:
		Color: 
			rgba:   hex("#D5FFD4") if app.claridade == "Light" else hex("#000000")
		Rectangle:
			size: self.size
<HorizontalLayout@BoxLayout>:
	orientation: "horizontal"
	margin: "5dp"
	padding: "5dp"
	margin: "5dp"	
	canvas:
		Color: 
			rgba:   hex("#D5FFD4") if app.claridade == "Light" else hex("#000000")
		Rectangle:
			size: self.size

Explicando o código acima, eu posso lhe informar para você o seguinte: Nas próximas abordagens você vai poder assimilar e fixar este mecanismo e estrutura: entre os simbolos "<" e ">" Adicionamos a classe que queremos seguido de um "@" e o nome da classe principal de qual queremos extender a nova classe, lembre-se que esta classe principal se faz uso de que ela já esteja presente no Kivy, ou esteja presente em seu código fonte, caso contrário não seria possivel criar a extensão.

O atributo de orientação "vertical" é para um layout vertical e o atributo de orientação "horizontal" é para criarmos um layout horizontal e O atributo margin, padding e spacing que possuem o valor "5dp" são para que estes elementos que forem inclusos no layout possuam um espaçamento em densidade de pixels que organizam estes elementos entre eles.

E, de forma complementar, ainda temos uma região do tipo Rectangle que será preenchida no objeto canvas, que, com uma condição "se" em única linha, podemos aplicar a cor principal em cima deste retângulo, que será a área total ocupada pelo layout.

Extendendo a classe Label

De forma análoga como já foi explicado anteriormente, agora vamos criar a extensão do rótulo para podermos adicionar um comportamento único para nosso Label: receber uma cor de texto selecionada:

	
<RotuloPrimario@Label>:
	color: app.cor_primaria
	bold: True

Que cria o Rótulo como queremos, agora podemos adicionar este mesmo rótulo quantas vezes acharmos necessário, e em todo tipo de layout que quisermos.

Extendendo a classe Button

Trata-se de um Botão para a seleção de Cores específicas, este botão terá o texto de cor escura, será em negrito, e sem o efeito de fundo normal. Cada cor do tema será selecionada por um botão deste, e terá cada um destes botões a cor de fundo especializada.

	
<ColorButton@Button>:
	color: (1,1,1,1)
	bold:True
	size_hint:(0.3, 0.3)
	background_normal: ""

De forma análoga ao que já expliquei anteriormente crie os botões para aplicação dos temas claro e escuro, que podem ser classes vazias da seguinte forma.

	
<ButtonSetarClaro@Button>:					


<ButtonSetarEscuro@Button>:

Criando a Tela de Temas

Agora que já criamos os elementos extendidos, podemos compor toda a tela de temas, será um código um pouco longo, mas se trata da estrutura da Tela que poderemos escolher o tema mais apropriado para os Elementos que podemos alterar a cor com implementação da API de programação do Kivy.

O código completo da Tela Sc_Temas você confere logo abaixo, lembre-se de adicionar as estruturas que já mencionamos aqui: o ScreenManager e os Widgets Extendidos:

	
<Sc_Temas>:
	VerticalLayout:		
		ScrollView:
			size_hint_y: 0.9
			height: 2000
			GridLayout:
				cols: 2
				margin: "5dp"
				padding: "5dp"
				spacing: "5dp"
				ColorButton:
					id: btn_red
					text: "Vermelho"
					color: (0,0,0,1)					
					background_color:"#f44336"					
					on_press: 
						root.setar_tema("Red", "#f44336")					
				ColorButton:
					id: btn_pink
					text: "Rosa"
					color: (0,0,0,1)					
					background_color: "#e91e63"					
					on_press: root.setar_tema("Pink", "#e91e63")
				ColorButton:
					id: btn_purple
					text: "Roxo"
					color: (0,0,0,1)										
					background_color: "#9c27b0"					
					on_press: root.setar_tema("Purple", "#9c27b0")	
				ColorButton:
					id: btn_dpurple
					text: "Roxo Escuro"
					color: (0,0,0,1)					
					background_color: "#673ab7"				
					on_press: root.setar_tema("DeepPurple", "#673ab7")
				ColorButton:
					id: btn_indigo 
					text: "Azul Escuro"
					color: (0,0,0,1)										
					background_color: "#3f51b5"					
					on_press: root.setar_tema("Indigo", "#3f51b5")
				ColorButton:
					id: btn_blue 
					text: "Azul"
					color: (0,0,0,1)					
					background_color: "#2196f3"					
					on_press: root.setar_tema("Blue", "#2196f3")
				ColorButton:
					id: btn_lblue
					text: "Azul Claro"
					color: (0,0,0,1)					
					background_color: "#03a9f4"					
					on_press: root.setar_tema("LightBlue", "#03a9f4")
				ColorButton:
					id: btn_cyan 
					text: "Ciano"
					color: (0,0,0,1)
					background_color: "#00bcd4"					
					on_press: root.setar_tema("Cyan", "#00bcd4")
				ColorButton:
					id: btn_teal
					text: "Azul Cinzento"
					color: (0,0,0,1)									
					background_color: "#009688"
					on_press: root.setar_tema("Teal", "#009688")
				ColorButton:
					id: btn_green
					text: "Verde"
					color: (0,0,0,1)					
					background_color: "#4caf50"					
					on_press: root.setar_tema("Green", "#4caf50")
				ColorButton:
					id: btn_lgreen
					text: "Verde Claro"
					color: (0,0,0,1)										
					background_color: "#8bc34a"					
					on_press: root.setar_tema("LightGreen", "#8bc34a")
				ColorButton:
					id: btn_lime
					text: "Verde Limão"
					color: (0,0,0,1)										
					background_color: "#cddc39"					
					on_press: root.setar_tema("Lime", "#cddc39")
				ColorButton:
					id: btn_yellow
					text: "Amarelo"
					color: (0,0,0,1)					
					background_color: "#ffeb3b"					
					on_press: root.setar_tema("Yellow", "#ffeb3b")
				ColorButton:
					id: btn_amber
					text: "Amarelo Escuro"
					color: (0,0,0,1)										
					background_color: "#ffc107"					
					on_press: root.setar_tema("Amber", "#ffc107")
				ColorButton:
					id: btn_orange
					text: "Laranja"
					color: (0,0,0,1)										
					background_color: "#ff9800"					
					on_press: root.setar_tema("Orange", "#ff9800")
				ColorButton:
					id: btn_dorange
					text: "Laranja Escuro"
					color: (0,0,0,1)
					background_color: "#ff5722"
					on_press: root.setar_tema("DeepOrange", "#ff5722")
				ColorButton:
					id: btn_brown
					text: "Marrom"
					color: (0,0,0,1)					
					background_color: "#795548"					
					on_press: root.setar_tema("Brown", "#795548")
				ColorButton:
					id: btn_gray
					text: "Cinza"
					color: (0,0,0,1)										
					background_color: "#9e9e9e"
					on_press: root.setar_tema("Gray", "#9e9e9e")
				ColorButton:
					id: btn_bgray
					text: "Cinza Escuro"
					color: (0,0,0,1)					
					background_color: "#607d8b" 			
					on_press: root.setar_tema("BlueGray","#607d8b") 
				ColorButton:
					id: btn_white
					text: "Branco"
					color: (0,0,0,1)					
					background_color: "#FFFFFF" 					
					on_press: root.setar_tema("White","#FFFFFF") 
				ButtonSetarClaro:
					id: btn_tema_claro
					text: "Tema Claro"
					color: (0,0,0,1)
					bold:True
					size_hint:(0.3, 0.3)
					background_normal: ""
					background_color: "#D0E7AC" 
					on_press: root.setar_claridade("Light")
				ButtonSetarEscuro:
					id: btn_tema_escuro
					text: "Tema Escuro"
					color: (1,1,1,1)
					bold:True
					size_hint:(0.3, 0.3)
					background_normal: ""
					background_color: "#20181A" 				
					on_press: root.setar_claridade("Dark")
		BoxLayout:		
			orientation: "vertical"
			size_hint_y: 0.1	
			RotuloPrimario:
				text: "Demonstra a Seleção..."		

Aplicando temas manualmente

Aqui há uma forma de aplicar um tema manualmente: Selecionar a classe do VerticalLayout ou HorizontalLayout e editar, uma vez que esta classe é a Raiz, e por ser a principal terá o cor padrão de fundo de todo o Aplicativo, que por padrão no Kivy é uma cor escura para o background_color.

Então, substituindo o hexadecimal com a cor do background_color teremos o tema, que aqui escolhemos ser um tema escuro ou claro. Mas pode ser a cor que você desejar.

Outra forma de alterar a cor de fundo de botão, ou cor de texto de rótulos por exemplo é por meio de alterando o respectivo atributo de cor do Objeto, que para o rótulo é o objeto color e assim passamos para ele a cor que desejamos, sendo a cor que está selecionada em "app.cor_primaria", que consiste em um atributo da classe App, o aplicativo atual.

Criando a Base de Dados SQLite

Após importar a classe SQLite3, podemos começar a trabalhar com este Banco de Dados local: no código abaixo inicializamos os objetos da conexão:

	
class eBook(App):
	conexao = sqlite3.connect("data.db")
	cursor = conexao.cursor()

A nossa Aplicação tem o nome eBook, e há duas propriedades de objeto chamadas conexao e cursor, que cria uma conexao com o banco de dados em um arquivo que tem o nome "data.db", localizado no diretório raiz da aplicação.

Como você já pode ter lido, aqui em Nosso projeto tem alguns métodos em que você poderá entender a lógica de funcionamento da aplicação. A saber os seguintes métodos.

• __init__()
• criar_tabelas_de_tema())
• inserir_tema()
• setar_tema()
• setar_claridade()

O método __init__(), como o nome sugere inicializa a classe bem como os objetos e atributos principais.

O método criar_tabelas_de_tema() cria a estrutura da tabela em que vamos utilizar no banco de dados local SQLite

O méto inserir_tema() insere o dado com a respectiva cor, tema e claridade na base de dados.

O método setar_tema() aplica o tema desejado na aplicação.

O método setar_claridade aplica os temas claros ou escuro na Aplicação.

Que você pode analisálos com detalhes e respectivamente as linhas e estrutura lógica na íntegra abaixo:

Que, a classe App completa, com os objetos de cores em um dicionário no método aplicar tema, temos o seguinte código inteiro em python da aplicação que ilustra o projeto principal e em seguida o código completo da interface gráfica:

	
from kivy.app import App 
from kivy.uix.screenmanager import Screen, ScreenManager
from kivy.lang.builder import Builder
from kivy.core.window import Window
import sqlite3
from kivy.properties import StringProperty, ColorProperty

Builder.load_file("temas.kv")

class ScreenManager(ScreenManager):
	pass

class Sc_Temas(Screen):	
	def __init__(self, **kwargs):
		super(Sc_Temas, self).__init__(**kwargs)
		self.current_app = App.get_running_app()
		self.conexao = self.current_app.conexao
		self.cursor = self.current_app.cursor
		self.criar_tabelas_de_tema()
		
	def criar_tabelas_de_tema(self):
		sql_table = """CREATE TABLE IF NOT EXISTS tb_themes(
		id integer PRIMARY KEY,
		theme text NOT NULL,
		palette text NOT NULL,
		claridade text NOT NULL)"""
		self.current_app.conexao.execute(sql_table)
		self.current_app.cursor.execute("SELECT * FROM tb_themes")
		data = self.current_app.cursor.fetchall()
		if len(data)==0 or data==None:
			self.inserir_tema()
	
	def inserir_tema(self):
		sql_default = "INSERT INTO tb_themes(id, theme, palette, claridade) VALUES ('1', 'Blue', '#2196f3', 'Light');"
		self.current_app.cursor.execute(sql_default)
		self.current_app.conexao.commit()
		
	def setar_tema(self, pl, color):
		sql_update = "UPDATE tb_themes SET palette = ? WHERE id = ?;"
		self.current_app.cursor.execute(sql_update, (pl,'1'))
		self.current_app.conexao.commit()
		self.current_app.cor_primaria = color
		
	def setar_claridade(self, claridade):
		sql_update = "UPDATE tb_themes SET claridade = ? WHERE id = ?;"
		self.current_app.cursor.execute(sql_update, (claridade,'1'))
		self.current_app.conexao.commit()
		self.current_app.claridade = claridade

class eBook(App):
	conexao =sqlite3.connect("data.db")
	cursor = conexao.cursor()
	tema_ativo = StringProperty("")
	cor_primaria = ColorProperty("#00CCDD")
	tema_claro = ColorProperty("#A0B0C0")
	tema_escuro = ColorProperty("#FFFFFF")
	claridade = StringProperty("")
				
	def aplicar_tema(self):
		color_dict = {"theme": ["Light", "Dark"], "color": [["Red", "#f44336"], ["Pink", "#e91e63"], ["Purple", "#9c27b0"], ["DeepPurple", "#673ab7"], ["Indigo", "#3f51b5"], ["Blue", "#2196f3"], ["LightBlue", "#03a9f4"], ["Cyan", "#00bcd4"], ["Teal", "#009688"], ["Green", "#4caf50"], ["LightGreen", "#8bc34a"], ["Lime", "#cddc39"], ["Yellow", "#ffeb3b"], ["Amber", "#ffc107"], ["Orange", "#ff9800"], ["DeepOrange", "#ff5722"], ["Brown", "#795548"], ["Gray", "#9e9e9e"], ["BlueGray","#607d8b"], ["White","#FFFFFF"]]}			
		sql_theme = "SELECT theme, palette, claridade FROM tb_themes WHERE id = '1';"
		self.cursor.execute(sql_theme)
		data =self.cursor.fetchall()
		if len(data)==0 or data==None:
			self.inserir_tema()
		else:
			for dt in data:
				for cl in color_dict["color"]:
					if dt[2] == color_dict["theme"][0]:
						self.claridade = "Light"
					elif dt[2] == color_dict["theme"][1]:
						self.claridade = "Dark"							
					if dt[1] == cl[0]:						
						self.cor_primaria = cl[1]
								
	def build(self):	
		Window.size = (360, 690)		
		self.cor_primaria = "#CF00FD"
		self.scm = ScreenManager() 
		self.aplicar_tema()
		self.scm.current = "sc_temas"
		return self.scm
		
if __name__ == "__main__":
	eBook().run()

Aplicando Temas com um Clique

Agora que a Aplicação está completa, e após uma lida cuidadosa no código para você poder assimilar corretamente toda essa teoria de programação, temos que podemos já testar a aplicação, e se tudo estiver correto você poderá ver uma imagem semelhante a tela abaixo:

O aplicativo proposto contém uma única tela: a Sc_Temas", e está é a atual quando se lança o ScreenManager.

Lembrando que para você usar o Kivy se faz necessário que você instale o framework em seu dispositivo, sobre o Python3. No terminal de seu computador digite algo semelhante: python main.py, que no diretório atual da aplicação você poderá testar a Aplicação.

Após clicar em algum botão da telas Sc_Temas, você verá que o rótulo RotuloPrimario se altera a cor de seu texto, e, após clicar em um dos botões ButtonSetarClaro ou ButtonSetarEscuro, respectivamente se altera o tema para claro ou escuro.

Aplicando Temas ao Iniciar a Aplicação

Toda vez Quando a aplicação é lançada, automaticamente se aplica o tema e a cor que previamente já foi selecionada, e estes objetos já estão gravados na base de dados SQLite. Que é justamente o que desejava criar com esta Aplicação proposta.

Considerações Finais e o que fazer a partir daqui

Esta aplicação tem público alvo a dois tipos de pessoas: As que já conhecem linguagem de programação e as que nunca programou coisa alguma, portanto, certamente que você pode ser uma pessoa de um desses grupos, ou seja, este Curso foi desenvolvido exatamente para Você. Se inscreva em meu Canal no Youtube, porque lá tem mais material sobre Kivy e Programação de Jogos e Criação de Vídeos.

Se eu instiguei sua curiosidade do Kivy, visite o Website Oficial do Kivy, instale em seu Dispositivo e aprenda mais sobre este framework por meio da API de Documentação.

Conheça o meu Canal @ZigaMultimedia no Youtube

No Canal Ziga Multimedia no Youtube tem vários outros cursos de Treinamento em Vídeo pagos e gratuitos em que você pode Aprender o Kivy, Conheçar a produção e técnicas de Desenvolvimento de Aplicativos Móveis e Jogos 3D.