Desenvolvimento de Apps Python S60

Desenvolvimento de Aplicações
para Dispositivos Móveis

PyS60
Msc. Jonh Edson Ribeiro de Carvalho
06.08.2008
copyleft

Conteúdo 1/2
Introdução
– Python
– Plataforma S60
– Python para S60 (PyS60)‫‏‬

Ambiente de Desenvolvimento
– SDK para a Plataforma S60
– Instalando PyS60 no Emulador
– Instalando PyS60 no Dispositivo Móvel

Primeiro Exemplo: Hello World!
– Emulador (via Interpretador, via Script)‫‏‬
– S60 (via Interpretador, via Script)‫‏‬

Resumo sobre Python

Conteúdo 2/2
Programando com Python para S60
– Bibliotecas e Extensões

– Principais Recursos para Interface Gráfica com o Usuário
• Módulo APPUIFW
• Módulo GRAPHICS

– Principais Serviços/Recursos relacionados ao Symbian OS
• Módulo E32
• Módulo SYSINFO

Como Desenvolver uma Aplicação com Python para S60

Utilizando outros recursos da Plataforma S60

Python (1/4)
Breve Histórico
– Criada por Guido van Rossum em 1990 – Holanda
• Instituto Nacional de Matemática e Computação (CWI)
• Python Software Foundation (PSF): direitos de propriedade intelectual
• Sucessora de uma linguagem chamada ABC
• O nome Python: Monty Python's Flying Circus
• www.python.org, www.pythonbrasil.com.br/moin.cgi/GuidoVanRossum

– Em 1999, com financiamento da DARPA, foram definidos os objetivos:
• Linguagem fácil e intuitiva;
• Código aberto, para que qualquer um possa contribuir para o desenvolvimento;
• Código que fosse tão inteligível quanto inglês;
• Adequada para tarefas diárias, tempo de desenvolvimento mais curto.

– Atualmente, Guido trabalha para o Google.

Python (2/4)
O que é?
– Frequentemente definida como uma linguagem de script.

Algumas Características de Python:
– Interativa;
– Sintaxe compacta, simples e limpa (pseudo-código executável);
– Portável (independente de plataforma);
– Fortemente Tipado x Tipagem Dinâmica;
– Multi-paradigma (conceitos de programação funcional e de OO);
– Extensível (adição de módulos implementados em outras linguagens);
– Tratamento de Exceções;
– Gerenciamento de memória automático.

Python (3/4)
Por que usar?
Qualidade de Software
–
Produtividade do Desenvolvedor
–
Portabilidade
–
Suporte de bibliotecas
–
Componente de Integração
–

Quem usa?
– Google, Youtube, Yahoo!, NASA, MIT, UFCG, ...

Ferramentas?
– IDLE, PyDev (Eclipse), WinPy

Python (4/4)
Onde encontrar?
– Comunidade Mundial: www.python.org

– Comunidade Brasileira: www.pythonbrasil.com.br

– Embedded Academy: www.embeddedacademy.org

– Forum Nokia: www.forum.nokia.com

Postura:

– http://www.pythonbrasil.com.br/moin.cgi/AntesDePerguntar

Primeiro Exemplo
Introduzindo o Interpretador:
– Python além de uma linguagem de programação, também é um pacote de
software chamado Interpretador (programa que executa outros programas);

– O interpretador é uma camada de software lógico entre seu código e o
“hardware” do computador;

– O código Python escrito é executado pelo interpretador.

% python (no terminal – linha de comando)

