DevMobile

Já pensou em ter seu software mobile disponível para o mundo inteiro? Veja a lista dos idiomas com sua popularidade. Isso ajuda a decidir por quais idiomas você disponibilizará.

Número de Falantes

Fonte: Ethnologue em 21/10/1997

Idioma            Idioma Principal    Primeiro e Segundo Idioma

----------        -----------------   -------------------------

Mandarin             885 milhão

English              322 milhão        470 milhão

Spanish              266 milhão        362 milhão

Bengali              189 milhão        196 milhão

Hindi                182 milhão        418 milhão

Russian              170 milhão        288 milhão

Portuguese           170 milhão        182 milhão

Japanese             125 milhão

German                98 milhão        121 milhão

 Continue reading ‘Quer levar seu software mobile ao mundo todo? Confira os maiores idiomas.’ »

				

Ensinarei como criar um componente reutilizável em Canvas. Criaremos um botão tocável, que você poderá usar em qualquer tela Canvas em JME. Esse botão só deve ser usado em devices Touch Screen.

O funcionamento se dará da seguinte forma. Criaremos uma classe chamada ImageButtom que representará o botão em si. Ele será eficiente de tal forma que será capaz de se pintar na tela Canvas em que ele estiver, e de disparar eventos quando ele for tocado.

Ele pintará uma imagem de fundo, com o design de um botão. Essa imagem poderá ser carregada por ele mesmo, ou poderá ser passada como parâmetro para ele usar. No construtor do botão poderemos informar então o caminho da imagem que ele deve carregar, ou passaremos a imagem diretamente, já carregada, para ele usar. Qual a diferença? Bem, se temos 2 ou mais botões em uma mesma tela, devemos carregar a imagem apenas uma vez em memória e passá-la aos 2 botões. Assim teremos 2 botões usando a mesma imagem em memória. Se passássemos o caminho da imagem para os 2 botões, cada um carregaria a imagem uma vez na memória, desperdiçando memória. Devemos passar o caminho da imagem para o botão apenas quando teremos apenas 1 botão na tela.

Além da imagem, o construtor deverá pedir pela posição X e Y em que o botão deve ser pintado na tela, bem como o label ou texto que deve ser escrito no centro do botão.

Evento de Toque

Como o botão saberá que ele foi tocado? Bem, quando uma tela Canvas é tocada, é chamado o método pointerReleased(x,y) que tem como parâmetros a posição do toque. Isso acontece em toda tela Canvas naturalmente. Precisaremos apenas sobrescrever esse método da tela Canvas e verificar em qual botão da tela o toque aconteceu. Exemplo:

    protected void pointerReleased(int x, int y) {

        //Verifica se o primeiro botão Alerta foi tocado

        if (botaoAlerta.isTouched(x, y))

            return;

        //Verifica se o primeiro botão Sair foi tocado

        if (botaoSair.isTouched(x, y))

            return;

    }

Continue reading ‘Componentes Canvas - Um botão tocável em JME usando Canvas’ »

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.

Continue reading ‘Framework para gerar aplicações multiplataforma JME e nativas BlackBerry sem saber JME nem BlackBerry’ »

Já havia feito um post, há alguns meses, mostrando como fazer conexões HTTP em JME de forma bastante completa. Mas em muitos casos as pessoas só querem aprender o conceito, como fazer de forma simples. Abaixo segue 2 classes, a classe do MIDlet e a classe do Form. O Form mostra um comando para iniciar a conexão e a conexão é feita, mostrando um log da conexão na tela, e a resposta do servidor na tela.

Continue reading ‘Exemplo Completo e Simples de Conexão HTTP em JME’ »

As vezes precisamos saber se determinado celular suporta uma determinada JSR, por exemplo a JSR-82 (Bluetooth), ou saber todos os celulares que suportam uma determinada JSR. Ou mesmo saber quais celulares suportam MIDP 2.0.

Para isso a Sun compilou uma lista dos celulares por JSR. Basta clicar numa JSR e ver os celulares que a suportam.

http://developers.sun.com/mobility/device/device

Espero que seja útil.

Abraço.

Para interceptar os eventos da caneta, ou do dedo, numa tela de toque, usando Canvas em JME, basta implementar os métodos referente à caneta, que começam com pointer, da classe Canvas.

Veja um exemplo abaixo. Neste exemplo, conforme se percorre a caneta pela tela do device, vão surgindo pontos na tela, onde a caneta disparou o evento.

 Continue reading ‘Eventos da caneta em Canvas numa tela Touch Screen em JME?’ »

				

Ensinarei nesse post a instalar MIDlets JME nos devices BlackBerry de 2 maneiras.

Procedimento 1

Para instalar uma aplicação MIDlet no BlackBerry não é necessário nada de mais. Não é necessário gerar .COD.

Simplesmente gere o JAR/JAD normalmente, como se fosse colocar num outro device qualquer e disponibilize os 2 arquivos num servidor web comum, para que se possa fazer instalação da aplicação via OTA.

