DevMobile

Aqui na empresa, todas as aplicações são feitas em Canvas para melhor qualidade visual. A maioria de nossas aplicações devem rodar em JME e nativamente em BlackBerry. Aplicações BlackBerry usam APIs da própria RIM, embora as aplicações nativas BlackBerry suportem a maioria das APIs JME. Quando se desenvolve aplicações BlackBerry, as telas e uso de classes para controle de interface gráfica são bem diferentes da API do JME. Normalmente, se quiser ter a mesma aplicação JME rodando nativamente em BlackBerry deve-se criar um novo projeto, refazendo cerca de 80% da aplicação.

Visto que aqui na empresa, normalmente, as mesmas aplicações JME devem também rodar nativamente em BlackBerry, iniciei há um ano o desenvolvimento do Julien, um framework para desenvolvimento de aplicações multiplataforma. Implementei no Julien classes específicas para interface gráfica, imagens, fontes, controles gráficos, requisições HTTP, persistência, etc. Toda a interface gráfica do Julien é feita em Canvas puro, cada controle gráfico como listas, combobox, caixas de texto, checklist, botões, menus, caixas de diálogos, etc, foi desenhado na mão, e está pronto e disponível para o desenvolvedor simplesmente usar em suas telas.

O Core do Julien abstrai todas as classes de APIs JME e BlackBerry. Quanto desenvolve, o programador usa as classes e APIs do Julien, não do JME nem da RIM. Por isso, para desenvolver aplicações para JME e BlackBerry o desenvovledor precisa simplesmente conhecer Java, não precisa conhecer JME nem Blackberry.

Como Funciona?

O Julien consiste atualmente de 3 projetos:

1- JulienCore - Contém a maioria das classes do framework. Aqui ficam todas as APIs, gráficas, de persistência, comunicação, etc.

2- JulienJME - Contém a implementação do JulienCore usando as APIs JME. Por exemplo, a tela do JulienCore é implementada aqui usando Canvas, as imagens do JulienCore são implementadas aqui usando Image do JME, etc.

3- JulienBlackBerry - O mesmo que o JulienJME para com implementação usando as classes nativas da RIM.

Dessa forma, quando queremos criar um projeto multiplataforma de chamados, por exemplo, criamos também 3 projetos:

1- ChamadosCore - Contém 99,9% da implementação do projeto. Todas as telas, comunicação, dados do projeto são feitas nesse projeto. Esse projeto usa apenas o projeto JulienCore, e toda a implementação é feita usando as APIs do JulienCore.

2- ChamadosJME - Contém apenas 1 classes do MIDlet, com poucas chamadas para o JulienJME e o ChamadosCore. Essas chamadas servem apenas para rodar a aplicação. Em termos práticos, o MIDlet instancia a classe Application do JulienJME, passando como parâmetro a classe principal da aplicação no ChamadosCore. Dessa forma, o JulienJME saberá o que fazer para rodar o ChamadosCore em JME.

3- ChamadosBlackBerry - Contém apenas 1 classes do UiApplication, que é como que o MIDlet na API RIM, com poucas chamadas para o JulienBlackBerry e o ChamadosCore. Essas chamadas servem apenas para rodar a aplicação. Em termos práticos, o MIDlet instancia a classe Application do JulienBlackBerry, passando como parâmetro a classe principal da aplicação no ChamadosCore. Dessa forma, o JulienBlackBerry saberá o que fazer para rodar o ChamadosCore em BlackBerry.

Assim, quando o desenvolvedor quiser compilar/testar a aplicação Chamados em JME, ele apenas rodará o ChamadosJME. Quando quiser compilar/gerar em BlackBerry, fará isso usando o projeto ChamadosBlackBerry e será gerado o arquivo de instalação .COD. É muito prático.

Ao rodar os 2 projetos num Nokia, Motorola, ou qualquer outro celular que rode JME, ou BlackBerry de qualquer modelo, a aplicação rodará idêntica em qualquer device.No entando, o framework ainda respeitará o estilo de cada plataforma. Por exemplo, no BlackBerry não existe o conceito de softkeys, existe o conceito de menu, etc.

É prático usar o Framework?

Sim, muito prático e fácil. Para ter ótimas aplicação com excelentes visuais o desenvolvedor implementa poucas linhas. Cuida mais das regras de negócio da aplicação do que da implementação em si. Para se ter uma idéia, eu desenvolvo uma aplicação mais rápido usando o Julien, do que se fosse usar os controles das APIs JME ou BlackBerry. A produtividade é excelente.

Particularidades do Framework

Fontes