Python 2.4 (#28, Dec 21 2005, 12:21:22)
Type quot;helpquot;, quot;copyrightquot;, quot;creditsquot; or quot;licensequot; for more information.
>>> print ‘Hello World!’
Hello World
>>>

Execução do Programa
Programa Python = arquivo texto contendo “declarações Python”;

1. print ‘Hello World!’
2. raw_input(‘press any key to exit!’)

Pode-se usar qualquer editor
Tipicamente, nomes de arquivos Python possuem extensão“.py”;
Pode ser executado: $ python hello.py
– via linha de comando; Hello World!
– clicando no ícone;
– Através de um IDE.
#Desviar a saída para um arquivo .txt
$ python hello.py > out.txt

Plataforma S60 (1/2)
Plataforma dedicada para smartphones:
– Interface intuitiva
– Excelentes recursos para criação de software
– Multitarefa
Symbian OS.
Mais de 100 milhões de aparelhos vendidos;
Plataforma dominante para os próximos 5-10 anos (previsão);
Algumas características comuns à maioria dos dispositivos da S60:
– Para operação com apenas uma mão;
– Nokia 3250, 6600, 6681, E61, N73, N95, ...;
– Resolução: 176x208, 208x176, 240x320, 320x240;
– 4096 (ou mais) cores;
– Teclado ITU-T ou circular;
– SMS, MMS, e-mail, calendário, agenda, Notas, etc.

Symbian OS
Sistema operacional dedicado para smartphones
– http://www.symbian.com
– Dispositivos S60
Possui gerenciamento de memória e características multitarefa que
permitem uma operação segura e eficiente sob condições de recursos
reduzidos.
É um Sistema Operacional aberto:
– Permite o desenvolvimento de software de forma livre
Suporta várias linguagens:
– Java;
– Python;
– C++;
– FlashLite;
– OpenC.

Proprietários de Licença para Uso do Symbian OS

Arquitetura da Plataforma S60 (1/3)
Garantia que os elementos específicos serão apresentados em todos
aparelhos baseados na edição da plataforma, conforme a arquitetura.

S60 Platform Services: serviços fundamentais
– Application Framework Services — lançamento de aplicações e servidores,
gerenciamento de dados persistentes.
– UI Framework Services — criação de componentes da UI e manipulação dos
eventos.
– Graphics Services — criação da parte gráfica e desenhos na tela.
– Location Services — localização do dispositivo.
– Web-Based Services — estabelecimento de conexões e interação com
funcionalidades “Web” (navegação, download de arquivos, ...).
– Multimedia Services — Execução de áudio and vídeo.
– Communication Services — comunicação local remota (Bluetooth, Wi-Fi)

S60 Application Services: funcionalidades básicas usadas pelas
aplicações S60
– PIM Application Services — gerenciamento de informações pessoais
(contatos, calendário, bloco de notas, relógio).
– Messaging Application Services — suporte a vários tipos de mensagem( SMS,
MMS, e-mail, ...).
– Browser Application Services — visualização de conteúdo Web, incluindo
suporte para Flash Lite (Adobe), reprodução de vídeo (rendering) e áudio.
S60 Java™ Technology Services:
– Suporte à Plataforma Java™ (J2ME)
– Suporte à APIs para acesso ao sistema de arquivos, PIM, Bluetooth,
Messaging, áudio, vídeo, Web, localização, etc.
S60 Applications: são as aplicações próprias da plataforma disponíveis
ao usuário do aparelho.
– PIM, Messaging, Media Applications, etc.

Edição e Feature Pack (FP)
Dependendo das características presentes em um dispositivo ele se
enquadra em uma determinada edição e em um determinado FP;

Assim, garante-se que um software desenvolvido funcione em todos os
dispositivos da mesma edição e mesmo FP;

Cada edição com seu respectivo FP é associada a uma versão do sistema
operacional Symbian.

Versões da S60
1ª Edição
– Original (Versão 0.9) - Symbian OS v6.1 (7650)
– FP 1 (Versão 1.2) - Symbian OS v6.1 (3660, N-Gage)

2ª Edição
– Original (Versão 2.0) - Symbian OS v7.0s (6600)
– FP 1 (Versão 2.1) - Symbian OS v7.0s (7610)
– FP 2 (Versão 2.6) - Symbian OS v8.0a (6681)
– FP 3 (Versão 2.8) - Symbian OS v8.1a (N70, N90)

3ª Edição
– Original (Versão 3.0) - Symbian OS v9.1 (3250, N93)
– FP 1 (Versão 3.1) - Symbian OS v9.2 (N95)
– FP 2 (Versão 3.2) - Symbian OS v9.3 (N96)

S60: Desenvolvimento de aplicações
C++:
SDK completo (inclusive IDE e compilador) gratuito em http://forum.nokia.com
–
API C++ do Symbian: diferente de POSIX, Win32, etc.
–
Aprendizado mais lento (dialeto de Symbian, gerenciamento de memória, etc.)
–
Requer programadores experientes
–
A nova API OpenC busca atenuar este problema
–
Java:
Desenvolvimento mais rápido em relação à C++
–
API limitada
–
Python propõe um paradigma de programação diferente:
Desenvolvimento mais rápido em relação à Java
–
Projeto de aplicações fácil e rápido (aprendizado mais rápido e intuitivo)
–
Open Source: http://sourceforge.net/projects/pys60
–
Respeita limitações do dispositivo: baixo consumo de memória, etc.
–
Possui biblioteca padrão bastante versátil
–
Permite criar bibliotecas/extensões
–

Python para S60 (1/2)
É ideal para começar a criar aplicações para dispositivos baseados na
plataforma S60;
– Criação de programas que usam as características e recursos dos telefones
Série 60.

Desenvolvimento relativamente simples, fácil e rápido;

É bem adequado para o desenvolvimento de protótipos ou para a
construção de aplicações;

Um conhecimento básico em qualquer linguagem de programação em
script é o bastante para entender a programação de scripts Python e
criar aplicações em um tempo muito curto.

Python para S60 (2/2)

Atualmente, Python para S60 é baseado em Python 2.2
Suporta boa parte da biblioteca padrão de Python (math, por exemplo)
Alguns módulos específicos da plataforma já estão inclusos:
– Widgets GUI nativos, Bluetooth, rede GPRS, informação de localização GSM,
mensagem SMS, câmera, contatos, entre outros;
– Acesso mais fácil aos recursos, em relação a C++.
A depuração no dispositivo é mais fácil
Desempenho pode ser um problema
– Pode-se escrever bibliotecas C para as partes de desempenho crítico
Nem toda a API C++ está coberta
– Mas é possível escrever módulos adicionais (extensões)

Capacidades de PyS60
Elementos da GUI: Menu, Form, Listbox, Input field, Dialog, Note;
Gráficos: cores, atributos font e style, desenho na tela, imagens e
ícones;
Eventos key-up e key-down;
Sockets: TCP/IP, Bluetooth (RFCOMM, OBEX);
Mensagens (SMS);
Rede (HTTP, FTP, …);
Acesso ao sistema de arquivos, leitura de arquivos, XML, RSS;
Acesso a câmera, telefone;
Acesso ao calendário, contatos, informação do sistema;
Localização (cell-id/GPRS), GPS;
Acelerômetro;
Extensões Python são escritas em C++/Symbian.

O que é possível criar?
Aplicações com câmera
Aplicações com áudio
Wi-Fi e GPRS
Bluetooth
Telefonia
Mensagem
Bibliotecas gráficas e teclado
Acelerômetro

Ambiente
de
Desenvolvimento

Desenvolvimento com PyS60
É possível criar um programa python direto no dispositivo móvel;

É possível se conectar por bluetooth e enviar linhas de código para o
dispositivo móvel;

É possível criar um programa python no PC e enviar para o dispositivo
móvel;

Para testar o programa antes de enviá-lo para o dispositivo móvel
usamos um Emulador;

Ambiente de Desenvolvimento: Windows (e Linux? GNUPOC)

SDK para a plataforma S60
Existe um SDK (Software Development Kit) para desenvolvimento de
aplicações para a Plataforma S60 no PC, que inclui um emulador;
Para cada modelo de dispositivo existe um pacote SDK associado à
versão do Symbian OS;
A versão do Symbian OS pode ser verificado no Fórum Nokia:
http://www.forum.nokia.com/devices/matrix_all_1.html

– Depois de identificada a versão do Symbian OS do smartphone, os SDK’s
podem ser baixados também no Fórum Nokia.
http://www.forum.nokia.com/info/sw.nokia.com/id/4a7149a5-95a5-4726-
913a-3c6f21eb65a5/S60-SDK-0616-3.0-mr.html
Versão utilizada neste curso: 3rd Edition (262 MB)

Instalando PyS60 no Emulador (1/3)
Após instalado o SDK do Symbian OS, é necessário instalar o pacote SDK
de python para S60 correspondente:
– http://sourceforge.net/projects/pys60

Versão utilizada: PythonForS60_1_4_3_SDK_3rdEd.zip (Contém o
arquivo sdk_files.zip)

Descompactar sdk_files.zip em: C:Symbian9.1S60_3rd

O diretório C:Symbian deve ter permissões para escrita e leitura

Os scripts Python são colocados no diretório:
<EPOCROOT>Epoc32winscwcpython, onde <EPOCROOT> é o diretório raiz
da instalação do SDK (C:Symbian9.1S60_3rd).

Módulos e scripts de Python a serem executados pelo emulador devem
ser colocados neste diretório ou em um dos seus subdiretórios*.

Testando:
– Abrir o Emulador:
Menu Iniciar→Programas→Series 60 Developer Tools→3rd Edition SDK→1.0→Emulator
– Executar o Python no emulador: Installations→Python

Instalando PyS60 no Dispositivo Móvel
Pacote de instalação PyS60 para o dispositivo móvel:
– http://sourceforge.net/projects/pys60

– Python runtime:
• Interpretador Python (DLL)
• Módulos da biblioteca padrão de Python

– Python Script Shell:
• Ambiente de execução de scripts Python

– O pacote deve ser escolhido de acordo com a Edição e o FP:
• PythonForS60_1_4_3_3rdEd.SIS
• PythonScriptShell_1_4_3_3rdEd.SIS

O arquivo de instalação .sis deve ser instalado no dispositivo móvel;

Programa instalador, que reconhece plug-ins e aplicações para Symbian
escritas em Python (Edições anteriores à 3ª).

PyS60 em Dispositivos S60 3rd Edition (1/2)
Symbian OS v9.x (S60 3rd Edition): controle de segurança mais rígido
– Aplicativos assinados com certificado digital
– Aplicativos têm capabilities e escopo de distribuição embutidos na
assinatura
– http://forum.nokia.com/main/platforms/s60/capability_descriptions.html

Compatibilidade:
– 1ª e 2ª edições são compatíveis com aplicações *.sis.
– 3ª Edição compatível com aplicações *.sisx (e aplicações certificadas *.sis).

Certificado do desenvolvedor assinado pela Symbian Ltd. (Pago)

Certificado auto-assinado impede o uso de algumas capabilities

Aplicativos para distribuição em massa têm de ser homologados pela
Symbian Ltd. (ou seja, mais grana!)

PyS60 em Dispositivos S60 3rd Edition (2/2)
O pacote PyS60 1.4.X é assinado pela Nokia
– Os scripts “herdam” estas capabilities e não precisam ser assinados

Instalar scripts via Bluetooth ou SMS não funciona na 3a Edição
– Aparelhos S60 3rd Edition dão acesso via USB ao cartão de memória do
telefone
– Dica: compactar o script e enviá-lo via Bluetooth, já que o smartphone
pode descompactar o arquivo.

Primeiro Exemplo:
Hello World!

PyS60 no Emulador (1/4)
Menu Iniciar→Programas→Series 60 Developer Tools→3rd Edition
SDK→1.0→Emulator

Pode-se usar PyS60 de duas maneiras no Python Script Shell:
– Console interativo (interpretador)
– Executar um script
Pode-se também criar aplicações standalone a serem instaladas no
emulador
Em opções escolha o interpretador:
>>> print quot;Hello World!quot;
>>>2+2
>>>9-2

Para obter uma lista de scripts Python: Options → Run Script
Então, todos os scripts contidos na pasta Python* são mostrados na tela
(*<EPOCROOT>Epoc32winscwcpython)
Para executar um script basta selecioná-lo e pressionar OK.

Para criar e executar um script próprio, por exemplo com o mesmo
código “hello world!”, deve-se:
– Abrir um editor de texto;
– Escrever o código em Python (print quot;hello worldquot;);
– Salvar o arquivo com a extensão *.py na pasta Python. (hello.py);
– Iniciar o ambiente de execução de Python no emulador e executar o script.

Não é necessário reiniciar o emulador depois que um código é alterado.
Basta reiniciar a aplicação (o Python Script Shell).

Ferramentas de Desenvolvimento
Como é necessário apenas a criação de um arquivo *.py, nenhuma
ferramenta especial de desenvolvimento é necessária;

Um editor de texto simples é suficiente;

Algumas ferramentas ajudam na criação de um *.py:
– Eclipse + PyDev
– IDLE

IDLE
IDLE (Integrated DeveLopment Environment);

Ambiente de desenvolvimento para Python, também criado por Guido
van Rossum;

Funciona em ambas plataformas Unix e Windows;

É possível:
– Executar linhas de código usando o interpretador;
– Executar um script/programa;
– Editar um arquivo *.py;
– Criar um arquivo *.py.

http://www.python.org/idle/doc/idlemain.html

PyS60 no Dispositivo Móvel - 1ª e 2ª edições (1/3)
Os mesmo procedimentos realizados com o emulador podem ser
utilizados no dispositivo móvel

Para se ter scripts no dispositivo móvel pode-se utilizar:
– Um editor no próprio smartphone;
– Usar um editor em um PC e enviar o arquivo Python (*.py) para o
smartphone (1ª e 2ª edições)

O pacote PyS60 possui um instalador (Python Installer Program) que faz
todo o trabalho de instalação de um *.py. (1ª e 2ª edições)
– O instalador já vem com um reconhecedor de tipos MIME (Multipurpose
Internet Mail Extensions)
– Arquivos com extensão .py, .pyc, .pyo ou .pyd são reconhecidos e instalados

Durante a instalação, o instalador pergunta se o arquivo deve ser
instalado como um script Python ou como uma biblioteca de Python

Os arquivos do tipo .pyc, .pyo e .pyd só podem ser instalados como
bibliotecas

Outra forma de instalar um novo script no dispositivo é através da
criação de uma aplicação Python standalone (*.SIS) e enviá-lo para o
smartphone

Com o módulo instalado no smartphone basta abrir o ambiente de
execução de Python e executar o novo script

Deve-se notar que módulos e scripts Python a serem executados no
dispositivo devem ser colocados no diretório:
<drivename>:SystemAppsPython

Para instalar uma extensão Python procede-se da mesma maneira como
para a instalação de um script, tomando cuidado na hora da instalação

PyS60 no Dispositivo Móvel - 3ª edição
Para a 3ª edição alguns procedimentos mudam.

Não existe um reconhecedor e instalador de arquivos *.py

Deve-se notar que módulos e scripts Python a serem executados no
dispositivo devem ser colocados no diretório:
<drivename>:Python

Voltando ao Hello World
Uma versão do Hello World utilizando recursos da plataforma S60
torna-se bastante interessante e pode ser apresentada neste momento
sem maiores dificuldades.

1. import appuifw
2. appuifw.app.title = uquot;Hello Worldquot;
3. appuifw.note(uquot;Hello World!quot;, 'info')

Python para S60 – PyS60
Jonh Edson, M.Sc.

Principais Tópicos
Tipos e Operações
– Números, Strings, Listas, Dicionários, Tuplas, Arquivos, Outros tipos em
Python
Declarações e Sintaxe
– Atribuição
– Expressões
Estruturas de Controle de Fluxo
– if/elif/else
– while
– for
Funções
Módulos
– Pacotes
– imports
Classes

Tipos e operações em Python
Números:
– Inteiros normais são interpretados como Longs em C, isto é, ao menos 32
bits;
– Os inteiros Long (inteiros terminando com a letra L) são ilimitados;
– Números complexos: A parte imaginária pode vir primeiro e a parte real é
opcional.

Módulo math:
Funções trigonométricas(seno, cosseno...);
–
Constantes matemáticas(e, pi...);
–
Conversões (hexadecimal, octal, decimal...);
–
Outras funções matemáticas interessantes(log, sqrt, fabs...).
–

Strings
Strings em Python são como arrays de caracteres em linguagens como a
C;
Python não tem o tipo especial para caracteres simples (como o char de
C);
Strings em Python são categorizados como seqüências imutáveis;
Strings podem ser representados com aspas simples, aspas duplas, três
aspas simples ou três aspas duplas.
Ex: a = “Python” ou b = 'series 60'.
Strings podem ser indexadas;
replace(...), upper(...), split(...).

1. #Declaracao de strings:
2. s = “Python for series 60”
3. s[0]
4. s = s.upper()
5. Lista = s.split()

Listas
Lista é o tipo de coleção ordenada mais flexível de Python;
Ao contrário de strings, as listas podem conter qualquer variação de
objetos: números, strings, outras listas, etc.;
São declaradas usando-se colchetes.
1. #Lista vazia:
2. L1 = [ ]
3. #Lista heterogênea com 3 itens:
4. L2 = [1,’a’,2]
5. #Listas aninhadas:
6. L3 = [‘abc’, [‘def’,’ghi’]]
7. L3[1][1]

Dicionários
São conjuntos em que seus elementos são acessados por chaves;
Tem tamanho variável, é heterogêneo e arbitrariamente aninhável;
Dicionários são escritos como uma série de pares chave:valor,
separados por vírgula e entre chaves.
1. #Criando um dicionário:
2. d = {‘spam’: 2, ’ham: 1, ‘eggs’: 3}
3. #Alterando uma entrada:
4. d[‘ham’] = [‘grill’,’bake’,’fry’]
5. print d
6. #Apagando uma entrada:
6. del d[‘eggs’]
7. print d
8. #Criando uma nova entrada:
9. d[‘brunch’] = ‘Bacon’
10. print d

Tuplas
As tuplas funcionam exatamente como as listas, exceto pelo fato de
que as tuplas são imutáveis;
A tuplas são usualmente escritas como uma série de itens entre
parêntesis e não entre colchetes;

1. #Tupla vazia:
2. a=( )
3. print a
4. #Tupla com um item:
5. a=(1,)
6. print a
7. #Tupla com mais de um item:
8. a=(1,2,3)

Controle de fluxo (1/3)
Testes if:
Principal recurso para seleção de ações alternativas baseado no
resultado do teste;

1. if<teste1>: 1. x=2
2. <declaração1> 2. if x is 1:
3. elif<teste2>: 3. x=x+2
4. <declaração2> 4. elif x is not 2:
5. else: 5. x=x–2
6. <declaração3> 6. else:
7. print x

Laço while:
O else é executado se a execução não saiu do laço com um break.

1. while<teste>:
2. <declaração1> 1. x = 1
3. else: 2. while x <= 5:
4. <declaração2> 3. x=x+1
4. if x == 4:
5. print ‘Saiu do while COM o break!’
6. break
7. else:
8. print ‘Saiu do while SEM o break!’

Laço for:
O else é executado se a execução não saiu do laço com um break.

1. for <var> in <objeto>:
2. <declaração1>
3. else:
4. <declaração2>

1. for item in [‘a’, ‘b’, ‘c’]:
2. print ‘item =’, item
2. if item == ‘c’:
3. print ‘Saiu do for COM o break!’
4. break
5. else:
6. print ‘Saiu do for SEM o break!’

Funções (1/2)
Para criar funções usamos a sentença def;
O corpo das funções freqüentemente possuem a sentença de retorno e
mais de um valor pode ser retornado na mesma função;
Não existe declaração de tipo de retorno e nem de tipo de argumento.

1. #Declaração
2. def times(x, y):
3. return x * y
4.
5. #Chamada
6. print times(2,4)

Funções (2/2)
É possível declarar valores padrões para os parâmetros das funções;
É possível passar o valor do parâmetro especificando o nome.

1. def f1(a, b=2, c=3):
2. print a, b, c
3.
4. f1(1)
5. f1(1,4)
6. f1(1,4,5)
7. f1(1, c=6)

A sentença global
Todo nome atribuído dentro de uma função é local, a não ser que ele
seja declarado como global:

1. X = 88
2. def func( ):
3. global X
4. X = 99
5. func( )
6. print X

Módulos em python
Todo arquivo python com extensao .py é um módulo;
Para que outros arquivos possam acessar os itens definidos em um
módulo usa-se “import”;
Um “import”carrega um outro arquivo (módulo) e permite acesso ao
seu conteúdo (atributos);
Arquitetura baseada em módulos;
Esta operação também executa código Python.

Classes
São descrições de tipos de objetos (métodos e atributos comuns a todos
os objetos da classe);

1. class Calculadora:
2. def __init__(self, x, y):
3. self.x = x
4. self.y = y
5.
6. def soma(self):
7. return self.x + self.y
8.
9. calc = Calculadora(1,2)
10. print calc.soma()

Tópicos
Programando com Python para S60
– Bibliotecas e Extensões

– Principais Recursos para Interface Gráfica com o Usuário
• Módulo APPUIFW
• Módulo GRAPHICS

– Principais Serviços/Recursos relacionados ao Symbian OS
• Módulo E32
• Módulo SYSINFO

Como Desenvolver uma Aplicação com Python para S60

Utilizando outros recursos da Plataforma S60

Programando com
Python para S60

Programação em Python para S60
Todos os tipos nativos da linguagem Python são suportados na
plataforma S60;

PyS60 não inclui todos os módulos da biblioteca padrão de Python
– Economia de espaço de armazenamento no smartphone

Existem dois tipos de extensões nativas de C++ na distribuição PyS60:
– Extensões internas (built-in);
– Extensões dinamicamente carregadas.

Extensões
Existem duas extensões internas no pacote PyS60:
– O módulo (extensão) e32;
– O módulo appuifw.

O módulo e32 implementa interfaces para serviços do Symbian OS;

O módulo appuifw (APPlication User Interface FrameWork) oferece um
conjunto de recursos para a interface gráfica com o usuário;

As extensões dinamicamente carregadas fornecem API’s proprietárias
para serviços da plataforma S60:
– Módulos: graphics, messaging, inbox, location, camera, audio, calendar,
contacts, entre outros.

O Módulo APPUIFW
APPlication User Interface FrameWork;
Layout de uma aplicação UI para S60:

Criando uma aplicação básica
Baixar o pacote Aula_Python.rar
– Imagens + aula.py

import appuifw
– Accesso aos recursos de interface gráfica para aplicações no s60.

import graphics
– Acesso às primitivas gráficas e tratamento de imagem.

import e32
– Acesso a recursos do sistema operacional (Symbian OS)‫‏‬

import sysinfo
– Provê informações do dispositivo móvel

A instância app
appuifw.app: sempre presente;
Atributos:
– body: tipo de componente gráfico do corpo da aplicação (Text, Listbox,
Canvas ou None).
– exit_key_handler: objeto “callable” chamado quando o usuário pressiona a
tecla de saída.
• Valor padrão: None.
– menu: atributo para criação do menu de uma aplicação.
• Pode ser atribuído a uma lista contendo tuplas no formato (title, callback) ou no
formato (title, ((title_submenu, callback), ...)).
– screen: corresponde a área da tela usada pela aplicação.
• Opções de aparência: 'normal', 'large' e 'full';
– title: título (Unicode) da aplicação, visível no title pane.

Image (1/2)
Módulo graphics
– Recursos gráficos primitivos, carregamento, armazenamento e
redimensionamento de imagens.
Classe graphics.Image
– classe para manipular imagens
Image.new(size[, mode='RGB16']): cria e retorna um objeto Image
com tamanho size (tupla de dois elementos), e modo de cores mode.
mode pode receber as seguintes strings:
– '1' (preto e branco – 1 bit por pixel);
– 'L' (256 cores em escala de cinza – 8 bits por pixel);
– 'RGB12' (4096 cores – 12 bits por pixel);
– 'RGB16' (65536 cores – 16 bits por pixel);
– 'RGB' (16.7 Milhões de cores – 24 bits por pixel).
Método point(coordseq[, <options>])
– Desenha um ponto na coordenada passada com as opções dadas.

Image (2/2)
As coordenadas:
– Podem ser do tipo int, long ou float;
– Seqüência não vazia de coordenadas x e y alternadas: (1, 221L, 3, 4, 5.1, 6)
– Seqüências de dois elementos, que especificam as coordenadas x e y
[(1,221L),(3,4),[5.12,6]]

As opções podem ser:
outline: cor usada nos contornos dos desenhos e em textos.
–
fill: cor usada no preenchimento dos desenhos.
–
width: espessura da linha usada para desenhar os contornos dos desenhos.
–
pattern: especifica o padrão usado no preenchimento dos desenhos.
–

Canvas
Canvas: componente gráfico para desenho e interações gráficas com o
usuário.
Classe Canvas([redraw_callback=None, event_callback=None]).
–
• redraw_callback: objeto “callable” chamado sempre que uma parte do Canvas
torna-se obscura por alguma coisa, necessitando ser redesenhada.
• event_callback: objeto “callable” associado à ocorrência de um evento do
teclado. O evento ocorrido é sempre passado para o objeto “callable” associado.
O argumento passado para este objeto consiste em um dicionário.

Canvas é “drawable” assim como Image.

Pode usar métodos de Image como:
– line;
– point;
– clear;
– blit.

Cores
Representação de Cores
– Formas de representação:
• Tupla de três elementos com inteiros na faixa de 0 a 255, representando os
componentes vermelho, verde e azul da cor (RGB);
• Inteiro na forma 0xRRGGBB, onde RR é a componente vermelha da cor, GG a
componente verde e BB a azul.

– Exemplos:
• 0x004000 (verde escuro);
• (255,0,0) (vermelho);
• 0 (preto);
• 255 (azul claro).

– Floats, números fora da faixa, ou uso de outra estrutura sem ser uma tupla
NÃO são suportados.

Exercício 1
A) Alterar o aplicativo para o modo em tela cheia;