Você deve configurar os MIME Types de seu servidor web que armazenará os arquivos JAD e JAR com os MIME Types desses arquivos. Na maioria dos servidores isso não está configurado, e se não for configurado, não funcionará. Encontre as configurações de MIME Type do seu servidor, e adicione os MIME Types abaixo. Aproveite e já defina também o MIME Type das aplicações nativas BlackBerry, .COD.

Continue reading ‘Como instalar MIDlet JME em BlackBerry?’ »

Vou ensinar a assinar aplicações JME usando o NetBeans 6. Com uma aplicação certificada por algum órgão, como a VeriSign, sua aplicação pode ter acesso liberado à muitas funções do device, sem que o ele peça autorização ao usuário para executar tais funções. Por exemplo, se você inicia uma conexão à web por meio da sua aplicação JME, se a aplicação não é assinada, é perguntado ao usuário se ele deseja permitir que a aplicação se conecte à web. Se sua aplicação for assinada, o acesso é feito sem que o usuário autorize.

Primeiro você precisa adquirir o certificado. Depois que você já comprou o certificado da VeriSign, que tem validade de um ano, por exemplo, ela lhe enviará o certificado por e-mail. Será um e-mail como segue:

Título: VeriSign Java Object Signing (Class 3) Digital ID Order Confirmation
Mensagem:

Dear VeriSign Customer,

Congratulations! Verisign has issued your Java Object Signing (Class 3)

Digital ID.  VeriSign has digitally signed your

Digital ID which gives you assurance that your

Digital ID has not been damaged or changed in any way during its transmission to you.

Continue reading ‘Como assinar midlets com certificados digitais e certificar suas aplicações JME?’ »

Estou escrevendo um interpretador Python para BlackBerry, para rodar aplicações Python nesses potentes smartphones. O objetivo é poder rodar aplicações Python for S60, da Nokia, também nos BlackBerry, bem como escrever aplicações mais facilmente nesses devices. O interpretador é um RIMlet, e está sendo escrito para rodar nativamente em BlackBerry, no formato .COD.

Não estou usando nenhum interpretador como base, apenas a própria especificação da linguagem, pois um interpretador para mobile deve ter arquitetura específica, devido a limitações de memória e processamento. Uso o interpretador no desktop para testar e inibir possíveis diferenças, analisando ambas as saídas.

Ainda estou implementando o núcleo da linguagem, como tipos de dados, if, loops, e alguns métodos básicos. Já consigo rodar alguns scripts básicos, como o abaixo.

w = 3

i = 1

resultado = 0

temp = 0

while i <= 1000000:

  resultado = w * i

  temp = i%100000

  if temp == 0:

    print resultado

  i = i + 1

print w

Continue reading ‘Python for BlackBerry escrito em J2ME’ »

Mostrarei um código básico para deixar uma imagem em tons de cinza, ou grayscale.

O algoritmo para deixar uma imagem em tons de cinza é muito simples. Levando-se em conta que cada pixel de uma imagem possui 4 valores ARGB, representando o canal de transparência (A=Alpha), o canal de vermelho (R=Red), o canal de verde (G=Green), e o canal de azul (B=Blue), devemos alterar os canais RGB, mantendo o canal alpha inalterado.

Mas como calcular o tom de cinza de um pixel pelos canais RGB? Basta calcular a média aritmética dos 3 canais e usar esse valor como o novo valor de R, G e B.

Canal Cinza = ((R+G+B) / 3 )

Por exemplo, um pixel que tenha:

A=10, R=120, G=30, B=45

Calcularíamos o canal cinza assim: (120 + 30 + 45) /3 = 56.

Então montaríamos a nova cor do pixel repetindo o canal cinza nos canais RGB, ficando assim:

A=10, R=56, G=56, B=56

Fazendo isso com todos os pixels da imagem, deixando os valores RGB iguais, com o valor da médias dos 3 canais de cores, fará com que a imagem fique em tons de cinza, como mostra a imagem ao lado.

O código é bem simples. Ele trabalha em cima do array ARGB da imagem. Veja:

    public Image grayscaleImage(Image imgOriginal, int porcentagem) {

        //Guarda a largura e altura da imagem

        int largura = imgOriginal.getWidth();        

        int altura = imgOriginal.getHeight(); 


        //Cria o vetor RGB da imagem destino, com o mesmo tamanho da imagem origem

        int[] rgb = new int[largura * altura];

        //Preenche o vetor RGB com as cores dos pixels da imagem origem

        imgOriginal.getRGB(rgb, 0, largura, 0, 0, largura, altura);

        //Deixa a imagem em tons de cinza

        int gray;

        for (int i = 0; i < rgb.length; ++i) {

            gray = (((rgb[i] >> 16) & 0xff) + ((rgb[i] >> 8) & 0xff) + (rgb[i] & 0xff)) / 3;

            rgb[i] = (((rgb[i] >> 24) & 0xff) << 24) | (gray << 16) | (gray << 8) | gray;

        }

        //Cria a imagem final com base no vetor RBG com transparência alterada
        return Image.createRGBImage(rgb, largura, altura, true);    

    }

Continue reading ‘Como deixar uma imagem em tons de cinza em J2ME’ »

