A prova dos 9: confrontando o Android e o iPhone em 9 tarefas do dia-a-dia

1) Navegando na web

Android

• Tela menor que o iPhone.
• Possui uma lupa para dar zoom em trechos da página (solução encontrada devido ao espaço restrito da tela).
• Agilidade do browser(Chrome) para fazer buscas.
• O navegador não suporta conteúdo em flash.
  

iPhone

• A interface multitoque faz toda a diferença para navegar na web.
• O navegador não suporta conteúdo em flash.
  

2) Playlist em ação

Android

• Player com visual simples ao extremo.
• Permite usar dados do artista para buscar músicas no YouTube.
• Liberdade para carregar o aparelho com músicas.
• Transferências das músicas para o G1 de forma simples, como uma pen drive.
  

iPhone

• Para carregar o iPhone com MP3s é necessário o uso do iTunes.
• O iTunes sincroniza as músicas de forma veloz e organizada, herdando as capas dos disco, porém você perde o controle sobre seus arquivos.
  

3) Ligado nos e-mails

Android

• Vem com dois aplicativos: Email e Gmail.
• Contatos e pastas da conta do Gmail podem ser transformados em atalhos na área de trabalho.
• Não tem suporte nativo com o Microsoft Enchange nem com o Outlook.
  

iPhone

• Grande compatibilidade com padrões de correios eletrônicos. Suporta Enchange, Gmail, MobileMe.
• Mostra resumos abaixo do assunto e integra bem contatos com endereços do Google Maps.
  

4) RSS na tela

Android

• Os aplicativos de notícia não são tão badalados quanto os do iPhone.
• O Android Market oferece pelo menos 18 opções de leitores RSS com os mais variados perfis.
• Porém é necessário instalar um destes leitores ou usar a versão online do Google Reader, porque o browser do Android não lê nem reconhece feeds RSS sozinho.
  

iPhone

• Grandes produtores de notícia do mundo já criaram aplicativos exclusivos para exibir seu conteúdo sem cobrar nada, como o New York Times.
• O safári é integrado a leitores básicos de notícias, como o .Mac Reader e Google Reader.
  

5) A hora dos vídeos

Android

• Ainda não possui aplicativos para rodas os formatos de vídeos mais populares.
• Não possui aplicativos para gravar vídeos.
• O sistema suporta um único site de vídeos em flash, o YouTube.
  

iPhone

• Possui o iTunes que roda vídeos em formato MP4 e MOV.
• Possui vários programas de terceiros que convertem vídeos de codecs variados para a resolução correta do iPhone, como o Free Video to iPhone Converter.
  

6) Bem nas fotos

Android

• A câmera do G1 possui 3.2 MP, contra 2.0 MP do iPhone.
• Suporta edição básica das fotos, como corte e rotação.
• As imagens podem ser enviadas rapidamente por e-mail ou mensageiro instantâneo.
• Usa a câmera para fazer truques como mesclar dados da internet com informações digitalizadas de códigos de barra e cartões de visita por meio de aplicativos como o Barcode Scanner.
  

iPhone

• Câmera de 2.0 MP.
• Ausência de recursos básicos de edição. Porém existem aplicativos pagos e gratuitos que podem suprir esta carência, como o Photogene.
  

7) Bússola digital

Android

• Integra contatos com pontos de mapas.
• Tem visualização Street View.
• Incorpora um recurso com muito potencial, os microformatos.
• O browser é capaz de interpretar os textos exibidos nos sites e, quando o usuário clica sobre um nome de rua, o Android oferece a opção de localização no mapa, como se o endereço fosse naturalmente um link para o mapa. Porém por enquanto só reconhece endereços nos Estados Unidos.
  

iPhone

• Tanto o iPhone como o G1 fazem apenas triangulação de antenas de celulares e não traça rotas em tempo real, como um navegador GPS faz.
• O trunfo da Apple é a variedade de aplicativos legais que usam o sistema de posicionamento, como o Trapster, que alerta o motorista sobre a localização de semáforas e radares de fiscalização de velocidade, inclusive nas ruas aqui do Brasil.
  

8) No expediente
Android

• Pobre no quesito softwares de escritório.
• Para editar os documentos de verdade é preciso apelar para aplicativos simplórios no estilo bloco de notas.
• O teclado físico ajuda muito na hora de escrever e a trackBall traz conveniência e agilidade na hora da edição de documentos.
  

iPhone

• Falta um aplicativo bom para edição de textos.
• Porém existem muitos programinhas simples que podem quebrar o galho.
• Para editar textos a pedida é um serviço online, Zoho.
• Para edição de planilhas uma solução é o Mobile Files Pro, que é um aplicativo pago.
• Para ver documentos é possível usar o Google Docs ou plug-ins do iPhone.
  

