| Últimas 20 atualizações de Marcel Pinheiro Caraciolo |
|
|
Desenvolvendo Aplicativos Python para Symbian OS
Introdução à programação Python para celulares Symbian S60 - Parte 02
O desenvolvimento de aplicações móveis tem crescido fortemente devido ao aumento do número de aparelhos móveis, os quais tem trazido novas funcionalidades, inovações e além de oferecer uma nova variedade de serviços. Essa tendência foi mais acentuada ainda com a chegada de novos aparelhos móveis: os smartphones, que unem o poder dos PDAs (Personal Digital Assistant ou Assistente Pessoal Digital) com os celulares. Esses dispositivos são embarcados com diversos sistemas operacionais: Linux, Symbian, Windows Mobile dentre outros. No que diz respeito a linguagens de programação, existe um universo muito maior, como exemplo as linguagens Brew, C++, JavaME, FlashLite e Python.
Um dos sistemas operacionais que tem predominado no mercado de smartphones é o Symbian OS. Ele foi desenvolvido para esse perfil de aparelhos celulares, que agrega mais recursos comparado aos comuns. Além de ser um sistema multitarefa com uma interface gráfica intuitiva, ele possui várias plataformas para desenvolvimento de aplicativos móveis. Dentre elas, vale destacar a plataforma Symbian C++, a qual é uma variação da linguagem C++ usada também no desenvolvimento do sistema operacional e tem acesso a diversos recursos do celular. Outro exemplo é a plataforma Java, que é representada por uma Java Virtual machine compatível com JavaME/MIDP. Todas essas plataformas de desenvolvimento de aplicações para um aparelho Symbian possuem várias vantagens e desvantagens relacionadas ao grau de rapidez, acesso a recursos do aparelho e complexidade da linguagem de programação.
A maior dificuldade encontrada foi a necessidade de um estudo prévio aprofundado dessas plataformas e suas particularidades. Isso se tornou dispendioso, já que o foco do desenvolvimento de aplicativos móveis deveria ser em aprendizado fácil e produção rápida de aplicativos. A Nokia, então, ciente dessa necessidade trouxe uma linguagem que oferecesse aos desenvolvedores um meio que pudesse implementar aplicações úteis sem a obrigação de gastar meses aprendendo Java ou C++, além dos detalhes técnicos envolvidos no sistema operacional Symbian. O resultado foi o Python para S60 (PyS60), uma linguagem de script portada para celulares Symbian OS.
A linguagem além de ser bastante simples, através da rápida contrução de programas, oferece novas oportunidades ao desenvolvimento de aplicativos móveis. Não somente os iniciantes na plataforma irão se beneficiar dessa oportunidade, como também os desenvolvedores experientes que poderão usufruir desse meio para desenvolvimento ágil e poderoso de aplicativos móveis.
Neste artigo, que é o segundo de uma série que começou com a introdução à plataforma Python para Série 60 e a descrição de instalação e configuração do ambiente de desenvolvimento, iremos explorar alguns recursos disponibilizados pela plataforma PyS60 através de simples exemplos de aplicações a fim de ilustrar os conceitos aqui apresentados.
Construindo aplicativos com PyS60
Para ilustrar o desenvolvimento de uma aplicação Python para S60 iremos utilizar alguns exemplos bastante simples de aplicações que explorem os recursos avançados da plataforma PyS60. O primeiro exemplo consiste de uma aplicação que captura fotos e os envia via MMS para um número de telefone informado. O segundo exemplo consiste do clássico jogo da velha (tic-tac-toe) a fim de demonstrar a possibilidade de construção de aplicativos que utilizam gráficos e eventos de teclado suportados pela plataforma Python para S60. Porém, antes de explorarmos o código, é preciso introduzir alguns conceitos que serão utilizados no decorrer do desenvolvimento dos aplicativos.
Estrutura de um aplicativo
Diversos aplicativos disponíveis para o Symbian S60 compartilham do mesmo layout de interface gráfica. Basta abrir alguns aplicativos existentes no seu aparelho (inclusive o interpretador do PyS60), para perceber que eles possuem a mesma estrutura no quesito de interface gráfica. A figura 01 ilustra a estrutura de um aplicativo utilizando o framework de interface gráfica do aparelho S60. Observando o diagrama na figura 02, pode-se comparar como essa estrutura é mapeada em um aplicativo real desenvolvido com este framework.
 