B) Alterar a cor do canvas para branco e do ponto para preto.

Menu
appuifw.app.menu

Pode ser atribuído a uma lista contendo tuplas no formato (title,
callback) ou no formato (title, ((title_submenu, callback), ...)).

appuifw.app.menu = [(uquot;menuquot;, func1), (uquot;menu2quot;, ((uquot;submenu1quot;,func2),
(uquot;submenu2quot;, func2))
)]

Exercício 2
A) Crie um menu com as opções:
– size (submenu: up, down);
– color (submenu: red, green, blue);
– exit

B) Associe up com uma função que aumente o ponto em 10 pixels;

C) Associe down com uma função que diminua o ponto em 10 pixels;

D) Associe red com uma função que muda a cor do ponto para
vermelho;

E) Faça o mesmo com as outras cores;

F) Associe exit à função quit;

G) Crie um menu para alterar a velocidade da bola.

Teclado
Para obter eventos do teclado é necessário adicionar a classe teclado
(http://www.embedded.ufcg.edu.br/~diego/keyboard.txt);

Também é necessário associar o método handle_event da classe
teclado como event_callback de canvas;

canvas = appuifw.Canvas(event_callback = keyboard.handle_event,
redraw_callback= handle_redraw)

Podemos verificar se uma tecla foi apertada chamando o método
pressed de keyboard. Este método recebe como parâmetro uma
constante que deve corresponder à uma tecla:
– EScancodeLeftSoftkey, EScancodeYes, EScancodeMenu, EScancode0...9,
EScancodeStar, EScancodeLeftArrow, EScancodeUpArrow, EKeySelect
EScancodeSelect, EScancodeRightArrow, EScancodeDownArrow,
EScancodeRightSoftkey, EScancodeNo, EScancodeBackspace,
EScancodeEdit, EScancodeHash.

Exercício 3
A) Crie um retângulo no centro da tela de tamanho 10x10 e de cor
preta usando:

img.rectangle( (display_size[0]/2-5, display_size[1]/2-5,
display_size[0]/2+5, display_size[1]/2+5), fill=0x000000)

B) Faça com que a posição do retângulo na tela seja alterada com as
setas do teclado (cima, baixo, esquerda e direita). Para fazer isso use
as constantes:
EscancodeUpArrow,
–
EscancodeDownArrow,
–
EscancodeLeftArrow,
–
EscancodeRigthArrow.
–

if keyboard.pressed(EScancodeLeftArrow):
#código para alterar posição do retângulo para a esquerda

Adicionando uma imagem
Para carregar uma imagem usa-se o método open de Image:
– graphics.Image.open(filename)
– filename deve ser o caminho completo para a imagem a ser carregada
• Exemplo: c:pythonbg.bmp
– “” é caractere de escape.

Para colar uma imagem sobre outra usa-se a função blit:
blit(image[,target=(0,0), source=((0,0),image.size), mask=None, scale=0 ])‫‏‬
–

A máscara determina onde a imagem deve ser “colada”.
– A imagem que define a máscara deve ser monocromática em preto e
branco.
– Para carregar uma máscara fazemos assim:

mask_name = graphics.Image.new( invader.size, '1' )

mask_name.blit(graphics.Image.open(“c:pythonmask.bmpquot;) )