9) Sim, eles telefonam
Android

• Para digitar qualquer coisa, inclusive SMS, é necessário deslizar o teclado do G1.
• Na hora de telefonar é possível usar a tela sensível ao toque para discar os números.
• Uma qualidade do G1 é a sua natureza multitarefa, que facilita o uso de outras funções do telefone enquanto você conversa.
  

iPhone

• Integração com as mensagens do correio de voz.
• Uso do acelerômetro para reconhecer gestos na hora de atender as ligações.
• O uso intenso dos comandos por toque acaba formando uma camada de gordura sobre a tela.
  

fonte: Revista Info - fevereiro de 2009.

AT&T anuncia rede móvel duas vezes mais rápida

A AT&T anunciou quarta-feira(24/05/09) os planos de upgrade para a tecnologia High Speed Packet Access 7.2 (HSPA 7.2), que promete acesso móvel à internet duas vezes mais rápido que o atual. A atualização da rede foi um dos temas abordados pelo CEO da empresa, Randall Stephenson, durante a conferência "All Things Digital". "Eles chamam isso de um caminho intermediário entre o 3G e o 4G, que ainda está por vir", disse o presidente do Terra, Fernando Madeira, que participa do evento na Califórnia.

A migração para HSPA 7.2 começa este ano, deve estar concluída em 2011 e pode proporcionar uma velocidade de até 7.2 Mbps. Em 2010, a AT&T começa os testes com o LTE (Long Term Evolution), padrão de banda larga móvel considerado de 4ª geração e que pode chegar a 20Mbps.

Para acessar a notícia completa clique aqui.

Aplicativo de celular ajuda deficientes visuais a "enxergar"

Utilizando a câmera dos telefones celulares mais modernos, o software é capaz de reconhecer objetos do dia-a-dia e descrevê-los em voz alta.

O programa possui uma biblioteca de objetos que permite confrontar as imagens gravadas na memória com as obtidas com a câmera do celular e, depois de um rápido processamento, identificar o objeto. Novas entradas podem ser adicionadas, contando-se com a ajuda de uma pessoa de visão inalterada.

Veja um vídeo do software sendo usado.




Clique aqui para acessar a notícia completa.

Iniciando no J2ME: Agenda sem banco

Exemplo prático para a utilização de form, list, alert, entre outros.

Código Fonte: Agenda em J2ME

1) Crie um projeto Java ME – Aplicativo Móvel, com o nome de “agenda”. Vamos usar CLDC-1.0 e MIDP-2.0.
Caso não saiba como criar um projeto para um aplicativo Móvel veja o post (Como criar um projeto J2ME e desenvolver um Hello World).

2) No fluxo gerado aparece um form com um exitCommand. Clique sobre o form com o botão direito e vá em propiedades.
No campo título escreva “Agenda” e em nome da instância escreva formPrincipal.
Neste ponto o Netbeans já gerou este form que agora é o formPrincipal. E as alterações feitas pelo editor visual são feitas no código fonte pelo Netbeans.

3) Clique sobre o formPrincipal e vá em tela. Exclua o StringItem que tem na tela (Hello, Hello World). Para excluir clique com o botão direito do mouse e selecione excluir.

4) Clicando com o botão direito sobre a tela em branco do formPrincipal temos em Novo/Adicionar vários itens e comandos que podem ser adicionados. Insira dois Campos de texto (textField).
Clicando sobre o primeiro textField inserido, vá em propriedades e mude o rótulo para “Nome:” e o nome da instância para textFieldNome. Em restrições de entrada está ANY, que significa que pode ser qualquer caracter.
No segundo textField mude as propriedades para: “Telefone:”, “textFieldTel” e em restrições de entrada selecione “Numeric”, que restringe a entrada só para números.

5) Precisamos agora de botões que realizem os eventos de inserir e exibir os dados da agenda.
Então, clicando sobre o formPrincipal vá em Novo/Adicionar e selecione Comando Ok. Nas propriedades do Command mude o rótulo para “inserir” e o nome da instância para “cmdInserir”. Insira um outro Comando Ok com “Exibir” e “cmdExibir”.
A tela ficou desta forma:


6) Vamos agora programar a ação do cmdInserir. Em cima dele clique com o botão direito e vá em código fonte. Precisamos guardar o que o usuário digitou nos campos, para serem salvos.
Nós como ainda não utilizaremos Banco de dados, vamos guardar os dados em vetores. Para capturar o conteúdo dos textFields precisamos acessá-los através do getTextFieldNome() e getTextFieldTel() e pegamos o seu texto com getString(). Estes dois primeiros métodos são os que criam e retornam os textFields que foi gerado no editor visual. Caso a aplicação seja feita a mão, estes métodos precisam ser implementados por você.

