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’ »

Em algumas situações é necessário que sua aplicação seja iniciada automaticamente durante o boot. Para fazer isso é muito simples, basta adicionar ao seu JAD um parâmetro de flags que o BlackBerry usa, com valor 1.

Manifest-Version: 1.0

RIM-COD-Module-Name: xxxxxxxxx

RIM-COD-Module-Dependencies: net_rim_cldc,net_rim_os

…

MIDlet-Permissions: xxxxxxxxx

MicroEdition-Profile: MIDP-2.0

RIM-MIDlet-Flags-1: 1

Feito isso, sua aplicação será iniciada automaticamente quando for instalada, e também quando der um boot no aparelho. Ela será iniciada em background, ou seja, embora você instancie telas, elas não serão mostradas. Quando o usuário entrar na aplicação ela será colocada em foreground, e aí sim ele verá as telas. Se ao iniciar a aplicação, no boot, você já quiser que o usuário veja a tela, se quiser que a aplicação já inicie em foreground, basta chamar o método requestForeground() do seu objeto UiApplication.

Você ainda pode definir outros valores para a flag, veja a baixo:

RIM-MIDlet-Flags-1: 0 //Normal application

RIM-MIDlet-Flags-1: 1 //Auto-Startup

RIM-MIDlet-Flags-1: 2 //System Module

RIM-MIDlet-Flags-1: 3 //System Module & Auto-Startup

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’ »

Citei nos posts passados como integrar sua aplicação com o SO BlackBerry, fazendo com que sua aplicação inicie chamadas, envie e-mails e SMS. Agora vou mostrar como é fácil fazer com que sua aplicação marque um compromisso para o usuário, na agenda/calendário do BlackBerry.

Isso pode ser muito útil em aplicações comerciais. Por exemplo, imagine que sua aplicação tenha uma tela com o cadastro do cliente, com nome, telefone, endereço, informações sobre a conta, etc. Se o usuário quisesse agendar um compromisso, ele deveria sair da sua aplicação, iniciar o calendário, criar um novo compromisso, digitar demoradamente cada ítem do compromisso. Isso é até desanimador, e acaba desestimulando o uso da agenda. Com este recurso você adiciona um ítem de menu na tela de cliente de sua aplicação chamado “Agendar Compromisso”. Quando o usuário clica nesse ítem, abre a agenda do BlackBerry com o novo ítem já criado, com as informações já preenchidas do Nome do Cliente, Local, Anotações sobre o cliente, título do compromisso, e tudo maisque você julgar necessário.

Exemplo:

Colocar na sessão de IMPORTS:

import javax.microedition.pim.Event;
import javax.microedition.pim.EventList;
import javax.microedition.pim.PIM;
import net.rim.blackberry.api.invoke.CalendarArguments;
import net.rim.blackberry.api.invoke.Invoke;

Método de Exemplo:

public void marcarCompromisso(String titulo, String local, String notas) {

    try {
        Event e = null;
        EventList el = (EventList)PIM.getInstance().openPIMList(PIM.EVENT_LIST, PIM.READ_WRITE);
        e = el.createEvent();
        e.addString(Event.SUMMARY, 0, titulo);
        e.addString(Event.LOCATION, 0, local);
        e.addString(Event.NOTE, 0, notas);
        long start = System.currentTimeMillis() + 86400000;
        e.addDate(Event.START, 0, start);
        e.addDate(Event.END, 0, start + 3600000);
        Invoke.invokeApplication(Invoke.APP_TYPE_CALENDAR, new CalendarArguments(CalendarArguments.ARG_NEW, e));
    } catch (Exception e) {
        Invoke.invokeApplication(Invoke.APP_TYPE_CALENDAR, new CalendarArguments(CalendarArguments.ARG_NEW));
    }

} 

Bons códigos!

O uso de acelerômetro abre muitas possibilidades legais de desenvolvimento, e agora que o novíssimo BlackBerry Storm possui esse recurso, vale a pena explorá-lo.

Para usar o acelerômetro no BlackBerry Storm você precisa desenvolver usando API nativa, 4.7 ou superior.

É muito simples de usar. Basta que você leia as posições XYZ do acelerômetro, indicando um vetor short para que a API escreva nesse vetor as três posições.