Exercício 4
A) Substitua o fundo de tela pela imagem bg.bmp e o retângulo pela
imagem invader.bmp;

B) O invader deve se mover assim como o retângulo se movia.

C) Use a máscara da imagem (mask.bmp)

Utilizando outros
recursos da
Plataforma S60

Explorando mais Recursos (1/6)
Foto:
#FotoTest.py

import camera
print camera.image_sizes() #[(1280, 960), (640, 480), (160, 120)]
image = camera.take_photo( size = (160,120) )
image.save(uquot;e:image.jpgquot;)

Audio: #AudioTest.py

import audio
sndfile = audio.Sound.open(uquot;d:test.wavquot;)
sndfile.record()
sndfile.stop()

#Play audio
sndfile.play()

SMS:
#SMS.py

import appuifw
import messaging

numero = appuifw.query(uquot;Mensagem para:quot;, quot;numberquot;)

txt = appuifw.query(uquot;Digite a msg.quot;,quot;textquot;)

if appuifw.query(uquot;Enviar mensagemquot;,quot;queryquot;) == True:
messaging.sms_send(str(numero), txt)
appuifw.note(uquot;Mensagem enviada, cara.quot;, quot;infoquot;)
else:
appuifw.note(uquot;Mensagem descartadaquot;, quot;infoquot;)