7) Criamos variáveis temporárias para alocar o nome e telefone que o usuário entrou. Portando o código fica o seguinte:

else if (command == cmdInserir) {
String nomeTemp = getTextFieldNome().getString();
String telTemp = getTextFieldTel().getString();
}

8) Agora nos atributos da classe vamos declarar dois vetores de String, um para os nomes e outro para os telefones. E também um contador para manipular as posições do vetor.

private String[] nome = new String[100];
private String[] tel = new String[100];
private int contador = 0;

9) Agora voltando ao código do cmdInserir vamos guardar no vetor os dados coletados que estão nas variáveis temporárias. Estas servem pra fazermos verificações futuramente.

nome[contador] = nomeTemp;
tel[contador] = telTemp;
contador++;

10) Podemos criar um alert pra exibir uma mensagem de erro quando os campos não estiverem preenchidos corretamente ou para exibir uma mensagem de sucesso quando inserir corretamente. Para isso vá no fluxo e clique sobre a área livre com o botão direito e selecione alert.

11) Dentro desse alert coloque um CommandBack, para voltar ao formPrincipal depois que exibir sua mensagem. Para isto vá na tela no alert e insira o comando da mesma forma que foi feito para o form, porém o agora é comando voltar e não comando ok.

12) No fluxo, puxe uma seta do comando Inserir para o alert. Uma via será criada com uma seta para o formPrincipal, como mostra a figura abaixo.


13) Insira um seta saindo do backCommand do alert até o formPrincipal. Agora quando clicar em Inserir o alert será chamado. Então vamos tratar os casos de sucesso ou erro.

14) O código fonte do cmdInserir agora fica da seguinte forma:

if (command == cmdInserir) {
String nomeTemp = getTextFieldNome().getString();
String telTemp = getTextFieldTel().getString();
//Se um dos textFields estiver vazio quando aperta Inserir
if(nomeTemp.equals("")||telTemp.equals("")){
//seta a mensagem que aparecerá no alert. Mensagem de erro!
getAlert().setString("Algum campo está vazio! Preencha corretamente");
}else{ //se os campos estiverem preenchidos
//guarda os dados nos vetores
nome[contador] = nomeTemp;
tel[contador] = telTemp;
contador++;
//seta a mensagem do alert. Mensagem de sucesso!
getAlert().setString("Os dados foram inseridos com sucesso!");
//limpa os textFields para inserir novos dados
getTextFieldNome().setString("");
getTextFieldTel().setString("");
}
switchDisplayable(getAlert(), getFormPrincipal());
}

15) Os dados já estão sendo guardados! Agora para exibi-los vamos usar um list. Na área livre do fluxo clique e insira uma lista. Insira nesta lista um CommandBack (Voltar), indo na tela do list e fazendo os procedimentos já explicados.

16) No fluxo puxe uma seta do commandBack do list para o formPrincipal. Podemos também mudar os títulos do alert e do list na propriedades destes.

17) Para a tela do list ser exibida quando selecionarmos Exibir devemos ligar o cmdExibir ao list, puxando uma seta deste comando situado no formPrincipal até o list. Desta forma nosso fluxo final é o seguinte:


18) Agora é só configurarmos nosso comando Exibir e a aplicação estará pronta. Vá ao código fonte do cmdExibir. Agora é só imprimirmos os vetores e exibi-los na tela. Antes de cada exibição é importante limpar a tela, para não listar dados repetidos.

if (command == cmdExibirDados) {
getList().deleteAll(); //apaga o que está no list
for(int i=0;i
//o vetor tem muitas posições e nem todas estão preenchidas então
//só imprimimos se for diferente de null
if(nome[i]!=null){
     //adiciona na lista o nome contido no vetor “-“ e o telefone
     getList().append(nome[i] + " - " + tel[i], null);
}
}
}

19) A aplicação está pronta!

Form, Itens, List, Alert eTextbox

Conforme visto no post anterior (Interface com o usuário: Display, Displayable e Command), form, list, alert e textbox são heranças da classe Screen, que é uma herança da classe Displayable.

Form: é um formulário o qual pode conter textos, imagens e outros itens que são herança da classe Item. Você pode por vários itens em um form e se houver necessidade ele apresenta barra de rolagem automática. Porém nada muito extenso é viável para aplicações móveis.

Quanto aos itens, temos: StringItem, TextField, ImageItem, DateField, ChoiceGroup, Gauge e Spacer.

