Py 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

Introdução

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.

Plataforma S60 (2/1)

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 do Symbian

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.

Arquitetura da Plataforma S60 (2/3) 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)

Arquitetura da Plataforma S60 (3/3) 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

Instalando PyS60 no Emulador (2/3) 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*.

Instalando PyS60 no Emulador (3/3) 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

PyS60 no Emulador (2/4) 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

PyS60 no Emulador (3/4) 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.

PyS60 no Emulador (4/4) 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

PyS60 no Dispositivo Móvel - 1ª e 2ª edições (2/3) 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

PyS60 no Dispositivo Móvel - 1ª e 2ª edições (3/3) 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.

Resumo sobre Python

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

Controle de fluxo (2/3) 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!’

Controle de fluxo (3/3) 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()

Python para S60 – PyS60

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()

Explorando mais Recursos (2/6) 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;)

Explorando mais Recursos (3/6) 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()

Explorando mais Recursos (4/6) 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()

Explorando mais Recursos (5/6) 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

www.forum.nokia.com

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

www.embedded.ufcg.edu.br

www.croozeus.com

www.symbianresources.com

www.pyconbrasil.com.br

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

http://www.visual.pro.br	348
http://visual.pro.br	150
http://www.slideshare.net	9
http://static.slidesharecdn.com	1
http://www.google.com.br	1

Py S60

by Jonh Edson on Apr 27, 2009

Accessibility

Categories

Upload Details

Usage Rights

5 Embeds 509

Statistics

Py S60 — Presentation Transcript