Canvas + Câmera import appuifw
import e32
import graphics
import camera

def quit():
global running
running = 0

appuifw.app.exit_key_handler = quit
appuifw.app.screen = 'large'
canvas = appuifw.Canvas()
appuifw.app.body = canvas
running = 1
while running:
image = camera.take_photo( size = (160, 120) )
canvas.blit(image)
e32.ao_yield()

import appuifw
Localização import e32
import location

def gsm_location() :
(mcc, mnc, lac, cellid) = location.gsm_location()
print uquot;MCC: quot; + unicode(mcc)
print uquot;MNC: quot; + unicode(mnc)
print uquot;LAC: quot; + unicode(lac)
print uquot;Cell id: quot; + unicode(cellid)

def exit_key_handler():
global script_lock
script_lock.signal()
appuifw.app.set_exit()

script_lock = e32.Ao_lock()
appuifw.app.title = uquot;Get cell-idquot;
appuifw.app.body = appuifw.Text(uquot;Press Options button below ...quot;)
appuifw.app.menu = [(uquot;get locationquot;, gsm_location)]
appuifw.app.exit_key_handler = exit_key_handler
script_lock.wait()

def exit_key_handler():
Telefone global script_lock
script_lock.signal()
import appuifw
import e32 script_lock = e32.Ao_lock()
import telephone appuifw.app.title = uquot;Dialerquot;
main_menu_setup()
def hangingup(): corpo_texto = appuifw.Text(u'Use o menu.')
telephone.hang_up() appuifw.app.body = corpo_texto
main_menu_setup() appuifw.app.exit_key_handler = exit_key_handler
script_lock.wait()
def main_menu_setup():
appuifw.app.menu = [(uquot;dialquot;, dialing),
(uquot;hang-upquot;, hangingup)]