StringItem: é um simples texto, porém não pode ser editado.


TextField: Campo para entrada ou edição de texto. Pode ter uma formatação ou limitação. Por exemplo: aceitar somente números, qualquer caracter, ser um campo de senha, entre outros.


ImageItem: permite inserir uma imagem no form. É necessário instanciar um objeto do tipo Image.


ChoiceGroup: É uma lista de escolhas, dentro de um form. Possui os tipos: múltiplo, exclusivo ou pop up.

Múltiplo: podem ser selecionadas várias opções do choiceGroup;


Exclusivo: Pode ser selecionado apenas uma opção e esta é marcada com um radio Button.


Pop Up: Pode ser selecionada apenas uma opção. E a lista de opções é exibida conforme mostra a figura a baixo.

DataField: Campo utilizado para exibir data e/ou hora.


Gauge: É uma representação gráfica de um número inteiro. Ele permite que o usuário defina um nível, como o volume por exemplo, se for um Gauge interativo. Se for não interativo é somente o programa que o controla.


Spacer: Determina um espaçamento vertical e/ou horizontal mínimo entre os componentes de um form.



Além do form temos outros Screens como:

List: É uma lista que permite ao usuário selecionar opções. Estas podem ser tanto uma String quanto uma imagem. É importante lembrar que os itens citados a cima não são disponíveis para ser usados em list ou outras telas que não sejam um form. Os lists podem ser exclusivo, múltiplo ou implícito.

Implícito: Pode ser selecionada apenas uma opção. Não possui radio button ou check box.


Alert: É uma tela de informação ao usuário. Pode conter uma mensagem de erro, de sucesso, entre outras. Ele pode ser programado para ser exibido durante um tempo pré determinado e sua aparência varia de acordo com o dispositivo móvel usado .


Textbox: Basicamente é uma tela que serve para entrada de texto. É como se fosse um textField que ocupasse o espaço da tela inteira.


No próximo post iremos aplicar estes conceitos em um exemplo prático: uma agenda. Porém sem usar banco de dados ainda. Nesta aplicação utilizaremos um form, com textFields para capturar os dados, um list para exibir os dados salvos, um alert para as mensagem de erro ou sucesso e commands para controlar eventos da aplicação.

Interface com o usuário: Display, Displayable e Command.

As aplicações feitas em J2ME (MIDlets) devem rodar em qualquer dispositivo que tenha uma máquina virtual Java. Porém os dispositivos podem variar em tamanho de tela, número de cores que representam na tela, disposição dos botões, entre outros e estas informações são acessadas pela MIDlet somente em tempo de execução.

Para solucionar esses problemas as aplicações são desenvolvidas com uma certa abstração de tela e para acessar as informações de um determinado aparelho existe a classe Display. Cada MIDlet possui sua própria instância dessa classe que pode ser acessada pelo método

Display.getDisplay(MIDLet).

Portanto, a tela do dispositivo é representada por uma instância da classe Display e para que seja mostrado algo na tela devemos passar um objeto Displayable para o objeto da classe Display.

Displayable é uma classe abstrata que controla o que é mostrado na tela e os comandos enviados pelos usuários.

Existem duas classes que herdam a classe Displayable, que são: Screen e Canvas.

Canvas é uma classe de baixo nível (Low-Level API’s). Ela proporciona maior liberdade na implementação dos gráficos e eventos. É muito utilizada para a criação de jogos.

Screen é uma classe de alto nível (High-Level API’s). Ela contém objetos gráficos “prontos”, como forms, lists, alerts e textboxes, onde cada um pode ter uma aparência, variando de acordo com o dispositivo em que esta sendo executada a aplicação. Screen e suas heranças são classificadas como objetos de interface.

Em um Displayable podem ser exibidos comandos, que são aplicados aos botões. E no form podem ser exibidos itens, como: ChoiceGroup, DataField, ImageItem, StringItem, TextField, entre outros, que serão explicados com mais detalhes em posts seguintes.

Os comandos (commands) são usados para a interação do usuário com a aplicação. Podem ser atribuídos a um Displayable ou a um Item. Uma de suas funções básicas é a troca de Displayables. Quando um comando é acionado pelo usuário, é notificado a um CommandListener que é definido no objeto Displayable.

Todas essas classes pertencem a biblioteca javax.microedition.lcdui que é demonstrada no diagrama abaixo.

Resumindo,

O Display faz a ponte entre as telas da aplicação (Displayables) e a aplicação (MIDlet). É a classe que recebe os Displayables.

O Displayable é uma superclasse a qual deriva duas subclasses: Screen, que é de alto nível e Canvas, que é de baixo nível.