Veja como é fácil:

public short[] leAcelerometro() {

    short[] xyz = new short[3];

    canal.getLastAccelerationData(xyz);

    return xyz;

}

O método acima retorna um vetor com as posições XYZ do acelerômetro.

No entanto, antes de ler o acelerômetro, é necessário abrir um canal com o hardware dele, e fechá-lo quando não for mais necessário fazer leitura do acelerômetro. Você só deve abrir o canal quando realmente for iniciar o uso do acelerômetro, fazendo várias leituras seguidas.

Continue reading ‘Como usar a API do Acelerômetro no BlackBerry Storm?’ »

Para os que desejam desenvolver para BlackBerry aproveitando os novos recursos dos novíssimos modelos BlackBerry Storm, Bold e Pearl Flip, a Rim já disponibilizou para download free a nova JDE v4.7 (beta) e novos emuladores para os modelos.

A nova JDE já inclui o emulador para o BlackBerry Storm. É só baixar, integrar ao Netbeans, e desenvolver!

Entre os novos recursos e APIs, pode-se citar:

- Suporte a Touch-Screen em suas aplicações.
- Suporte a orientação (bússola) e rotacionamento automático da tela.
- Suporte a acelerômetro.
- API para controle do teclado virtual.
- Permite que sua aplicação defina o papel de parede do Blackberry.
- Vários novos recursos para controle multimídia.
Continue reading ‘Ferramentas de desenvolvimento para BlackBerry Storm, Bold e Pearl Flip’ »

Os devices BlackBerry possuem ricas API para acesso ao sistema do celular. É muito fácil enviar um e-mail, iniciar uma chamada, ou enviar um SMS de dentro da sua aplicação. No entanto, o comum a fazer quando se deseja fazer alguma dessas coisas, é fazer a sua aplicação abrir o programa do sistema BlackBerry responsável, passando os parâmetros necessários, e deixar que o usuário faça o que deseja usando o programa do celular.

Por exemplo, digamos que você queira que sua aplicação envie e-mail. Sua aplicação chamará o programa do BlackBerry responsável por e-mails, passando o endereço de e-mail, o título do e-mail, entre outras coisas. Então o usuário continuará a enviar o e-mail por usando o programa do BlackBerry. Após fechar o programa de e-mail, o usuário voltará à sua aplicação automaticamente.

Mostro abaixo 2 métodos básicos para enviar e-mail.Você pode explorar ainda mais as classes Invoke e ApplicationArguments, que são os argumentos para cada programa.

void doCall(String numero) {

    Invoke.invokeApplication(Invoke.APP_TYPE_PHONE, new PhoneArguments(PhoneArguments.ARG_CALL, numero));

}

static void doEmail(String para, String titulo, String mensagem) {

    Invoke.invokeApplication(Invoke.APP_TYPE_MESSAGES, new MessageArguments(MessageArguments.ARG_NEW, para, titulo, mensagem));

} 

Abraço.

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.

Precisei recentemente pegar informações do e-mail do usuário, num smartphone BlackBerry. Vou compartilhar com a comunidade.

Basta usar a classe Session, e pegar o objeto que guarda todas as configurações do e-mail do usuário que é uma instância da classe ServiceConfiguration.

Veja um exemplo rápido:

public String getEmail() {

    Session s = Session.getDefaultInstance();

    String mail = s.getServiceConfiguration().getEmailAddress();

    return mail;

} 

Dá para pegar também o nome do usuário.

Isso é legal para personalizar a aplicação com o nome do usuário, ou para pré-preencher um campo de login de sua aplicação.

Abraço.

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?’ »

Ensinarei alguns macetes para você que desenvolveu uma aplicação nativa BlackBerry, e precisa publicá-la na web, para que outras pessoas possam instalá-la em seus devices usando o browser do próprio device, tal como fazemos com aplicações JME MIDlets. Chamamos esse tipo de publicação de OTA.

Quando você faz o deploy da sua aplicação no NetBeans, o NetBeans gera o arquivo .COD da sua aplicação dentro da pasta do simulador. O simulador fica dentro da pasta em que foi instalado o JDE. No meu caso:

C:\Dev\Java\Sdk\BlackBerryJDE4.2.1\simulator\MinhaAplicacao.cod

Dependendo do tamanho da sua aplicação, esse .COD criado dentro da pasta Simulador, na verdade é um arquivo .ZIP mascarado, com um ou mais .COD dentro dele. Para você instalar via OTA, você precisará descompactar esse .COD original, e fazer Upload desses vários .CODs descompactados para um diretório em seu FTP. Não envie para o FTP o .COD original, apenas os arquivos que estavam dentro dele.

Além de enviar para o FTP esses vários .CODs, será preciso enviar também o arquivo .JAD, que fica dentro da pasta “dist” do NetBeans. Sempre que você faz o deploy no NetBeans, o JAD e o COD são criados. O JAD fica dentro da de “dist”, já o COD vai para a pasta do simulador.

Continue reading ‘Como publicar sua aplicação nativa BlackBerry via OTA na web para ser instalada pelo browser do device?’ »

É muito prático, principalmente na hora do desenvolvimento, enviar suas aplicações nativas para o BlackBerry usando o cabo USB. Você precisará apenas do .COD final, aquele que é gerado na pasta do emulador BlackBerry.

Você precisará do BlackBerry Device Manager rodando. Normalmente ele aparece na área de notificação do windows (próximo ao relógio). Caso você não o tenha, instale-o. Você poderá baixá-lo no site www.blackberry.com. Se você instalou o BlackBerry Desktop Software, ele automaticamente instala o BlackBerry Device Manager.

Se certifique de que o cabo USB está conectado ao device e ao PC. Dê duplo clique no Device Manager, e aparecerão as portas COM. Deve aparecer também a porta “USB:PIN - Connected”. Caso não apareça, procure solucionar isso antes de continuar.

Eu sugiro criar uma pasta chamada OTA, dentro da pasta do seu projeto, e criar um arquivo .BAT com os três comandos MS-DOS, para que você não precise ficar digitando comandos sempre que quiser enviar a aplicação para o BlackBerry. O primeiro comando copia da pasta do simulador o último arquivo .COD gerado. O segundo comando apaga, ou desinstala, a aplicação antiga do device, caso ela exista. O terceiro comando envia para o device a sua aplicação .COD que rodou no emulador BlackBerry.

Continue reading ‘Como enviar uma aplicação nativa BlackBerry para o device usando o cabo USB?’ »

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’ »

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’ »

Explicarei nesse artigo como preparar sua aplicação para usar conexões com a Internet de forma funcional, decidindo se deve usar transporte por BES (BlackBerry Enterprise Server), BIS (BlackBerry Internet Server), WAP, conexão direta pelo device TCP (APN), ou Wi-fi.

A grande maioria dos desenvolvedores BlackBerry já passaram por esse problema. Inicialmente todos desenvolvedores pensam que basta criar uma conexão normalmente, e tudo estará resolvido. Até que começar a ter os erros “Invalid Tunnel” ou “Can’t Open Connection”, ou erros semelhantes. Esses erros ocorrem pois a conexão não foi configurada corretamente na aplicação, e ela está tentando usar uma conexão indisponível no device.

Nos outros celulares, quando fazemos uma conexão com a Internet em nossa aplicação, o próprio celular pergunta ao usuário qual conexão ele deseja usar, se WAP, ConnectFast, Wi-fi, etc. No BlackBerry não é assim, em cada conexão você precisa definir qual será o meio de transporte dos dados.
Continue reading ‘Conexões HTTP e Socket com BIS BES WAP Wi-Fi e TCP APN em aplicações BlackBerry’ »

Ensinarei neste tutorial como preparar seu computador para poder desenvolver aplicações nativas para BlackBerry, usando a JDE instegrada ao NetBeans. Conheça as diferenças entre aplicações MIDlet e RIMlet lendo este post escrito por mim:
Aplicações BlackBerry: RIMlet X MIDlet.

Para desenvolver para BlackBerry você precisará fazer download, instalação e configuração dos seguintes softwares. Salve todos os downloads numa única pasta, e ao terminar todos os downloads, dê continuidade ao tutorial.

Continue reading ‘Configurar a plataforma de desenvolvimento BlackBerry JDE no NetBeans’ »