From Forum Nokia Wiki

Tutorial de Python para S60

Introdução

Antes de partirmos para a ação vamos apresentar os atores envolvidos nesse tutorial:

Python: Linguagem de programação dinâmica que implementa vários paradigmas de desenvolvimento, fácil de aprender e usar, criada em 1991 por Guido van Rossum. Seu nome é derivado do grupo humorístico britânico Monty Python. Mais informações em http://www.python.org
Serie 60 (S60): Linha de celulares smartphones da Nokia que vêm equipada com o sistema operacional Symbian. Atualmente existem 3 "edições" da Serie 60 e em cada uma delas uma versão diferente do Symbian é usada. Dentro de cada edição ainda existe uma subdivisão de Feature Packs para distinguir entre dispositivos que possuem determinadas funcionalidades (ex. Wi-Fi, Bluetooth, Câmera, etc.). Uma lista completa das edições, FPs e dispositivos podem ser obtidas em http://www.forum.nokia.com/devices/matrix_all_1.html Mais informações sobre a Serie 60 em http://www.s60.com
Symbian: 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 rumores de que o código fonte dele será disponibilizado como Open Source. Mais informações em http://www.symbian.com
Forum Nokia: Portal para desenvolvedores de software para celulares da Nokia. Lá é possível encontrar o SDK para desenvolvimento C++ e Java para Serie 60 bem como uma série de artigos, tutoriais, exemplos, ferramentas e recursos para desenvolvedores.
Python para S60: Projeto Open Source custeado pela Nokia que já foi suportado oficialmente pela Nokia mas atualmente segue sua vida no mundo Open Source. O Python para S60 utiliza a versão 2.2 do Python (que é uma versão consideravelmente antiga visto que o Python está indo para a versão 2.6). O ponto central de informações sobre o PyS60 (para abreviar)0 é o site do projeto em http://pys60.sf.net.

Montando o ambiente de trabalho

Iremos descrever neste tutorial como montar o ambiente de trabalho para desenvolvimento em Python utilizando o Windows mas no site do PyS60 você pode encontrar informações sobre como desenvolver para PyS60 usando tanto o Linux quanto o MacOS X (que é consideravelmente mais fácil do que usando Windows).

Apesar de existir um emulador para celulares S60 no SDK C++ da Nokia ele não implementa todas as funcionalidades disponíveis em um aparelho real (tais como câmera, comunicação via GSM ou conectividade Bluetooth) portanto é extremamente recomendável dispor de um aparelho S60 real para acompanhar este tutorial até o fim. Qualquer edição pode ser usada mas eu recomendo algum aparelho "3rd Edition". O celular que eu usei para desenvolver o tutorial é um Nokia N95 que é um dispositivo "3rd Edition Feature Pack 1", portanto, se alguma coisa não funcionar conforme descrito aqui em seu celular verifique se isso não está acontecendo por causa da versão diferente do dispositivo/SDK.

Instalando o SDK/Emulador