E Commands são comandos associados ao Displayable, que são usados na iteração entre usuário e aplicação.

No próximo post veremos uma subclasse de Screen, o form, e alguns tipos de itens. O artigo conterá teoria e um exemplo prático, com explicação do código.

Ciclo de vida do MIDlet

Depois de adquirirmos conhecimento sobre a Arquitetura J2ME vamos entender como funciona uma aplicação desenvolvida utilizando essa tecnologia.

O que é MIDlet?
É uma aplicação destinada para dispositivos móveis desenvolvida com a utilização do perfil MIDP, que está vinculado a configuração CLDC. Os MIDLets devem herdar a classe MIDLet que contêm métodos que inicializa, resume, interrompe a execução e destrói um MIDLet.

O gerenciador de aplicativos (AM – Application Manager) de cada dispositivo é quem controla os aplicativos a serem instalados, onde e como serão armazenados e como serão executados. A comunicação do gerenciador com o MIDlet acontece pela classe MIDlet do pacote javax.microedition.midlet.MIDlet.
Uma aplicação é iniciada quando o AM invoca o método startApp(), colocando a aplicação no modo ativo. Enquanto ela estiver executando ela pode ser pausada pela AM através do método pauseApp(), isto pode ocorrer quando uma chamada for recebida por exemplo ou o próprio usuário pode pausar a aplicação. E quando a aplicação é encerrada ela passa para o estado destruído. Dessa forma o ciclo de vida do MIDlet fica o seguinte:


Além do startApp() e do pauseApp() temos ainda outros métodos:

destroyApp(): limpa todos os recursos para fechar a aplicação.
notifyDestroy(): avisa ao gerenciador que pode desligar a MIDlet.
notifyPaused(): envia o pedido de pausa para o gerenciador caso a MIDlet queira pausar.
resumeRequest(): avisa ao gerenciador que a MIDlet pode tornar-se ativa novamente.

Os métodos startApp(), pauseApp() e destroyApp() são os 3 métodos essenciais a um MIDlet. Sem algum destes métodos não temos um MIDlet.

Arquitetura J2ME

J2ME (Java Micro Edition) é a plataforma Java direcionada para micro aplicativos. Ou seja, aplicativos destinados a dispositivos que possuem processamento, memória e vídeo limitados, como celulares, PDA’s, TVs, controle remotos e outros embarcados.

A arquitetura J2ME é dividida em Configurações, Perfis, Máquina Virtual e API’s opcionais.

As configurações definem as bibliotecas que são necessárias para o funcionamento da máquina virtual (JVM). Elas são: CLDC (Connected, Limited Device Configuration) e CDC (Connected Device Configuration).

A primeira é destinada a dispositivos mais simples e menores, como celulares, pagers e PDAs, que possuem processamento de 16/32 bits e memória de 128/512 kb. A segunda rege os dispositivos com capacidade um pouco maior: com pelo menos 32bits de processamento e 2 MegaBytes de memória, como TV digital, dispositivos sem fio de alto nível e sistemas automotivos.

Os perfis são um conjunto de aplicações que complementam uma configuração e fornecem funcionalidades para desenvolver um aplicativo para um determinado dispositivo.

Perfis para a configuração CLDC: MIDP (Mobile Information Device Profile) e PDAP (PDA Profile).

MIDP é a biblioteca necessária para a execução de qualquer aplicativo escrito para J2ME, os chamados MIDlets. Ele possui classes de interface com o usuário e acesso a rede, entre outros. E PDAP é um ambiente de execução especialmente para PDAs.

Para a CDC temos o Foundation Profile e o Personal Basis Profile. O primeiro é um perfil para dispositivos interconectados em rede e sem interface gráfica. E o segundo oferece suporte a gráficos.

Quanto a máquina virtual temos a CVM (Compact Virtual Machine), que é vinculada a configuração CDC e a KVM (Kilo Virtual Machine) que é vinculada a CLDC.

Para melhor entender, veja uma visão geral da Arquitetura Java, mostrando a formação da tecnologia J2ME, inclusive onde se enquadra os celulares
.

Iniciando em J2ME: Analisando o código Hello World

Continuando o último post (Iniciando em J2ME: Desenvolvendo o Hello World), vamos explicar agora todo o código fonte gerado pelo editor visual do Netbeans, para o código do Hello World.

O código ficou o seguinte:


A classe HelloMIDlet extende MIDlet (é um código java de aplicativo móvel) e implementa CommandListener, que é a classe responsável pelos comandos, no caso o CommandExit, que sai do aplicativo.

Em General Fields: estão as declarações necessárias.