Figura 01: Estrutura do aplicativo Figura 02: Aplicativo com S60 UI
No topo da tela, você pode observar o título do aplicativo. Esta é parte de nossa aplicação onde setamos o título do aplicativo. Em PyS60, podemos setar um título usando o comando: appuifw.app.title = u"First App!" . Abaixo do título, se encontra a barra de navegação, útil para quando se deseja utilizar abas em seu aplicativo. A área que compõe a maior parte da aplicação corresponde ao corpo do aplicativo e também é considerado como a parte mais importante do mesmo. Nele, podem ser atribuídos diversos tipos de objeto de interface gráfica como:
- Canvas que manipula a parte de gráficos na tela.
- Formulários para construção de listas que abrigam diversos tipos de campos de texto.
- Um objeto do tipo texto que corresponde ao texto puro escrito na tela.
- Listas, caixas de diálogo, etc.
Na parte inferior, você pode observar 2 itens que são ativados por botões dedicados (softkeys da esquerda e direita) do teclado do seu aparelho móvel. Se nenhuma caixa de diálogo estiver presente, o softkey da esquerda ativa o menu da aplicação ('Options'), enquanto o softkey da direita corresponde ao comando de sair ('Exit') da aplicação em execução. Se uma caixa de diálogo estiver em exibição, os softkeys correspondem ao "Aceitar" ('Accept') e "Rejeitar" ('Cancel') respectivamente.
Em PyS60, você pode acessar os elementos de interface gráfica através do objeto app que faz parte do módulo appuifw. Modificá-los é bastante simples: como cada elemento é uma variável dentro do objeto appuifw.app, basta atribuir a um valor desejado, da mesma maneira que uma atribuição de uma varíável qualquer (Ex: appuifw.app.exit_key_handler= sai ). Além do módulo appuifw, há o módulo e32 que é responsável pela manipulação de objetos e funções nativas relacionadas ao sistema operacional Symbian OS (Ex: locks, threads, etc.). No decorrer deste artigo, iremos utilizar de alguns objetos deste módulo, que serão descritos conforme forem aparecendo.
Eventos e callbacks
Para facilitar a vida do programador no desenvolvimento de aplicações que consumam poucos recursos os módulos Python específicos para a plataforma S60 usam e abusam do conceito de eventos e callbacks. Esse conceito é simples: a aplicação fica "dormindo" até que um evento ocorra (tecla pressionada, sinal de relógio, etc) e dispare uma função pré-determinada (callback).
Funções Assíncronas
Além do conceito de eventos e callbacks descrito acima os módulos que acompanham o PyS60 também possuem várias funções que se comportam de maneira assíncrona, ou seja, elas retornam antes de terminar de executar a sua tarefa. Nesses casos é bastante comum que essas funções executem uma chamada à uma função callback para 'avisar' de que sua tarefa foi concluída.
Abaixo na Listagem 1, iremos falar rapidamente sobre os módulos do PyS60, mas por questão de espaço não poderemos entrar em maiores detalhes sobre cada um deles ou até mesmo sobre suas funções. Para uma visão detalhada de cada um deles eu recomendo uma visita à documentação oficial do Python para S60 que pode ser encontrada no endereço link.
Listagem 1. Módulos específicos do PyS60
e32
Este módulo fornece acesso às funções específicas do sistema operacional Symbian que não possuem relação direta com a interface com o usuário. Neste módulo você irá encontrar funções que retornam a versão do PyS60, se seu programa está rodando no emulador, a lista de todos os drives disponíveis e funções e objetos que lidam com locks, threads, etc.
sysinfo
Este módulo fornece funções que retornam dados do aparelho tais como qual o perfil escolhido (geral, reunião, silencioso, ...), o estado da carga da bateria, tamanho da tela, espaço livre em disco, IMEI, potência do sinal da rede telefônica, tipo de toque, informações sobre a memória do aparelho, versão do firmware, etc.
appuifw
Neste módulo você irá encontrar tudo o que tem relação com a interface gráfica com o usuário (GUI). É um dos módulos mais importantes do PyS60.
graphics
Módulo com funções gráficas para manipulação de imagens, desenho de primitivas, impressão de textos em imagens, funções para tirar screenshots, etc. Esse módulo tem total interoperabilidade com os módulos camera e appuifw.
camera
Um dos módulos mais interessantes do PyS60 por sua facilidade de uso. Este módulo disponibiliza funções para manipular a(s) câmera(s) do celular permitindo que se tire fotografias ou que se grave vídeos com elas.
gles
Biblioteca que fornece uma API compatível com OpenGL/ES para desenho de gráficos 3D com aceleração (alguns dispositivos da S60 possuem um chip para aceleração gráfica 3D).
sensor
Este módulo dá acesso aos sensores de aceleração, rotação e tapping (bater com o dedo na tela do celular aciona esse sensor). Vale lembrar que apenas alguns modelos de celulares S60 dispõem desses sensores.
audio
Esse módulo permite a manipulação total do sistema de áudio do aparelho. Com ele é possível manipular tanto o auto-falante externo (tocando um MP3, por exemplo) quanto o áudio de uma ligação telefônica (emitir um som no meio de uma conversa ou até mesmo gravá-la).
telephone
Funcionalidades de telefonia tais como fazer uma ligação ou atender à uma chamada estão neste módulo.
messaging
Esse módulo tem as funções responsáveis pelo envio de SMS e MMS.
inbox, contacts, calendar
Manipulam respectivamente a caixa de entrada de mensagens (SMS/MMS), os contatos da agenda e os eventos de calendário. Esses módulos são extremamente poderosos.
location, positioning
Módulos de localização que utilizam respectivamente os dados da rede GSM e dados do GPS (interno ou externo) do aparelho.
e32db
Mini banco de dados relacional que permite manipulação utilizando SQL (será substituído pelo SQLite em versões futuras do PyS60).
socket
Módulo que já acompanha o Python e recebeu adições para suportar conexões via Bluetooth.
Desenvolvendo o primeiro aplicativo - FotoPy
A filosofia do Python diz que a linguagem tem "batteries included" (baterias inclusas) e isso significa que a linguagem sempre deve vir acompanhada de uma biblioteca padrão bastante completa e poderosa. Isso não é diferente no Python para S60 onde temos alguns módulos da biblioteca padrão do Python (apenas uma parcela dos módulos padrões) e mais algumas bibliotecas específicas para o desenvolvimento para S60.
Obviamente, por questões de espaço, não irei descrever ou usar todos os módulos neste tutorial, mas se você deseja obter informações detalhadas sobre o que está disponível para essa plataforma é recomendável dar uma leitura na documentação oficial do PyS60 que pode ser baixada no site do projeto listado na primeira parte deste artigo(disponível em formato PDF).
Para ilustrar o desenvolvimento de uma aplicação Python para S60 iremos utilizar o primeiro exemplo bastante simples de uma aplicação que tira uma foto e a envia via MMS para um número de telefone informado. Todas as aplicações PyS60 podem usar a estruttura abaixo (Listagem 4) para ser desenvolvida:
Listagem 4. Estrutura da Aplicação
1. import e32
2. import appuifw
3.
4. def sai():
5. #envia o sinal para o objeto "trava"
6. trava.signal()
7.
8. #Aqui começa a nossa aplicação
9. # ============================
10.#Cria um objeto "trava" que irá "segurar"
11.#a nossa aplicação rodando
12.trava = e32.Ao_lock()
11.
12.#Atribui uma chamada "callback" para
13.# o método "sai()" quando o usuário
14.#escolher a opção "Sair" no celular.
15.#Obs: Note que a chamada do método "sai()"
16.#não tem parêmteses pois a função não
17.#é executada imediatamente
18.appuifw.app.exit_key_handler = self.sai
19.
20.#Aguarda e segura a execução até que o
21.#objeto "trava" receba um sinal.
22.trava.wait()
23.
Esta primeira aplicação não fará nada de útil. A única coisa que foi codificada até agora foi a implementação da função “.sai()” (Linha 4) onde programamos a opção “Sair” ('Exit') da aplicação utilizando um “ActiveObjectLock” do Symbian. Este objeto “trava” (“ActiveObjectLock” - Ao_lock') (Linha 12) é necessária, pois as aplicações no universo Symbian são desenvolvidas para trabalharem no modelo assíncrono, ou seja, as funções retornam imediatamente após serem chamadas antes mesmo de terem concluído as suas tarefas. Isso acarretaria na saída súbita da aplicação sem que o usuário consiga enxergar a aplicação sendo executada. Por isso, utiliza-se a chamada à função wait() (Linha 22) que coloca a aplicação em modo de espera (a aplicação continua em execução) até que o objeto "trava" receba um sinal pela chamada da função signal() (Linha 6). Esa função deve ser chamada quando o usuário deseja finalizar a aplicação, por isso a sua chamada apenas dentro da função sai(). Muitas funcionalidades do PyS60 também são implementadas usando o modelo de callback, ou seja, o programador associa funções a eventos e quando esses eventos ocorrem, a função apropriada é invocada. Na nossa aplicação o método “.sai()” é executado sempre que o evento exit_key (Linha 18) for disparado e o mesmo ocorre quando pressionamos o softkey direito do aparelho móvel.
Um dos módulos mais interessantes que acompanha o PyS60 é o módulo “camera”. Com ele podemos facilmente acionar a câmera do aparelho móvel, tirar fotografias, manipular fotos, gravá-las no cartão de memória ou até enviá-las para outros celulares. Para tirar uma foto com a câmera basta executar os comandos (Listagem 5):
Listagem 5. Ligando a câmera
1. import camera
2. foto = camera.take_photo()
3. foto.save(("E:\\Images\\foto.jpg")
A função “.take_photo()” do módulo “camera" irá retornar um objeto do tipo “Image” contendo a imagem fotografada (Linha 2). Para gravar a imagem no cartão de memória basta chamar o método “.save()” deste objeto, passando como parâmetro o caminho do diretório onde a image capturada deve ser armazenada (Note que o caractere “\” precisa ser duplicado para ser reconhecido como “escaping”) (Linha 3).
Como se pode observar é extremamente simples tirar uma foto em Python, mas isso tem um inconveniente: a foto é capturada assim que a função camera.take_photo() é chamada e isso implica que o que está sendo fotografado não aparece na tela do celular, logo o usuário não conseguirá visualizar o que está sendo fotografado. Para que visualizar o que a câmera está fotografando, é necessário acionar o view finder (modo preview) da câmera e desligá-lo imediatamente antes de tirar a fotografia. Então, de volta ao esqueleto da aplicação (Listagem 4), adicionaremos algumas linhas de código a mais (Listagem 6):
Listagem 6. Adicionando o View Finder
1. import e32
2. import appuifw
3.import camera
4.
5. def sai():
6. #envia o sinal para o objeto "trava"
7. trava.signal()
8.
9. def desenha_tela(self,imagem):
10. #Pinta a imagem vista pela câmera na tela
11. canvas.blit(imagem)
12.
13.#Aqui começa a nossa aplicação
14.# ============================
15.#Vamos criar um objeto Canvas.
16.#Objeto Canvas permite a exibição de imagens
17.canvas = appuifw.Canvas()
18.
19.#Cria um objeto "trava" que irá "segurar"
20.#a nossa aplicação rodando
21.trava = e32.Ao_lock()
22.
23.#Define o titulo da aplicacao
24.#O "u" antes da string informa que
25.#o texto está no formato unicode.
26.appuifw.app.title = u"PyFoto"
27.
28.#Vamos definir que o corpo da aplicação
29.#será o objeto Canvas criado acima.
30.appuifw.app.body = canvas
31.
32.#Atribui uma chamada "callback" para
33.# o método "sai()" quando o usuário
34.#escolher a opção "Sair" no celular.
35.#Obs: Note que a chamada do método "sai()"
36.#não tem parêmteses pois a função não
37.#é executada imediatamente
38.appuifw.app.exit_key_handler = sai
39.
40.#Iniciamos o "view finder" que irá
41.#executar desenha_tela()
42.#constantemente onde iremos exibir
43.#a imagem capturada pelo finder no Canvas
44.camera.start_finder(desenha_tela)
45.
46.#Aguarda e segura a execução até que o
47.#objeto "trava" receba um sinal.
48.trava.wait()
Executando esse teste vamos obter a seguinte tela (Figura 3):
Figura 3. View Finder em execução
Agora vamos adicionar uma opção "Tirar foto" ao nosso menu "Opções". Para isso vamos adicionar esse pequeno trecho de código (Listagem 7):
Listagem 7. Adicionando a captura de foto
1. import e32
2. (...)
3.
4.
5. def tira_foto():
6. #Desliga o view finder
7. camera.stop_finder()
8.
9. #Tira a foto e grava em E:\\Images\\foto.jpg
11. foto = camera.take_photo()
12. foto.save("E:\\Images\\foto.jpg")
13.
14. #Religa o view finder
15. camera.start_finder(desenha_tela)
16.
17.#Aqui começa a nossa aplicação
18.# ============================
19.(...)
20.#Após a chamada camera.start_finder()
21.
22.#Cria uma opção "Tirar foto" no menu
23.#Opções do celular que invoca o método
24.#tira_foto() quando acionado.
25.appuifw.app.menu = [(u"Tira foto",tira_foto)]
26.(...)
Agora a foto já pode ser capturada, que será gravada no arquivo E:\Images\foto.jpg (para futuramente enviá-la via MMS) (Figura 4):
Figura 4. Opção “Tirar foto”
Uma observação importante é que a aplicação pode ficar com uma tela branca durante alguns segundos, pois é o tempo necessário para que o interpretador Python grave a foto recém-tirada. Agora com a foto salva, iremos enviá-la via MMS para um número de celular informado. Para isso adicione o código abaixo ao nosso aplicativo (Listagem 8):
Listagem 8. Adicionando o envio de MMS
1. (...)
2. import messaging
3.
4. (...)
5.
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui |
|
|
|
Desenvolvendo Aplicativos Python para Symbian OS
Introdução à programação Python para celulares Symbian S60 - Parte 01
Marcel Pinheiro Caraciolo
O número de telefones inteligentes (smartphones) no mercado vem crescendo gradativamente nos últimos anos, devido, principalmente, às novas maneiras de como as pessoas estão se comunicando, interagindo e trabalhando. Há uma necessidade por provimento de serviços e acesso às informações de forma eficiente e rápida, especialmente no âmbito de dispositivos móveis. Existem, atualmente, mais de bilhões de usuários vinculados a alguma operadora telefônica móvel e a tendência é aumentar ainda mais esses números. Este aumento do número de aparelhos móveis provoca uma demanda por novos serviços e aplicativos em variadas plataformas nos quais eles são desenvolvidos e distribuídos. Hoje, o telefone móvel é considerado como um objeto de posse "pessoal e individual", disponibilizando ao usuário recursos multimídia, listas de tarefas, álbuns de fotos e vídeos capturados e acesso a internet.
Desde o início desta tendência, diversos desenvolvedores de software começaram a escrever aplicativos para plataformas móveis, a fim de lucrar em cima desse novo mercado emergente. Driblando as desvantagens desse vasto campo de possibilidades na área de dispositivos móveis que são bem conhecidas: poder de processamento limitado, telas reduzidas, limitações de memória, dentre outros fatores que passam a exigir uma maior habilidade por parte dos desenvolvedores para a construção de aplicativos eficientes e usáveis.
Diferentes plataformas foram estabelecidas por diversos fabricantes de dispositivos móveis. Algumas desenvolveram o seu próprio sistema operacional, enquanto outras decidiram utilizar sistemas operacionais de terceiros. Essas plataformas podem permitir aos desenvolvedores utilizarem a API nativa do sistema para acesso às diversas funcionalidades e recursos dos aparelhos no desenvolvimento dos seus aplicativos. Dentre esses sistemas, o Symbian OS tornou-se uma das principais plataformas neste mercado de smartphones. Ela é um sistema operacional proprietário para dispositivos móveis desenvolvido pela Symbian e custeado por um consórcio formado por empresas como Nokia, Sony Ericsson e Samsung. Atualmente, ela pertence inteiramente à Nokia e existem informações de que o código fonte dele será disponibilizado como open-source. Mais informações, podem ser encontradas no site oficial do Symbian.
Grande parte dos aparelhos Symbian é agrupado em plataformas que compartilham certas características, tais como resolução, tamanho de tela, processadores e versão do sistema operacional. Esse fato auxilia o desenvolvedor, pois generaliza a plataforma alvo, aumentando assim o número de dispositivos alcançados por uma determinada aplicação. As plataformas mais populares são Série 60, Série 80, Série 90 e UIQ. A plataforma Série 60, além de ter mais fabricantes licenciados e o maior número de aparelhos lançados é também a mais popular no Brasil. Tanto que a Nokia desenvolveu a plataforma de desenvolvimento Python direcionados a esses celulares devido ao grande portfólio de aparelhos com essa versão do Symbian embarcada. Por essas razões o desenvolvimento abordado neste artigo enfoca os aparelhos Série 60.
Symbian S60
O sistema operacional Symbian S60 é um sistema multitarefa que possui uma interface gráfica intuitiva, além de suportar várias plataformas para desenvolvimento de aplicativos móveis. Vale destacar a plataforma Symbian C++, que é uma variação da linguagem C++ usada também no desenvolvimento do sistema operacional, e tem acesso a diversos recursos do celular. Outro exemplo é a plataforma Java, que é representada por uma máquina virtual Java compatível com JavaME/MIDP. Todas essas plataformas de desenvolvimento de aplicações para um aparelho Symbian possuem várias vantagens e desvantagens caracterizadas por grau de rapidez, acesso a funcionalidades/recursos do aparelho e complexidade da linguagem de programação.
A maior dificuldade encontrada foi a necessidade de um estudo prévio aprofundado dessas plataformas e suas particularidades. Isso se tornou dispendioso, já que o foco do desenvolvimento de aplicativos móveis deveria ser em fácil aprendizado e rapidez na produção de aplicativos. A Nokia, então, reconheceu essa necessidade de uma linguagem que oferecesse aos desenvolvedores um meio que pudesse implementar aplicações úteis sem a obrigação de gastar meses aprendendo Java ou C++ e mais além os detalhes técnicos envolvidos no sistema operacional Symbian. O resultado foi o Python para S60 (PyS60), uma linguagem de script portada para celulares Symbian OS.
A linguagem além de ser bastante simples, através da rápida produção de aplicativos, oferece novas oportunidades de desenvolvimento de aplicativos móveis. Não somente os iniciantes na plataforma irão beneficiar-se dessas oportunidades, como também o desenvolvedores experientes que poderão usufruir desse meio para desenvolvimento ágil e poderoso de aplicativos móveis.
Este artigo está dividido em duas partes. Nesta primeira parte discutirei algumas características da linguagem de programação Python e da plataforma Python para série 60. E em seguida, iremos descrever como montar um ambiente de desenvolvimento de aplicações para este sistema. Na segunda parte, descreverei alguns recursos disponibilizados pela plataforma PyS60 através de aplicações e exemplos simples que ilustrarão os conceitos apresentados.
Python
Python é uma linguagem de programação de script orientada a objetos, disponível para diversas plataformas e ambientes. O código gerado é interpretado em tempo de execução, diferentemente das linguagens compiláveis como C++, que é compilada para a plataforma-alvo antes da sua execução. A linguagem em questão permite que programas sejam escritos de forma compacta e legível, possibilitando o rápido aprendizado. Os códigos escritos em Python são geralmente menores em comparação a códigos equivalentes em C++ ou Java devido ao seu mecanismo de abstração de tipos o qual permite expressar operações bastante complexas com apenas um comando. Os comandos são agrupados por indentação e não há necessidade de declaração de variáveis.
Um pequeno trecho de código é ilustrado na Listagem 1, onde está demonstrado a definição de uma função e em seguida a sua chamada para execução. Como pode ser observado, as variáveis são usadas sem a necessidade de declaração explícita e a delimitação de um bloco de código (while-loop) é definido pela indentação sem a necessidade de chaves ({ }) comuns em linguagens de programação como Java e C++.
Listagem 1. Definição de uma função em Python
1. #define uma função
2. def exponencial (n,exp):
3. a = 1
4. while a < exp:
5. n = n*n
6. a = a+1
7. print n
8.
9.#chamada da funcao
10.exponencial(2,3)
Como mencionado acima, Python é uma linguagem orientada a objetos e permite a definição de estrutura de dados e classes. A Listagem 2 ilustra a definição de uma simples classe com um atributo (idade) e uma função (nome). A instanciação do objeto é demonstrada mais abaixo no código (Linha 7).
Listagem 2. Definição de uma classe em Python
1. #define uma classe
2. class Pessoa:
3. idade = 23
4. def nome(self):
5. return ‘Ola Pessoa!’
6.
7. x = Pessoa()
Python para S60
Python para S60 é uma iniciativa da Nokia de portar a linguagem Python para smartphones Symbian Série 60. A plataforma Série 60 provê uma interface gráfica e outros recursos para celulares Nokia baseados no sistema operacional Symbian OS e um kit de ferramentas de desenvolvimento para esta plataforma. Atualmente existem quatro versões (1nd, 2nd, 3nd, 5nd), além de diferentes kits de funcionalidades (feature packs) que se diferenciam pela época de lançamento e inclusão de novos recursos (upgrades) dependendo das capacidades técnicas do aparelho. Os mais recentes smartphones da Série 60 já vêm com um conjunto de aplicativos pré-instalados e recursos de multimídia e rede acessíveis através de um conjunto de bibliotecas pré-definidas (APIs). Com o Python para S60, os desenvolvedores podem usufruir de quase todo o poder que a plataforma Série 60 oferece.
Desde 2006, ele se tornou um projeto open-source da Nokia, e todo o código-fonte da plataforma foi disponibilizado para estudo. Este foi um dos grandes fatores que impulsionaram o sucesso da plataforma, visto que, os desenvolvedores puderam analisar os códigos, encontrar bugs e falhas, enviar sugestões e novas funcionalidades para as próximas versões do PyS60. Na época em que esse artigo estava sendo escrito, o PyS60 encontrava-se na versão 1.4.4, disponibilizado para download, hospedado no site SourceForge o interpretador a ser instalado no celular, o kit de desenvolvimento (SDK) para testes no emulador e a documentação contendo informações sobre API e especificações do projeto.
Até a versão 1.4.4, o Python para Série 60 baseava-se na versão do Python 2.2.2. Ele suporta diversos módulo de biblioteca padrão de Python, que cobre estruturas de dados, tipos, exceções e outras especificações básicas da linguagem. Módulos e extensões específicas para plataforma móvel foram desenvolvidas para ter acesso aos recursos dos aparelhos S60, sendo assim adicionadas aos módulos padrões de Python. Há duas extensões básicas pré-definidas no PyS60. O módulo e32 que implementa toda a interface de comunicação de serviços da plataforma S60 e não possui relação direta com a interface do usuário. Neste módulo você irá encontrar funções que retornam a versão do PyS60, informações de carga de bateria, se seu programa está rodando no emulador, lista de todos os drivers disponíveis, funções e objetos que lidam com locks, threads, etc. O outro módulo, appuifw, é utilizado para manipular os eventos e criar componentes na interface do S60. Além desses extensões básicas, há outros módulos que disponibilizam a API necessária para acesso de recursos como mensagens de texto (SMS), câmera, áudio, lista de contatos e pintura na tela. Mais detalhes sobre esses módulos podem ser encontrados na documentação disponível para donwload junto ao interpretador e kit de desenvolvimento.
O desenvolvimento com PyS60 é baseado no kit de desenvolvimento para plataformas Série 60 (S60 SDK), que é geralmente usado para escrever os códigos nativos em C++ para o Symbian OS. O SDK vem junto com um emulador, no qual os aplicativos podem ser testados. Apesar de existir um emulador para celulares S60 no SDK C++ da Nokia, ele ainda não implementa todas as funcionalidades disponíveis em um aparelho real (tais como câmera, comunicação via GSM ou conectividade Bluetooth), portanto, se
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui |
|
|
| |
|
24/01/2009 22:49:00
2009
2009
3
0
