Trabalhando com Browser em Java ME, Android e BlackBerry

Trabalhando com o Browser em Java ME, Android e BlackBerry • Introdução Dentre as novas plataformas de desenvolvimento, ou ainda, aquelas que estão dominando o mercado de smartphones, todas permites uma integração entre os aplicativos construídos por terceiros e os aplicativos nativos do aparelho. Esta premissa permite criar aplicativos muito mais poderosos do que aqueles que criávamos com plataformas mais antigas.

Com isso podemos chamar um player de música para executar um recurso próprio do aplicativo de terceiro, chamar o Google Maps ou o BlackBerry Maps de dentro do seu aplicativo, permitir que nossos software efetuem ligações, transferindo esta ação para o sistema operacional do aparelho, dentre muitas outras possibilidades.

Neste artigo vamos trabalhar basicamente com três plataformas: • Java ME: apesar de seu visível declínio nos smartphones, o Java ME é muito maior que simples joguinhos em telefones celulares. Ainda é a plataforma mais utilizada e, em países de terceiro mudo, é a plataforma presente na grande maioria dos telefones celulares existentes no país.

• Android: A recente criação do Google vem crescendo cada vez mais, além disso, seu uso já na está mais presente só em smartphones, existem protótipos ou produtos que acoplam o Android, como NetBooks´s, Automóveis (sim, já existem carros com Android), aparelhos televisores, dentre outros.

• BlackBerry: Continua liderando o mercado de smartphones nos Estados Unidos, possui uma versão única do Java ME, criada pela própria RIM (Research in Motion). Junto com Android e iPhone, forma a tríplice coroa das principais plataformas móbile do momento.

A tarefa será interagir com o browser do aparelho em cada uma das três plataformas citadas anteriormente.

Chega de papo e vamos aos códigos.

• Java ME Para que o Java ME funcione com o seu alto nível de portabilidade, a Sun Microsystems definiu a seguinte arquitetura para ele:

Figura 1: Arquitetura Java ME.

Basicamente, uma configuração define propriedades em um nível mais baixo para os dispositivos, já o perfil trabalha mais com interface gráfica e outros quesitos alto nível.

O mais importante é que a maioria dos aparelhos celulares segue o conjunto configuração-perfil CLDC (Connected Limited Device Configuration)/MIDP (Móbile Information Device Profile). Muito provavelmente seu telefone que está em suas mãos contém este par.

Por conseguinte, a MIDP também está dividida em versões.

Atualmente existem a 1.0, 2.0, 2.1 e 3.0. A 2.0 é de longe a com maior presença no mercado.

Essa explicação inicial era necessária para dizer o seguinte: para trabalhar com o browser do aparelho em Java ME vamos utilizar o método platformRequest(), que está presente somente a partir da versão 2.0 da MIDP. Para estudar seu uso vamos criar uma simples aplicação que mostra apenas uma caixa de texto e um Command para abrir a URL digitada pelo usuário. Veja a Listagem 1:

Listagem 1: 1: package com.estudo; 2: 3: import javax.microedition.io.ConnectionNotFoundException; 4: import javax.microedition.lcdui.Command; 5: import javax.microedition.lcdui.CommandListener; 6: import javax.microedition.lcdui.Display; 7:import javax.microedition.lcdui.Displayable; 8: import javax.microedition.lcdui.Form; 9: import javax.microedition.lcdui.TextField; 10: import javax.microedition.midlet.*; 11; 12: public class OpenURL extends MIDlet implements CommandListener{ 13: 14:

private Display display;

15:

private Form fmMain;

16:

private TextField tfURL;

17: 18:

private Command cmOpen;

19: 20:

public void startApp() {

21:

display = Display.getDisplay(this);

22: 23:

fmMain = new Form("");

24:

tfURL = new TextField("Acessar:", "", 100, TextField.ANY);

25:

fmMain.append(tfURL);

26: 27:

cmOpen = new Command("Open", 1, Command.ITEM);

28:

fmMain.addCommand(cmOpen);

29:

fmMain.setCommandListener(this);

30: 31: 32:

display.setCurrent(fmMain); }

33: 34:

public void pauseApp() { }

35:

public void destroyApp(boolean unconditional) { }

36: 37: 38: 39:

public void commandAction(Command arg0, Displayable arg1) { try { platformRequest(tfURL.getString());

40:

} catch (ConnectionNotFoundException ex) {

41:

ex.printStackTrace();

42: 43:

} }

44: }

A seqüência de linhas de 1 até 36 fazem parte do Java ME, sem nenhum mistério.