def dialing():
number = appuifw.query(uquot;Número:quot;, quot;numberquot;)
print number
telephone.dial(unicode(number))
main_menu_setup()

Desafios Propostos
Jogos:
– Adagas!

– Space Invader

– Outros (sejam criativos)

PyS60
Pontos fortes
– Fácil de aprender e utilizar;
– Acesso mais simples a diversos recursos: Buetooth, SMS, UI, ...;
– Interface com código nativo;
– Extensível;
– Ciclo programar-testar-programar mais curto;
– Abre a plataforma S60 para não especialistas;
– Indicado para ensino e prototipagem.

Pontos fracos
– Interpretador não é componente padrão;
– Não tão madura quanto C++;
– Nem todas as API’s de Python estão disponíveis.

www.semanadamobilidade.blogspot.com

Python para S60 – PyS60
Semana da Mobilidade, CEFET-RN
Yuri Gomes, M.Sc.
Natal, 13-15/05/2008

http://wiki.forum.nokia.com/index.php/Category:Pyth
on

http://wiki.forum.nokia.com/index.php/Developing_Python_Applications_for_maemo

http://wiki.opensource.nokia.com/projects/Python_for
_S60

www.mobilenin.com/pys60/menu.htm

Obrigado!

Jonh Edson Ribeiro de Carvalho
Contato: visual@visual.pro.br
jonhedson@yahoo.com.br
Site: http://www.visual.pro.br/py

Jonh Edson Ribeiro de Carvalho

Desenvolvimento de Apps Python S60

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Desenvolvimento de Apps Python S60

Semelhante a Desenvolvimento de Apps Python S60 (20)

Desenvolvimento de Apps Python S60