Se você já dispõe de um celular S60 a instalação do SDK é opcional. O SDK C++ da Nokia depende da instalação do Perl em seu computador. Eu recomendo a instalação do ActivePerl da ActiveState (http://www.activestate.com/store/download.aspx?prdGUID=81fbce82-6bd5-49bc-a915-08d58c2648ca) pois para instalá-lo basta rodar o instalador).

Depois de ter baixado o SDK C++ do site Forum Nokia é chegado o momento de instalá-lo. Para isso basta descompactar o arquivo .zip que você acabou de baixar e rodar o instalador (setup.exe) que está dentro dele e seguir as instruções.

Se você não alterou o local padrão de instalação é provável que você tenha agora um diretório C:\Symbian em seu computador.

Agora que você já instalou o SDK C++ e o emulador em seu computador chegou o momento de baixar e instalar o PyS60 para rodar dentro do emulador. Para isso é só baixar o PythonForS60_1_4_4_SDK_XXX.zip (substituindo o XXX pela versão do SDK que você havia baixado).

Depois que você descompactou este arquivo .zip basta copiar o conteúdo dele dentro de C:\Symbian\X.X\S60_3rd_FP1\Epoc32 (ou o diretório equivalente dependendo da versão de SDK que você instalou).

Pronto. Já temos o Python instalado pra funcionar dentro do emulador. Para executá-lo basta entrar na opção do menu "Iniciar"->Programas->S60 Developer Tools->SDK->Emulator (tenha paciência pois o emulador vai demorar pra começar a funcionar) ir na opção "Installed" e escolher "Python".

Instalando no celular

Para instalar o PyS60 no seu celular você precisa baixar a versão adequada do PyS60 para seu celular em http://sourceforge.net/project/showfiles.php?group_id=154155 Será necessário baixar dois arquivos com a extensão SIS:

PythonForS60_1_4_4_VERSAO.SIS: Esse pacote tem o interpretador do Python propriamente dito.
PythonScriptShell_1_4_4_VERSAO.SIS: Esse pacote disponibiliza a opção "Python" no menu "Aplicativos" do seu celular e ainda acompanha alguns exemplos de código.

Agora é só usar o Nokia PC Suite para instalar esses pacotes em seu celular que a opção "Python" irá aparecer no seu menu de aplicações:

Menu "Aplicações"

Tela inicial do Python

Testando programas PyS60

Agora falta o último passo que precisa ser executado antes de partirmos para o desenvolvimento de uma aplicação para S60: enviar um programa Python para o aparelho para testar.

Para isso vamos fazer um pequeno programa chamado "ola_mundo.py" com o seguinte conteúdo:

  import appuifw
  appuifw.note(u"Olá Mundo!", "info")

Para fazer esse programa você pode usar um editor de textos comum como o Notepad do Windows (eu costumo usar o Notepad++ para isso).

Depois que você gravou o seu pequeno programa é necessário enviá-lo para o diretório C:\Python ou E:\Python (no caso do seu celular ter um cartão de memória) para podermos executá-lo. No exemplo abaixo eu estou conectando o meu celular através da USB mas essa comunicação também pode ser feita via conexão Bluetooth. Note que também é preciso ter o Nokia PC Suite Instalado para que tudo funcione corretamente:

Copiando "ola_mundo.py" para E:\Python

Depois que a gente fez a cópia é chegado o momento de executar o nosso primeiro aplicativo Python para S60:

Escolhendo a opção "Run Script"

Escolhendo o nosso programa

Assim que o nosso programa começar a rodar ele irá mostrar uma caixa de diálogo com a nossa mensagem de saudação:

Nossas saudações!

Agora que já sabemos como fazer um pequeno programa para PyS60, enviá-lo para o celular e executá-lo chegou o momento de apresentar uma visão mais aprofundada das funcionalidades disponíveis para o desenvolvimento de aplicações Python para dispositivos móveis.

Os módulos do PyS60

As limitações de memória e de poder de processamento dos dispositivos móveis obrigam o desenvolvedor a tomar mais cuidado com o desenvolvimento de suas aplicações. Isso não foi diferente ao se portar o interpretador Python para o ambiente Symbian.

Pequenas mudanças no interpretador fazem com que o garbage collector do Python não faça a coleta de lixo de objetos que continham referências circulares (A referencia B que referencia A), portanto, é importante tomar cuidado para que esse tipo de situação não ocorra.

Além desse tipo de cuidado o desenvolvedor tem que cuidar para sempre "desligar" os recursos que não estão sendo usados e, sempre que possível, por o seu programa "pra dormir" pois desta forma o Symbian irá diminuir o clock do processador que causará uma economia considerável de bateria.

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.

Módulos específicos do PyS60

Iremos falar rapidamente sobre os módulos do PyS60 a partir de agora 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 http://www.pythonbrasil.com.br/moin.cgi/DocumentacaoPython.

Os módulos específicos do PyS60 são:

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

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 iremos 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 eu recomendo enormemente uma lida na documentação oficial do PyS60 que pode ser baixada no site do projeto listado na primeira parte deste tutorial (disponível em formato PDF).

Para ilustrar o desenvolvimento de uma aplicação Python para S60 iremos utilizar um 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 o esqueleto abaixo para ser desenvolvida (para aqueles que ainda não conhecem Python eu recomendo a leitura do Tutorial da Linguagem disponível em http://www.pythonbrasil.com.br/moin.cgi/DocumentacaoPython):

  import e32
  import appuifw

  class MinhaAplicacao(object): # Define uma classe MinhaApp
      def __init__(self):
          # Cria um objeto "trava" irá "segurar"
          # a nossa aplicação rodando
          self.trava = e32.Ao_lock()
       
      def executa(self):
       
          # Aqui vai nossa applicacao
          # =========================
       
       
       
          # atribui uma chamada "callback" para
          # o método "sai()" quando o usuário
          # escolher a opção "Sair" no celular
          # Obs: note que o método "sai()" é 
          # não tem os parênteses porque a função
          # não é executada imediatamente
          appuifw.app.exit_key_handler = self.sai
       
          # aguarda segura a execução até que
          # "trava" receba um sinal
          self.trava.wait()
       
      def sai(self):
          # envia o sinal para "trava"
          self.trava.signal()
       
  if __name__ == '__main__':
      aplicacao = MinhaAplicacao()
      aplicacao.executa()

Essa aplicação não fará nada de interessante ainda. A única coisa que fizemos até agora foi organizá-la dentro de uma classe "MinhaAplicacao" que implementa o método ".executa()" onde programamos a opção de "Sair" da aplicação usando um "ActiveObject Lock" do Symbian.

Essa "trava" é 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 mesmo antes de terem concluído as suas tarefas. Muitas funcionalidades do PyS60 também são implementadas usando o modelo de callback, ou seja, o programador associa funções à eventos e quando esses eventos ocorrem a função apropriada é chamada. No nosso caso o método ".sai()" é executado sempre que um evento exit_key for disparado e esse evento ocorre quando acionamos o botão de opções direito do celular.

Ligando a câmera

Um dos módulos mais interessantes que acompanha o PyS60 é o "camera". Com ele podemos facilmente acionar a câmera do nosso celular, tirar fotografias, manipular a foto, gravá-la no cartão de memória, enviá-la para outros celulares, etc.

Para tirar uma foto com a câmera basta executar os comandos:

  import camera
  foto = camera.take_photo()

A função ".take_photo()" do módulo "camera" irá retornar um objeto do tipo "Image" contendo a imagem fotografada. Para gravar a imagem no cartão de memória basta chamar o método ".save()" deste objeto (note que o caracter "\" precisa ser duplicado para fazer escaping do mesmo):

  foto.save("E:\\Images\\minha_foto.jpg")

Como vocês puderam ver é extremamente simples tirar uma foto em Python mas isso tem um incoveniente: a foto é tirada assim que a função camera.take_photo() é chamada mas o que está sendo fotografado não aparece na tela do celular, logo, você não consegue ver o que está sendo fotografado. Para ver o que a câmera irá fotografar é necessário acionar o view finder da câmera (e desligá-lo imediatamente antes de tirar a fotografia). Vamos então voltar ao nosso "esqueleto" de aplicação e adicionar um pouco mais de código à ele:

  :
  import appuifw
  import camera
  :
  class MinhaAplicacao(object):
      def __init__(self):
  :
          # Vamos criar um objeto Canvas. Um
          # objeto Canvas permite a exibição
          # de imagens.
          self.canvas = appuifw.Canvas()
       
      def desenha_tela(self, imagem):
          self.canvas.blit(imagem)
       
      def executa(self):
          # define o título da aplicação
          # o "u" antes da string diz que
          # ela está no formato Unicode
          appuifw.app.title = u"PyFoto"

          # Vamos definir que o corpo da aplicação
          # será o objeto Canvas criado acima. 
          appuifw.app.body = self.canvas
       
          # iniciamos o "view finder" que irá
          # executar self.desenha_tela()
          # constantemente onde iremos exibir
          # a imagem capturada pelo finder no Canvas
       camera.start_finder(self.desenha_tela)
  :
      def sai(self):
          # desliga o view finder
          camera.stop_finder()
  :

Executando esse teste vamos obter a seguinte tela:

Imagem da tela do meu computador

Agora vamos adicionar uma opção "Tirar foto" ao nosso menu "Opções". Isso é extremamente simples de se fazer... vamos voltar ao nosso código e adicionar o seguinte trecho:

  :
  class MinhaAplicacao(object):
  :
      def tira_foto(self):
          # Desliga o view finder
          camera.stop_finder()
       
          # Tira a foto e a grava em
          # E:\Images\foto.jpg
          foto = camera.take_photo()
          foto.save("E:\\Images\\foto.jpg")
       
          # Religa o view finder
          camera.start_finder(self.desenha_tela)

      def executa(self):
  :
          # ... após a chamada camera.start_finder()

          # Cria uma opção "Tirar foto" no menu
          # Opções do celular que chama o método
          # self.tira_foto() quando acionado
          appuifw.app.menu = [
              (u"Tirar foto", self.tira_foto),
          ]
  :

Agora já podemos tirar a foto que será gravada no arquivo E:\Images\foto.jpg (para futuramente enviá-la via MMS):

Opção "Tirar foto"

Não se assuste se a aplicação ficar com uma tela branca por alguns segundos pois é o tempo necessário para que o Python grave a foto recém tirada.

Agora que temos a foto vamos enviá-la via MMS para um número de celular informado. Para isso adicione o código abaixo no nosso exemplo:

  :
  import messaging

  class MinhaAplicacao(object):
  :
      def tira_foto(self):
  :
          # ...logo depois de foto.save(...)

          # Solicita o numero do telefone
          numero_fone = appuifw.query(u"Número do telefone", "text")

          # verifica se o numero foi informado e envia mensagem
          if numero_fone:
              messaging.mms_send(
                  numero_fone,
                  u"Foto tirada pelo PyFoto",
                  "E:\\Images\\foto.jpg"
              )

Assim que a gente roda a nossa aplicação e tiramos uma foto já podemos informar o número do telefone do destinatário e ver a mensagem depois de entregue (cuidado ao testar o envio de MMS pois isso poderá incorrer em custos):

Solicitando o número do telefone

Mensagem recebida

Obviamente podemos melhorar muitos aspectos da nossa aplicação como por exemplo:

Reduzir o tamanho da imagem antes de enviá-la para economizar dinheiro
Buscar o número de telefone da nossa lista de contatos
Girar a tela para aproveitarmos melhor o espaço para o view finder
Adicionar outras opções de envio (Flickr, Bluetooth, ...)

Mas fica como exercício para os leitores.

Community: Wiki

Introdução ao Python para S60