Existem 2 formas de escrever textos usando o Julien, usando fontes de Bitmap, e usando fontes nativas da plataforma. Mas isso fica na maioria das vezes transparente ao desenvolvedor. A vantagem em se usar fontes Bitmap é que as fontes terão o mesmo tamanho em qualquer device, e você garantirá que a aplicação será idêntica em quaquer device. Usando fontes nativas do device, você notará pequenas diferençãs nos tamanhos das fontes, principalmente em plataformas diferentes. Por isso aqui na empresa sempre usamos fontes de Bitmap. Você pode colocar as fontes TrueType que mais lhe agradarem na sua aplicação, e não precisará usar apenas a mesma fonte feia do JME.

Mas fontes de bitmap não deixa a aplicação lenta? Não! Fiz testes massivos, e mesmo em celulares com baixíssima memória e processamento o Julien rodou muito bem com fontes de Bitmap. Nos testes massivos que fiz, pintando fontes de Bitmap e fontes nativas, as fontes bitmap foram sempre mais rápidas de se pintar do que as fontes nativas.

Como funciona? Você usa um programa, seleciona a fonte, o tamanho, e o programa gera uma imagem colocando todas as letras nesta imagem, plotando-as com a fonte TrueType que você selecionou, e joga o arquivo dentro do seu projeto. O Julien interpreta  esse arquivo, e quanto vai pintar a palavra “Julien” na tela, pinta cada pedacinho da imagem correspondente à letra desejada. O Julien interpreta inclusive o controle de kerning entre os pares de caracteres.

Imagens

Em sua API para controle e tratamento de imagens, o Julien dispõem de vário recursos como, rotação, transparência, redimensionamento, alteração no padrão de cores, etc. Além disso possui recursos para montagem de imagens para que os controles e imagens de ajustem à tela do device, independente da resolução. Por exemplo, para criar uma imagem de fundo de um ítem de menu, você informa apenas o pedaço inicial esquerdo da imagem, o pedaço final direito da imagem, e um pedaço do meio, ele gerará uma nova imagem duplicando o pedaço do meio para se ajustar à resolução de tela.

Todas as imagens que você usa na aplicação você declara num único lugar, o ImageManager. Esse gerenciador gerencia o uso de cache dessas imagens em toda a aplicação, limpando e mantendo em cache as imagens de acordo com necessidade e tela. Isso garante o bom gerenciamento da memória.

Telas

O Julien possui sua própria implementação de tela canvas. Dessa forma, numa aplicação JME, todas as telas são pintadas finalmente em uma única tela Canvas. As telas possuem pleno controle de pintura apenas dos necessário. Por exemplo, num campo de texto, enquanto o usuário está digitando, apenas o campo de texto é repintado, não toda a tela, reduzindo em muito o consumo de bateria.

De forma prática, você simplesmente diz em sua tela quais controles terá, e quais comandos e itens de menu existirão.O framework fará todo o resto.

Controles Gráficos

Implementei muitos controles gráficos, vários tipos de listas, campos de texto, campos multilinha, comboboxes, etc. Tudo isso está pronto para usar facilmente nas telas.

Controles de texto, por exemplo, incluem automaticamente no menu um ítem “Inserir Símbolo”. O mesmo ocorre com controles de telefone, e-mail, adicionam ao menu “Iniciar Ligação” e “Enviar e-mail”. Essas ações o próprio framework trata, o desenvolvedor não precisa implementar a ligação ou o envio de e-mail. No Nokia o envio de e-mail é feito pelo próprio framework, no BlackBerry é chamado o programa defaul de mensagens com os campos do destinatário preenchido.

Touch Screen

Os controles do Julien também implementam TouchScreen. Por exemplo, você pode rolar uma lista com o dedo ou caneta.

A aplicação fica Leve?

Sim, fica bem leve. As mudanças de telas e desenho dos controles são muito rápidos, mesmo que a aplicação tenha bastante imagens.

Implementacões para outras Plataformas

Penso em implementar oJulien também para outras plataformas, como Windows Mobile e Android. Dessa forma a mesma aplicação, o mesmo projeto que você fez para JME, rodará nativamente em JME, BlackBerry, Android e WindowsMobile. Em Android não seria tão complexo, pois é Java. Já em WindowsMobileseria necessário ter a implementação do JulienWindowsMobile, com classes em C# específicas da plataforma, e escrever um conversor Java-C#que gerasse as classes do JulienCore e do ProjetoCore para C#. Isso é plenamente possível, mas levaria um certo tempo para implementar.

Open Source?

Infelizmente, ainda não é opensource. O framework foi desenvolvido por mim, na empresa onde trabalho, e pertence à empresa. Talvez futuramente, com uma boa organização de cooperação, abramos o código para todos poderem cooperar e participar do desenvolvimento. O objetivo do post é apenas msotrar a idéia e o conceito para quem desejar utilizar.

Sobre o Autor