private Command exitCommand; // o comando Sair
private Form form; //o form utilizado
private StringItem stringItem; //o item de string com Hello e Hello World

Em Generated Method: startMIDlet - função startMIDlet, é onde escrevemos como deve iniciar a aplicação.

public void startMIDlet(){
switchDisplayable(null,getForm());
}

No caso a aplicação inicia com o comando switchDisplayable, que exibe um display (tela). O primeiro parâmetro é de onde esta vindo (de que tela) e o segundo para que tela quer ir, que tela quer mostrar, no caso a tela form, que é obtida através da função getForm().

Em Generated Method: switchDisplayable - função que retorna qual tela mostrar, de acordo com os parâmetros mandados, como vimos acima.

Em Generated Method: commandAction for Displayables - implementação dos comandos usados na aplicação.

public void commandAction(Command command, Displayable displayable){
if (displayable == form){
  if (command == exitCommand){
      exitMIDlet(); 
  }
}
}

No displayable form está o comando exit (exitCommand) que quando selecionado executa o código determinado, no caso o exitMIDlet, que encerra a aplicação.

Em Generated Getters: exitCommand - código que cria e retorna o exitCommand.

public Command getExitCommand() {
if (exitCommand == null) {
  exitCommand = new Command("Exit", Command.EXIT, 0);
}
return exitCommand;
}

exitCommand recebe um novo comando. Os parâmetros são o nome, que vai aparecer na tela, o tipo do comando, no caso EXIT e a prioridade do comando.

Em Generated Getters: form - código que cria e retorna o form.

public Form getForm() {
if (form == null) {
  form = new Form("Welcome", new Item[] { getStringItem() });
  form.addCommand(getExitCommand());
  form.setCommandListener(this);
}
return form;
}

O form recebe um novo form e os parâmetros definem como este vai ser. O primeiro parâmetro é o título, o segundo são os itens que este possui. Entre chaves está o método que retorna cada item.

Em uma tela (form, list ou outro) podem ter vários itens. Para mostrar quais são os itens e screens (telas) vejamos a figura abaixo que define a hierarquia de componentes do J2ME.


Continuando o código da função getForm() temos a linha:

form.addCommand(getExitCommand());

Corresponde ao ExitCommand que está sendo adicionado ao form e em

form.setCommandListener(this);

informamos que neste form existe um evento.

Em Generated Getters: stringItem - código que cria e retorna este item de string.

public StringItem getStringItem() {
if (stringItem == null) {
   stringItem = new StringItem("Hello", "Hello, World!");
}
return stringItem;
}

stringItem recebe um novo StringItem e os parâmetros são os textos que vão aparecer na tela, no primeiro campo e no segundo.

Depois disso temos a função getDisplay() que retorna uma instância da classe Display, a qual serve para a MIDlet acessar as informações do dispositivo em que esta sendo executada. Estas informações são referentes ao tamanho da tela, disposição de botões, cores, entre outros.

public Display getDisplay () {
return Display.getDisplay(this);
}

Em seguida a função exitMIDlet() - encerra o aplicativo.

public void exitMIDlet() {
switchDisplayable (null, null);
destroyApp(true);
notifyDestroyed();
}

Primeiro é setado null (nada) para ser exibido na tela.
Depois é destruída a aplicação e essa ação é notificada ao gerenciador.

Os próximos 3 métodos são obrigatórios para o MIDlet e serão criados sempre que criar um novo MIDlet.

O primeiro: startApp é chamado automaticamente quando a plicação é executada.
Se você não clicar em iniciar (launch) a aplicação ficará no estado pausado (resumeMIDlet).
Se você iniciar a aplicação isto vai ser notificado e o starMIDlet será chamado para executar a(s) primeira(s) ação(ões) desejada(s).
Como o MIDlet está em execução o midletPaused é setado como falso.

public void startApp() {
if (midletPaused) {
   resumeMIDlet ();
} else {
   initialize ();
startMIDlet ();
}
midletPaused = false;
}

O segundo método é para quando a aplicação for pausada. O midletPaused é setado como verdadeiro.

public void pauseApp() {
midletPaused = true;
}

E o último método é para destruir a aplicação. Pode ser passado true ou false como parâmetro. O false seria usado para gerar uma exceção quando o usuário optar por sair, para o gerenciador ver se o aplicativo pode ser fechado. O true diz que a aplicação será fechada independente de qualquer coisa, mesmo que algum processo ainda esteja sendo executado.

public void destroyApp(boolean unconditional) {
}

Terminada a análise do código! Qualquer dúvida é só entrar em contato.

Como criar um projeto J2ME e desenvolver um Hello World