Na linha 37 temos o commandAction, que trata das ações efetuadas sobre os Commands. Como temos apenas um comando faremos a ação diretamente neste método, sem verificar quem chamou o mesmo.

Na linha 39, cercada pelo bloco de código try-catch está o platformRequest. Como método passamos apenas a URL digitada no campo de texto. Aqui poderíamos ter feito algumas verificações encima do que foi informado como URL, mas não é o objetivo deste simples artigo.

Agora veja na Figura 2 o aplicativo em execução:

Figura 2: Aplicativo OpenURL em execução.

Ao acionar o Open não acontecerá nada no emulador, apenas quando fechamos celular fictício, é que o browser do computador será chamado com a URL informada no campo de texto. No celular real o comportamento é diferente, ao clicar Open, o browser do dispositivo é acionado. Sendo vista em seguida pelo usuário.

Fácil né? Vamos para o próximo passo.

• BlackBerry O BlackBerry usa uma versão própria do Java ME, com reimplementação de algumas classes e novas possibilidades para o desenvolvedor.

Vamos criar o mesmo projeto OpnURL, mas desta vez usando a BlackBerry API. Veja a Listagem 2: Listagem 2: import import import import import

net.rim.device.api.ui.UiApplication; net.rim.device.api.ui.component.EditField; net.rim.device.api.ui.component.LabelField; net.rim.device.api.ui.container.FullScreen; net.rim.device.api.ui.container.MainScreen;

public class OpenURL extends UiApplication{ public static void main(String[] args) { OpenURL theApp = new OpenURL(); theApp.enterEventDispatcher(); } public OpenURL() { pushScreen(new HelloScreen()); } }

Como nosso objetivo não é ensinar nenhuma das três plataformas, não vamos detalhar a Listagem 2, ela apenas serve para monta o esqueleto básico de uma aplicação BlackBerry API. Na Listagem 3 definimos a classe que representa a interface gráfica de nosso projeto OpenURL.

Listagem 3: class HelloScreen extends MainScreen { public HelloScreen() { super(FullScreen.DEFAULT_MENU | FullScreen.DEFAULT_CLOSE); EditField edt = new EditField(); add(new LabelField("Digite a URL:")); add(edt); } public boolean onClose() { System.exit(0); return true; } protected void makeMenu(Menu menu, int instance) { menu.add(new MenuItem("Abrir",0,0){ public void run() { });

}

} }

A classe acima também é simplificada ao máximo devido aos nossos objetivos. No construtor adicionamos dois componentes a tela, um EditField e um LabelField. Também sobrescrevemos o makeMenu para adicionar nosso item de menu “Abrir”, ainda sem ação. Veja como ficou a interface na Figura 3:

Figura 3: OpenURL no BlackBerry.

Agora é a hora de definirmos a ação que acionará o browser do aparelho.

Primeiro, reescreva o makeMenu: Listagem 4: protected void makeMenu(Menu menu, int instance) { menu.add(new MenuItem("Abrir",0,0){ public void run() { BrowserSession browserSession = Browser.getDefaultSession(); browserSession.displayPage(edt.getText()); browserSession.showBrowser(); } });

Declare o objeto edt como variável de instância: final EditField edt;

Estamos usando duas classes princiais: • BrowserSession: sessão do Browser.

• Browser: usado para recuperar a sessão do Browser.

Perceba que estamos usando a sessão default, para isso chamamos o método getDefaultSession(). Com esta sessão criada, configuramos a página a ser visualizada através do método displayPage() e, finalmente, mostramos esta página no browser com o método showBrowser().

Vamos executar novamente a aplicação, digitar o endereço www.mobilidadetudo.com e acionar o menu “Abrir”. Veremos a tela mostrada na Figura 4 e 5:

Figura 4: Carregando URL informada no aplicativo OpenURL.

Figura 5: Visualização da página informada no programa OpenURL.

Se clicarmos no botão voltar no programa do Browser, novamente vamos ver a tela inicial do OpenURL.

• Android Até agora está muito fácil não é? A boa notícia é que vai continuar nesse mesmo ritmo.

Vamos criar o mesmo projeto OpenURL para Android. Ao criar um projeto precisamos definir basicamente o arquivo xml de layout e a Activity que trabalha com ela.

Na Listagem 5 mostramos o man.xml: Listagem 5: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:gravity="right" android:layout_height="wrap_content"> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Digite a URL:"/> <EditText android:layout_height="wrap_content" android:id="@+id/edtURL" android:layout_width="fill_parent"></EditText> <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/btnAbrir" android:text="Abrir"></Button> </LinearLayout>

Na Listagem 6 criamos a Acivity: Listagem 6: package com.openurl; import import import import import import import

android.app.Activity; android.content.Intent; android.net.Uri; android.os.Bundle; android.view.View; android.widget.Button; android.widget.EditText;

public class OpenURL extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button btn = (Button) findViewById(R.id.btnAbrir); btn.setOnClickListener(new View.OnClickListener(){ @Override public void onClick(View v) { } }); }

}