Mostrarei um código básico para deixar uma imagem transparente, respeitando a transparência já existente na imagem. Por exemplo, se eu aplicasse 50% a mais de transparência numa imagem, e esta imagem já tivesse pixels semi-transparentes com 50% de transparência, estes pixels ficariam 75% transparentes, enquanto que os outros pixels que não tinham transparência ficariam 50% transparentes.

Veja as duas imagens ao lado. A imagem PNG-24 da motocicleta está com transparência de 70%. Ocorre que ela já possuía pixels semi-transparentes em sua extremidade, e quando aplicamos a transparência de 70%, mesmo estes pixels que já eram trasnparentes ficaram 70% mais transparentes do que já eram.

Procurei bastante na internet por um método para fazer isso, mas não encontrei. O mais perto que cheguei foi de um método que deixava a imagem semi-transparente, mas não respeitava os pixels que já eram semi-transparentes. Isso não poderia ser usado numa imagem PNG-24 com pixels semi-transparentes.

O código é bem simples. Ele trabalha em cima do array ARGB da imagem. Veja:

    public Image transparentImage(Image imgOriginal, int porcentagem) {

        //Guarda a largura e altura da imagem

        int largura = imgOriginal.getWidth();        

        int altura = imgOriginal.getHeight(); 


        //Cria o vetor RGB da imagem destino, com o mesmo tamanho da imagem origem

        int[] rgb = new int[largura * altura];

        //Preenche o vetor RGB com as cores dos pixels da imagem origem

        imgOriginal.getRGB(rgb, 0, largura, 0, 0, largura, altura);

        //Deixa a imagem transparente, respeitando a transparência já existente        

        for (int i = 0; i < rgb.length; i++)

            rgb[i] = (((porcentagem * ((rgb[i] & 0xFF000000) >>> 24))

                     / 100) * 0×1000000) + (rgb[i] & 0×00FFFFFF); 

        //Cria a imagem final com base no vetor RBG com transparência alterada

        return Image.createRGBImage(rgb, largura, altura, true);    

    }

Continue reading ‘Como alterar a semi-transparência de uma imagem em J2ME’ »

Neste artigo mostrarei como carregar e usar imagens em aplicações J2ME de dois modos, usando Canvas, interface gráfica de baixo nível, e usando interface gráfica de alto nível, no caso, Form, List, etc. A primeira tela será uma tela Splash em Canvas com a logo da aplicação, e depois de alguns segundos automaticamente será carregada a tela inicial da aplicação, um Form. Ensinarei também a onde colocar corretamente os arquivos de imagens, de modo que quando for criado o JAR as imagens fiquem dentro dele.

Sobre os tipos de Imagens

Podemos usar tipos diferentes de imagens em nossas aplicações J2ME, mas nem todos os celulares que aceitam vários tipos. Por exemplo, alguns celulares reconhecem JPG e PNG-24, mas outros não. No entanto, todos reconhecem o formato PNG-8. Portanto, se sua aplicação precisa rodar em muitos dispositivos diferentes, use PNG-8, que normalmente é o formato que deixa a imagem com o menor tamanho final, comparando-se com JPG e PNG-24.

Continue reading ‘Tutorial: Como criar e trabalhar com imagens em aplicações J2ME’ »

Estarei apresentando neste artigo uma das melhores práticas para fazer a comunicação com o servidor usando HttpConnection em aplicações móveis J2ME, iniciando a conexão com apenas uma linha de código. Ensinarei a criar uma classe reutilizável responsável por toda a comunicação com o servidor, deixando sua aplicação mais lógica, enxuta e melhor estruturada. Você poderá inclusive disparar várias conexões paralelas, e ainda assim, ao receber os dados, terá o controle de qual conexão se trata. Poderá facilmente cancelar a requisição, caso queira. Se aplicar as informações deste artigo em seus projetos, você passará a se preocupar apenas com as regras de negócio, apenas trabalhará com a informação em si, despreocupando-se com quaisquer detalhes quanto à comunicação com o servidor.

No final do artigo você poderá baixar os arquivos do componente de conexão reutilizável, bem como uma aplicação de exemplo que mostra como usar o componente corretamente.

Continue reading ‘Comunicação paralela com servidor em aplicações J2ME com HttpConnection usando componente reutilizável’ »

Para aqueles que desejam fazer curso sobre desenvolvimento de aplicações para dispositivos móveis, cursos de J2ME, FlashLite, BlackBerry, Symbian, Android, WindowsMobile, PocketPC, etc., estarei dedicando este artigo para listar os principais cursos do país, por tecnologia e região. Iniciarei apenas com os poucos cursos da minha região, mas espero que esta lista cresça mais. Se você deseja indicar um curso sobre mobilidade para aparecer na lista, deixe um comentário no final da página informando a URL que detalha o curso, a tecnologia do curso e a região, e depois de verificar a URL colocarei na lista. Não serão listadas empresas que não possuem uma página especificando o curso de mobilidade. Continue reading ‘Lista de Cursos: Desenvolvimento para Mobilidade. Indique um!’ »