Olá! Para quem está querendo iniciar no desenvolvimento de aplicativos em J2ME aqui vai um dos primeiros passos, o Hello World!
Mostraremos passo a passo como configurar e “iniciar o desenvolvimento”.

Quanto a IDE, as duas mais utilizadas são o Eclipse e o Netbeans. O Eclipse para J2ME tem um plugin chamado EclipseME e o Netbeans utiliza o Mobility Pack.
Nós particularmente preferimos o Netbeans, pois já vem por default com um editor visual e isto para quem esta começando é evidentemente muito bom! Por isso aqui vamos utiliza-lo, mas é importante sempre olharem os códigos gerados pelo editor visual. É muito mais fácil e rápido desenvolver com este editor, porém mais pra frente certamente vai se deparar com alguma situação em que para atender ao que deseja terá que fazer tudo a mão, ou alguma parte pelo menos.

No link abaixo está disponível a versão 6.5.1 do Netbeans, e você pode escolher baixar-lo com quais tecnologias desejar.
http://www.netbeans.org/downloads/index.htmltml

Além do NetBeans é necessário o JDK (Java Development Kit), disponível em:

https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewProductDetail-Start?ProductRef=jdk-6u13-oth-JPR@CDS-CDS_Developer

Mãos a obra!

1) Abra a IDE Netbeans, clique em Arquivo > Novo
2) Em Categorias, selecione Java ME e em Projetos, Aplicativo móvel e clique em próximo.

3) Escolha o nome do projeto, mantenha selecionadas as opções “configurar como projeto principal” e “criar MIDlet Olá”. Esta ultima cria um MIDlet junto com o projeto. Clique em próximo.

Nota: MIDlet é um aplicativo Java para dispositivos móveis. Uma aplicação feita para estes tipos de dispositivos podem conter classes Java e outras, mas se não tiver um MIDlet não roda. Ainda podemos definir MIDlet como uma aplicação desenvolvida com a utilização do perfil MIDP e consequentemente da configuração CLDC. CLDC é uma configuração destinada a dispositivos de capacidade de processamento e memória restritos, como os celulares. MIDP é um perfil que se engloba nesta configuração. Em um outro post explicaremos melhor sobre a arquitetura J2ME.


4) Em dispositivos, você pode escolher a aparência do emulador. Pode deixar a default mesmo. Em configuração do dispositivo marque CLDC-1.1 e em perfil do dispositivo marque MIDP-2.0. Clique em próximo ou em finalizar. Se clicar em próximo, selecione finalizar na próxima tela.


Por default o Netbeans cria um MIDlet Visual. Para este tipo de MIDlet temos um fluxo e a opção de visualizar as telas.


O fluxo inicial gerado nos mostra que quando iniciado o aplicativo abre um form e este form tem um exitCommand, comando para sair. Este comando vai para o estado resumido, que seria um estado de pausa. Se selecionar o form e ir em Tela verá como esta tela está.


A tela, que é um form, tem um título(Welcome), um StringItem(Hello, Hello World!) e um comando de sair conforme já mencionado. Se executarmos o código já teremos um Hello World.


Simples assim! Não inserimos nenhuma linha de código a mão para obter este Hello World.
O ideal agora seria observarmos as linhas de códigos que foram geradas.
Em um próximo post descreveremos o código gerado.

Vídeo: Android x iPhone

Comparação entre as duas plataformas...

A mobilidade no mercado

Olá! Antes de iniciarmos no desenvolvimento para dispositivos móveis é necessário conhecer as tecnologias, dispositivos e sistemas operacionais que dominam o mercado.

Primeiramente vamos conhecer os tipos de dispositivos que são mais usados para rodar aplicações móveis e a diferença entre eles.

Palm é o termo usado para PDAs ou Handhelds, que são computadores de mão que fornecem as funções básicas de um computador pessoal.

O SmartPhone é uma catergoria de telefone celular com características que antes eram encontradas somente em Palms e Pcs.

PoketPC é o nome que a Microsoft usa para a categoria de PDAs, que difere dos SmartPhones por agregar características como uma tela maior e sensível a toque, suporte wifi, bluetooh, integração com GPS, enfim, qualidades que o tornam mais robusto.

Quanto aos SOs, os mais utilizados no mundo e nos EUA são:

fonte: www.admob.com/metrics

Symbian

É o mais antigo do mercado, desde 1998. Possui um sistema gráfico bem simples e atualmente é o sistema mais usado pelos maiores fabricantes de telefones móveis do mundo (Nokia, Samsung e Sony Ericsson), porém com o surgimento de novas tecnologias e plataformas, vem apresentando queda. Para este SO é possível desenvolver aplicativos nas seguintes linguagens: Symbian C/C++, JavaME, FlashLite, Perl, Python, Ruby, entre outras.

