Easy - Workshop de Software Livre

Easy: uma API baseada em Python para facilitar o
desenvolvimento de aplicações para a plataforma maemo
Miguel Falcão1 , André Hora1 , Emanuel Filho1 , Mario Hozano1 ,
Luciano Wolf2 , Hyggo Almeida1 , Angelo Perkusich1
1
2
Laboratório de Sistemas Embarcados e Computação Pervasiva
Centro de Engenharia Elétrica e Informática
Universidade Federal de Campina Grande (UFCG)
58.109-900 – Campina Grande – PB – Brasil
Instituto Nokia de Tecnologia (INdT) - 51.020-350 – Boa Viagem – Recife-PE – Brasil
{miguelaugusto,andre,emanuel,hozano,hyggo,angelo}@embedded.ufcg.edu.br
[email protected]
Abstract. This paper presents the Easy API, which provides an abstraction level
to ease the development of applications for the Linux-based maemo platform.
We present examples of using Easy as well as a description of underlying lowlevel tools. Finally, we describe an application that puts several Easy functionalities together.
Resumo. Neste artigo introduz-se a API Easy, que provê uma camada de
abstração para facilitar o desenvolvimento de aplicações para dispositivos
portáteis que utilizam a plataforma maemo, baseada em Linux. São apresentados exemplos de utilização da Easy, assim como as ferramentas de baixo nı́vel
utilizadas pela API. Por fim, apresenta-se um exemplo de aplicação que reúne
várias funcionalidades da Easy.
1. Introdução
Nos últimos anos dispositivos móveis como celulares têm agregado funcionalidades de
outros aparelhos, tornando-se dispositivos com múltiplos propósitos. Nesse sentido, é
possı́vel verificar tais aparelhos reunindo funções para capturar imagens, gravar som,
armazenar dados, tocar músicas, rádio FM, utilizar GPS1 além de realizar ligações
telefônicas. Ao passo em que novas funcionalidades são agregadas, uma maior complexidade no desenvolvimento de aplicações para estes dispositivos é promovida. Afinal, é necessário ao desenvolvedor o conhecimento da interface de acesso a estes recursos e da plataforma de desenvolvimento, além de contar com as limitações de processamento, memória e bateria encontradas no dispositivo que vai executar a aplicação
desenvolvida [Forman and Zahorjan 1994].
As plataformas de desenvolvimento de aplicações para dispositivos móveis são
relativamente recentes e suas informações escassas. Diante disso, a construção de aplicativos para dispositivos que as utilizam torna-se um desafio para muitos desenvolvedores.
O que na visão de alguns parece ser apenas uma adaptação do desenvolvimento de
aplicações para computadores convencionais (desktop), mostra-se extremamente diferente no que se refere à forma de implementação, no acesso aos recursos utilizados e
na estrutura de funcionamento da plataforma. Conseqüentemente, o grau de complexidade para desenvolver tais aplicações é incrementado, tornando necessária a existência de
camadas de abstração, evitando um conhecimento detalhado em determinadas tecnologias
mais complexas ou de mais baixo nı́vel.
Neste artigo introduz-se a API 2 Easy, uma camada de abstração para o desenvolvi1
2
Global Positioning System
Application Programming Interface
mento de aplicações sobre maemo [Maemo 2008], uma plataforma de desenvolvimento
para dispositivos móveis baseada em Linux. A API Easy tem como objetivo principal
prover simplicidade e clareza no acesso aos recursos da maemo, facilitando assim o trabalho para a comunidade de desenvolvedores. Ela é distribuı́da de acordo com a LGPL
e implementada em Python [Lutz and Ascher 2004]. O restante deste trabalho está estruturado da seguinte forma: a Seção 2 faz uma breve apresentação da plataforma maemo e
apresenta o código de um player de vı́deo implementado na mesma. A Seção 3 descreve
a API Easy apresentando sua arquitetura com seus diferentes módulos e exemplos de uso.
A Seção 4 ilustra aplicações mais elaboradas utilizando Easy como um player de vı́deo
implementado com a API. Por fim, a Seção 5 contém considerações finais do trabalho.
2. A Plataforma maemo
A plataforma maemo provê um conjunto de componentes para desenvolvimento para dispositivos móveis baseados em Linux, como os Internet Tablets Nokia 770, N800 e N810.
Atualmente em sua quarta versão, ela é distribuı́da com código aberto, reunindo componentes (frameworks) amplamente utilizados em sistemas convencionais e dispositivos
móveis, como GTK+ [Krause 2007], D-Bus [D-Bus 2008], Hildon [Hildon 2008] entre
outras tecnologias de software livre.
Listagem 1. Player de Vı́deo implementado em Python com GTK+ e GStreamer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import p y g t k , g t k , p y g s t , g s t , h i l d o n
class Video Player :
def
init
( self ) :
window = h i l d o n . Window ( )
window . c o n n e c t ( "destroy" , g t k . m a i n q u i t )
vbox = g t k . VBox ( )
hbox = g t k . HBox ( )
s e l f . entry = gtk . Entry ( )
s e l f . e n t r y . s e t t e x t ( "/home/user/MyDocs/.videos/Nokia_N810.avi" )
s e l f . b u t t o n = g t k . B u t t o n ( "Start" )
s e l f . b u t t o n . c o n n e c t ( "clicked" , s e l f . s t a r t s t o p )
s e l f . movie window = g t k . DrawingArea ( )
window . add ( vbox )
vbox . p a c k s t a r t ( hbox , F a l s e )
hbox . add ( s e l f . e n t r y )
hbox . p a c k s t a r t ( s e l f . b u t t o n , F a l s e )
vbox . add ( s e l f . movie window )
window . s h o w a l l ( )
s e l f . p l a y e r = g s t . e l e m e n t f a c t o r y m a k e ( "playbin" , "player" )
bus = s e l f . p l a y e r . g e t b u s ( )
bus . a d d s i g n a l w a t c h ( )
bus . e n a b l e s y n c m e s s a g e e m i s s i o n ( )
b u s . c o n n e c t ( "message" , s e l f . o n m e s s a g e )
s e l f . b i n = g s t . Bin ( "bin" )
v i d e o s c a l e = g s t . e l e m e n t f a c t o r y m a k e ( "videoscale" )
s e l f . b i n . add ( v i d e o s c a l e )
pad = v i d e o s c a l e . g e t p a d ( "sink" )
g h o s t p a d = g s t . G h o s t P a d ( "sink" , pad )
s e l f . bin . add pad ( ghostpad )
v i d e o s c a l e . s e t p r o p e r t y ( "method" , 1 )
conv = g s t . e l e m e n t f a c t o r y m a k e ( "ffmpegcolorspace" , "conv" ) ;
s e l f . b i n . add ( conv )
s e l f . v i d e o s i n k = g s t . e l e m e n t f a c t o r y m a k e ( "xvimagesink" )
s e l f . b i n . add ( s e l f . v i d e o s i n k )
g s t . e l e m e n t l i n k m a n y ( v i d e o s c a l e , conv , s e l f . v i d e o s i n k )
s e l f . p l a y e r . s e t p r o p e r t y ( "video-sink" , s e l f . b i n )
def s t a r t s t o p ( s e l f , widget ) :
i f s e l f . b u t t o n . g e t l a b e l ( ) = = "Start" :
s e l f . v i d e o s i n k . s e t x w i n d o w i d ( s e l f . movie window . window . x i d )
s e l f . b u t t o n . s e t l a b e l ( "Stop" )
s e l f . p l a y e r . s e t p r o p e r t y ( "uri" , "file://" + s e l f . e n t r y . g e t t e x t ( ) )
s e l f . p l a y e r . s e t s t a t e ( g s t . STATE PLAYING )
else :
s e l f . p l a y e r . s e t s t a t e ( g s t . STATE NULL )
52
53
54
55
56
57
58
59
60
61
62
s e l f . b u t t o n . s e t l a b e l ( "Start" )
d e f o n m e s s a g e ( s e l f , bus , m e s s a g e ) :
t y p e = message . t y p e
i f t y p e = = g s t . MESSAGE EOS :
s e l f . p l a y e r . s e t s t a t e ( g s t . STATE NULL )
s e l f . b u t t o n . s e t l a b e l ( "Start" )
Video Player ()
g t k . gdk . t h r e a d s i n i t ( )
g t k . main ( )
A utilização da maemo no desenvolvimento de novas aplicações se dá através
da linguagem C, caracterı́stica das plataformas Linux. Os desenvolvedores podem criar
aplicações em Python acessando seus componentes através de ligações (bindings) providas pelo projeto PyMaemo [PyMaemo 2008].
Embora seja uma plataforma aberta e baseada em Linux, o acesso aos recursos
dos dispositivos que a utilizam exige um bom nı́vel de experiência com os frameworks
utilizados. Ilustrando esse fato pode-se observar a Listagem 1 que apresenta o código de
um player de vı́deo na linguagem Python (PyMaemo) que utiliza os frameworks GTK+
para construção da interface gráfica (linhas 6 a 20) e GStreamer [GStreamer 2008] para
implementação das funções multimı́dia (linhas 22 a 58). Além de implementar muitas
linhas de código na criação de uma interface gráfica para uma aplicação simples, o desenvolvedor necessita de conhecimentos mais profundos sobre pipelines, bins, pads e sinais
do GStreamer para que possa reproduzir um vı́deo no visor aparelho.
3. A API Easy
Easy é uma API escrita na linguagem Python que tem como objetivo criar uma camada de
abstração para acessar os recursos oferecidos nos dispositivos maemo. Sua arquitetura,
ilustrada na Figura 1, define módulos que acessam os recursos da plataforma através
das ligações (bindings) providas pelo PyMaemo. Enquanto o PyMaemo oferece ligações
para as funções dos componentes GStreamer, D-Bus, Hildon, GTK+, etc., a API Easy
simplifica a utilização dos mesmos através de métodos diretos e intuitivos separados por
módulos de áudio, câmera, rádio, Bluetooth, etc.
Figura 1. Arquitetura da API Easy
Utilizando a API Easy, os desenvolvedores podem aumentar sua produtividade,
criando aplicações de forma rápida e com poucas linhas de código. Easy busca não só
facilitar o desenvolvimento por programadores experientes, mas também tornar possı́vel a
implementação de aplicações por programadores com algum conhecimento da linguagem
Python. Abaixo são descritos com maiores detalhes os módulos da API.
3.1. Áudio
Este módulo encapsula um conjunto de funcionalidades do GStreamer fornecendo
métodos diretos para gravação e reprodução de arquivos de áudio. O módulo ainda inclui
funções para o controle do volume, verificação da posição corrente, do seu tamanho e
funções para busca no arquivo em reprodução.
Um exemplo de implementação é apresentado na Listagem 2, em que com três
linhas de código é possı́vel fazer a gravação do som obtido pelo microfone e em seguida
reproduzi-lo nos alto-falantes do dispositivo. Após carregar os módulos necessários
(Linha 1), é realizada a gravação durante 30 segundos (Linha 2) e, em seguida, sua
reprodução (Linha 3).
Listagem 2. Gravação e reprodução utilizando o módulo de Áudio
1
2
3
from e a s y import a u d i o
a u d i o . r e c o r d ( f i l e n a m e =’my_audio.wav’ , r e c o r d t i m e = 3 0 )
a u d i o . p l a y ( f i l e n a m e =’my_audio.wav’ )
3.2. Câmera
Neste módulo são tratadas as funções referentes à manipulação da câmera do dispositivo
e reprodução de vı́deos. Estão presentes métodos para gravação e reprodução em arquivos
de vı́deo, assim como a captura de fotos. Outras funções que estão incorporadas são: a
mudança de propriedades do vı́deo (brilho, contraste e saturação), busca em arquivo e a
verificação da duração e posição corrente do vı́deo em reprodução.
Assim como o Áudio, este módulo utiliza o framework GStreamer para acessar
os recursos do dispositivo, neste caso a câmera e o visor. O código apresentado na
Listagem 3 exibe a imagem capturada pela câmera no visor do aparelho (Linha 2), realiza a gravação de um vı́deo com 30 segundos (Linha 3) e em seguida o reproduz (Linha
4). Na Linha 5 é capturada uma foto utilizando a câmera.
Listagem 3. Gravação, reprodução e captura de imagem com o módulo Câmera
1
2
3
4
5
from e a s y import c a m e r a
camera . s t a r t ( )
c a m e r a . r e c o r d ( f i l e n a m e =’my_video.avi’ , r e c o r d t i m e = 3 0 )
c a m e r a . p l a y ( f i l e n a m e =’my_video.avi’ )
c a m e r a . c l i c k ( f i l e n a m e =’my_photo.jpg’ )
3.3. Rádio
O módulo Rádio é uma abstração da utilização do chip de rádio FM presente em alguns
dispositivos maemo. As funções presentes no módulo provêem a reprodução de estações
de rádios FM (broadcast) com métodos para sintonização manual, busca automática de
estações e controle de volume.
O código apresentado na Listagem 4 permite inicializar o chip de rádio FM do
aparelho (Linha 2), sintoniza-o com a freqüência de 93.1MHz (Linha 3) e em seguida
realiza a sintonização automática para próxima estação disponı́vel (Linha 4).
Listagem 4. Sintonia de estações de rádio FM utilizando o módulo Rádio
1
2
3
4
from e a s y import r a d i o
radio . s t a r t ()
radio . tune (93100)
radio . next station ()
3.4. Outros módulos
A API Easy possui mais quatro módulos para facilitar a implementação de aplicações na
plataforma maemo. São estes:
• Bluetooth: composto por funções para a manipulação do Bluetooth integrado. Algumas funções disponibilizadas são: descoberta de dispositivos, serviços e transferência de arquivos. O módulo utiliza o projeto LightBlue [LightBlue 2008], uma
API para simplificar o acesso ao Bluetooth em Python.
• Contatos: permite a manipulação dos contatos armazenados no dispositivo
maemo. As principais funções disponibilizadas são: adição, remoção e consultas dos contatos. Utiliza a biblioteca Evolution-Python [PyMaemo 2008].
• E-mail: composto por funções para enviar e-mails através da biblioteca
smtplib.
• UI: permite a criação rápida de interfaces gráficas baseadas em GTK+ utilizando
o projeto Eagle [Eagle 2008].
A página do projeto Easy3 disponibiliza exemplos de utilização de todos os
módulos supracitados. Alguns destes exemplos são ilustrados na Seção 4.
4. Aplicações utilizando a API Easy
O escopo da API Easy não se resume apenas à sua utilização para implementar pequenos
scripts como os apresentados na seção anterior. Projetos mais elaborados com interface gráfica utilizando o módulo UI podem ser implementados, favorecendo a criação de
aplicações com código claro e pequeno. Exemplos de utilização para a API Easy incluem
player de áudio (Figura 2), player/gravador de vı́deo (Figura 3), rádio FM, gerenciador
de contatos, etc. Os exemplos supracitados foram implementadas utilizando apenas os
módulos do projeto Easy e encontram-se no repositório do projeto.
Figura 2. Player de Áudio
Figura 3. Player/gravador de Vı́deo
As interfaces gráficas destes exemplos foram implementadas com Eagle, uma biblioteca Python que ajuda no desenvolvimento de GUIs. O Eagle foi encapsulado integralmente no módulo de UI por apresentar uma filosofia semelhante à do Easy, criando
uma camada de abstração facilitando a criação de GUIs. Observando o código apresentado na Listagem 5 é possı́vel verificar a simplicidade na criação de aplicações utilizando
Easy. O código implementa um player de vı́deos ilustrado na Figura 3. Além das funções
do player a aplicação permite gravar vı́deos capturados pela câmera do dispositivo.
Comparando o player implementado com a API Easy e o apresentado na
Listagem 1 é possı́vel perceber a grande redução no número de linhas de código. Sua
interface gráfica é implementada com apenas 6 linhas (linhas 15 a 21) e as funções de
multimı́dia do player e do gravador de vı́deos correspondem às linhas 3 a 13.
3
http://easy.garage.maemo.org/
Listagem 5. Aplicação mais elaborada utilizando Easy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from e a s y import camera , e a g l e
d e f r e c o r d ( app , b u t t o n ) :
c a m e r a . r e c o r d a s y n c ( app [ ’filename’ ] )
d e f s t o p ( app , b u t t o n ) :
camera . s t o p r e c o r d i n g ( )
d e f p l a y ( app , b u t t o n ) :
c a m e r a . p l a y ( f i l e n a m e = app [ ’filename’ ] )
d e f p a u s e ( app , b u t t o n ) :
camera . pause ( )
app = e a g l e . App ( t i t l e =’Easy Player’ ,
t o p = ( e a g l e . E n t r y ( i d =’filename’ , v a l u e =’/home/user/record.avi’ ) ,
e a g l e . B u t t o n ( i d =’record’ , l a b e l =’Record’ , c a l l b a c k = r e c o r d ) ,
e a g l e . B u t t o n ( i d =’stop’ , l a b e l =’Stop Record’ , c a l l b a c k = s t o p ) ,
e a g l e . B u t t o n ( i d =’play’ , l a b e l =’Play’ , c a l l b a c k = p l a y ) ,
e a g l e . B u t t o n ( i d =’pause’ , l a b e l =’Pause’ , c a l l b a c k = p a u s e ) ) ,
c e n t e r = e a g l e . XWindow ( i d =’xwindow’ ) )
c a m e r a . s e t w i n d o w i d ( app [ ’xwindow’ ] . g e t w i n d o w i d ( ) )
eagle . run ( )
5. Considerações Finais
Atualmente a API Easy encontra-se na versão 0.3 e pode ser executada na plataforma
maemo 3.x. Uma nova versão já está sendo preparada para o maemo 4.0 devido a algumas
modificações realizadas na estrutura da plataforma.
Como trabalhos futuros estão a implementação de novos módulos, incluindo a
manipulação de aplicações com GPS e o tratamento de mensagens instantâneas sob protocolos existentes. Informações sobre contribuições, implementação, cadastro de bugs,
listas de discussão e novidades podem ser obtidas no site do projeto.
6. Agradecimentos
Os autores agradecem ao Instituto Nokia de Tecnologia (INdT) pelo apoio financeiro para
a realização desse trabalho.
Referências
D-Bus (2008). D-Bus. http://freedesktop.org/wiki/Software/dbus. Acessado em
05/03/2008.
Eagle (2008).
Eagle is a python library to help GUI development.
http://gustavobarbieri.com.br/eagle/. Acessado em 05/03/2008.
Forman, G. H. and Zahorjan, J. (1994). The challenges of mobile computing. Computer,
27(4):38–47.
GStreamer (2008).
GStreamer:
open source multimedia framework.
http://gstreamer.freedesktop.org/. Acessado em 05/03/2008.
Hildon (2008). Hildon. http://live.gnome.org/Hildon. Acessado em 05/03/2008.
Krause, A. (2007). Foundations of GTK+ Development. Apress, Berkely, CA, USA.
LightBlue (2008).
Lightblue:
a cross-platform python bluetooth api.
http://lightblue.sourceforge.net/. Acessado em 05/03/2008.
Lutz, M. and Ascher, D. (2004). Learning Python. O’Reilly, 2th edition.
Maemo (2008). Maemo is the application development platform for internet tablets.
http://maemo.org. Acessado em 05/03/2008.
PyMaemo (2008). Python for Maemo. http://pymaemo.garage.maemo.org. Acessado em
05/03/2008.