Assim como os outros exemplos, criamos uma aplicação super simples. Estamos apenas recuperando o Button através de seu id definido no XML. Com a instância desse widget adicionamos um listener para o evento de clique.

Veja na Figura 6 como ficou nossa interface de usuário:

Figura 6: Aplicativo OpenURL no Android.

Agora vamos adicionar a lógica para chamar a página no Browser do aparelho.

O Intent é um conceito muito importante no mundo de desenvolvimento Android. Vou utilizar algumas fontes externas para ajudar a explicar essa importantíssima parte da plataforma.

Segundo o livro Google Android, segunda versão, do Ricardo Lecheta, Intent é o coração do Androd. Ela está presente em todos os lugares e representa uma mensagem da aplicação para o sistema operacional, solicitando que algo seja realizado, e representa um importante papel na arquitetura do Android para integrar diferentes aplicações.

Ainda segundo Lecheta, cabe ao sistema operacional interpretar essa mensagem e tomar as providências necessárias, que pode ser para abrir uma simples aplicação, fazer uma ligação para um determinado número ou até abri o Browser em uma determinada página da internet.

Segundo o site de desenvolvedores do Android, um Intent é uma descrição abstrata de uma operação a ser realizada.

Acho que já ficou claro. Mas resumindo, vamos apenas dizer ao sistema operacional que queremos abrir uma página da Internet, lançando uma Intent para tal finalidade.

Reescreva o método onClick: btn.setOnClickListener(new View.OnClickListener(){

});

public void onClick(View v) { EditText edt = (EditText) findViewById(R.id.edtURL); Uri uri = Uri.parse(edt.getText().toString()); Intent it = new Intent(Intent.ACTION_VIEW, uri); startActivity(it); }

Inicialmente recuperamos o objeto EditText, precisaremos dele para usarmos o texto digitado exatamente na linha abaixo, onde criamos a instância de URI. Esta classe possui o método estático parser, que recebe uma string e transforma em URI. Com a URI criada, instanciamos o objeto Intent. Um dos construtores desta classe recebe uma String referenciando o serviço que queremos chamar e uma URI. Depois disso precisamos apenas iniciar esta atividade, usando o startActivity. Reinicie seu aplicativo e verás o seguinte resultado ao clicar no botão Abrir:

Figura 7: Abrindo a URL informada no OpenURL.

Figura 8: URL sendo no visualizada no Broswer do aparelho.

A classe Intent também fornece strings estáticas para interagir com diversos aplicativos nativos do Android. Veja alguns na lista abaixo, porém, recomenda-se consultar a documentação e ver todas as opções que os programadores tem em mãos: • ACTION_CALL: realizar uma chamada telefônica; • ACTION_ANSWER: responder a uma chamada telefônica; • ACTIOB_BATTERY_LOW: avisa que o nível da bateria está baixo; • ACTION_REBOOT: rebotar o aparelho; • ACTION_SHUTDOWN: desligar o aparelho; • ACTION_VOICE_COMMAND: inicia o comando de voz; • ACTION_WEB_SEARCH: inicia uma procura web; • ACTION_GTALK_SERVICE_CONNECTED: uma conexão gTalk foi estabelecida; • ACTION_SCREEN_OFF: desliga a tela.

• Conclusão As três plataformas móveis tratadas aqui possuem uma API que torna o trabalho de integração, entre aplicativos de terceiros e Browser nativo, muito fácil. Além disso, é interessante ver as diferentes formas de utilização do Java no Mudo Móbile.

• Sobre Mim Meu nome é Ricardo da Silva Ogliari, sou graduado em Ciência da Computação pela Universidade de Passo Fundo. Atualmente também estou cursando uma pós-graduação em web, estratégias de inovação e tecnologia, no Senac SP. Trabalho com mobile a 6 anos, escrevo artigos para algumas revistas nacionais especializadas. Sou criador e mantenedor do http://www.mobilidadetudo.com e sou um dos membros do www.javamovel.com. Palestrei em eventos nacionais e internacionais, como o FISL e o JustJava, além de ter dezenas de artigos meus espalhados pelo mundão da internet.