Iphone OS

O Iphone OS é o sistema operacional proprietário do Iphone, desenvolvido pela Apple. Atualmente conhecido como Mac OS X Snow Leopard, semelhante ao sistema OS X que roda nos computadores Macintosh. Este SO introduziu diversas tecnologias de primeira linha com uso de 64 bits, proporcionando a mais rápida implementação de javascript e acesso a web, chegando a ser 53 vezes mais rápido quando usa o mini navegador Safari. Além da tecnologia de multicondutores que agiliza a distribuição de tarefas em multiplos processadores.
Outra poderosa tecnologia implementada é o OpenCL(Open Computing Language) que possibilita aos desenvolvedores maior otimização em aplicações que usam recursos gráficos.
Em comparação ao Android por exemplo, é notável que o sistema operacional do Iphone é muito superior em qualidade e eficiência, só perde quanto ao custo.
A linguagem de desenvolvimento para o iPhone é o ObjC, uma linguagem orientada a objetos, que além das funcionalidades comuns do C adiciona a transmissão de mensagem. Também existem iniciativas Open-Source que fazem a ponte entre o C e outras linguagens, como o Python.

BlackBerry OS

É o SO do aparelho BlackBerry, desenvolvido pela RIM que deu origem à categoria dos smartphones. Seu ponto forte é a comunicação em tempo real com aplicações da internet, por exemplo o gerenciador de e-mails, que sincroniza por conta própria os e-mails que chegam no servidor.

Windows Mobile

Projetado para realizar boa parte das funções existentes no Windows para PC. Ele pode ser instalado em PDAs, Pocket Phones, Smartphones e aparelhos de multimídia em geral. Suporta aplicativos desenvolvidos em linguagens como C, Java ME, Visual Basic, Python, FlashLite, entre outras, além de possuir um interpretador para PHP.

Palm OS

Palm OS é um sistema operacional desenvolvido pela PalmSource para rodar em Palms (PDAs ou Handhelds). As linguagens mais utilizadas para o desenvolvimento de aplicações no Palm OS é o Pascal e o C/C++, que possui uma grande quantidade de frameworks, porém existem aplicativos que convertem aplicações desenvolvidas em Java para que possam ser utilizadas no Palm OS. Atualmente os dispositivos Palms estão sendo comercializados também com Windows Mobile, devido as restrições para o desenvolvimento no Palm OS.

Android

É o mais novo SO para dispositivos móveis do mercado, criado pela Google, com o intuito de competir com o Iphone. Baseado em Linux, possui uma maquina virtual projetada para otimizar a memória e os recursos de hardware. É a primeira plataforma móvel openSource e está tendo boa aceitação no mercado. Além dos aplicativos feitos em Java, o Android possui um conjunto de bibliotecas C/C++, OpenGL e um poderoso e leve banco de dados relacional, o SQLite.

Conclusões

O Symbian lidera o mercado mundial a bastante tempo, principalmente na Europa, porém vem sofrendo bruscas quedas nas vendas, devido ao destaque do Iphone, que apresenta um significativo aumento nas vendas mundias e lidera as vendas nos Estados Unidos, com um percentual esmagador.
Um outro SO que está em ascensão é o Android, que promete muito, mas ainda está muito cedo para saber se realmente irá lutar de igual pra igual com o Iphone.

O porque deste Blog

Com a expansão da Internet e da utilização de aplicações, surgiram diversas linguagens de programação, tendo destaque as de multiplataforma, como é o caso do Java, que pode ser aplicado em diversos setores, como aparelhos eletrônicos, telefones celulares, aplicações para web e desktop, entre outros. Levando em consideração os diferentes setores, tornou-se necessário a criação de kits de desenvolvimento diferenciados.

A proposta inicial do blog parte do interesse pela linguagem de programação Java, em específico Java 2 Micro Edition – J2ME. É uma tecnologia que permite o desenvolvimento de aplicações Java para dispositivos com processamento, memória e vídeo limitados, tais como celulares, PDAs, entre outros. Assim como as outras edições Java, essa tecnologia foi desenvolvida com o mesmo intuito, a portabilidade, além de possuir diversas APIs de desenvolvimento. O J2ME também fornece compatibilidade entre as edições Java, possibilitando a comunicação com aplicações J2SE (Java 2 Standard Edition) e J2EE (Java 2 Enterprise Edition).

Nos próximos posts serão estudas as tecnologias, o que tem de novo no mercado, artigos e códigos fonte, tutoriais, eventos, enfim... Tudo o que há de interessante quando o assunto é mobilidade!