JSR 211

Content Handler API

Objetivo
 Prover uma API que permita a aplicações
invocar outras aplicações (Java ou não-Java)
para tratamento de content types baseado em
seus mime types.
 Content handlers podem manipular o conteúdo
paralelamente à execução da aplicação que os
invoca ou em sequência (após finalização da
aplicação que os invoca), dependendo das
capacidades de multitasking do dispositivo.
 API atualmente em fase de public review.
Escopo
 Dispositivos
J2ME que implementem
quaisquer dos profiles abaixo:
 MIDP 1.0
 MIDP 2.0

 PBP (Personal Basis Profile)

 Outros perfis compatíveis com as

configurações CDC ou CLDC
Arquitetura de Referência
O pacote javax.microedition.content
 Registry - invocar, registrar, desregistrar e iniciar
invocações de content handlers
 ContentHandler - provê os detalhes sobre um handler
registrado no aparelho
 Invocation - contém os parâmetros passados e
retornados para o ContentHandler durante uma
requisição
 ContentListener - notifica a aplicação sobre requisições
pendentes
 ContentHandlerServer - processa uma requisição de
manipulação de conteúdo
 ActionNameMap - mapeia ações para nomes
(descritivos) de ação
 ContentHandlerException - reporta erros em uma
manipulação de conteúdo
Content Handlers
 Aplicações (MIDlets) que registram-se
para tratar requisições para um ou mais
content types específicos.
 Pode-se especificar content handlers para
ações (actions) específicas: open, delete,
save, new, etc.
Comunicando-se com Content Handlers

 As invocações (Invocations) de content handlers

passam o conteúdo a ser processado na forma
de uma URL (http://endereco/a.mp3,
file://arquivo.jpg, socket://10.0.0.100/teste.txt,
etc).
 Invocações podem especificar a ação que
desejam executar sobre o conteúdo e fornecer
um conjunto de argumentos (parâmetros)
 A resposta a uma requisição para a aplicação
chamadora utiliza o mesmo objeto Invocation.
Restrições de Segurança
 Uma aplicação deve conter a permissão
javax.microedition.content.ContentHandler
para poder executar como um
ContentHandler
Invocando uma aplicação
// Invoke based on a URL
try {
String url = “http://host/jones.vcard”;
Invocation invoc = new Invocation(url);
invoc.setAction(Invocation.ACTION_OPEN);
if (Registry.invoke(invoc, this)) {
// App must exit before invoked application can run
notifyDestroyed(); // inform the application manager
} else {
// Application does not need to exit
}
} catch (IOException ex) {
Alert alert = new Alert(“”, “Could not go there”, null, null);
display.setCurrent(alert);
}
Respondendo a uma invocação assincronamente

public class VCardViewer extends MIDlet implements ContentListener,

CommandListener {
Invocation invoc;
ContentHandler handler;

public VCardViewer() {
// Register the listener to be notified of new requests
handler = Registry.forClass(this.getClass().getName());
handler.setListener(this);
}

// Process a queued Invocation.

public void invocationNotify() {
// Dequeue the next invocation
invoc = handler.getRequest(0L);
if (invoc != null) {
// Display the content of the VCard
displayVCard(invoc);
}
}
Respondendo a uma invocação assincronamente

public void commandAction(Command c, Displayable s) {

if (c == okCommand) {
if (invoc != null) {
if (handler.finish(invoc, Invocation.OK)) {
notifyDestroyed(); // inform the application manager
}
invoc = null;
}
}
}

void displayVCard(Invocation invoc) throws Exception {

HttpConnection conn = (HttpConnection)invoc.open(false);
VCard vcard = parseVCard(conn.getInputStream());
...
// Display the content based on the action
String action = invoc.getAction();
if (ContentHandler.ACTION_EDIT.equals(action)) {
showEdit(vcard);
} else {
showView(vcard);
}
}
}
Tratando o retorno de uma
invocação
// Invoke based on a URL
try {
String url = “http://host/jones.vcard”;
Invocation invoc = new Invocation(url);
invoc.setAction(Invocation.ACTION_OPEN);
if (Registry.invoke(invoc, this)) {
// App must exit before invoked application can run
notifyDestroyed(); // inform the application manager
} else {
Invocation ret = Registry.getResponse(this, 1000);
// handle the returned invocation result here!
}
} catch (IOException ex) {
Alert alert = new Alert(“”, “Could not go there”, null, null);
display.setCurrent(alert);
}
Registrando uma aplicação como content handler

O content handler padrão vpara os tipos

application/java-archive e
text/vnd.sun.j2me.appdescriptor é o
próprio AMR
 Outros content handlers podem ter
aplicações padrões registradas
(dependendo do SO). Ex.: Browser
registrado como handler para text/html
Registro estático
 Adição de campos no descritor (.jad). Exemplo:
MIDlet-1: AudioPlayer, /icons/audio.png, example.Audio
MIDlet-2: Browser, /icons/browser.png, example.Browser
MicroEdition-Handler-1: example.Audio, audio/midi, open, .midi
MicroEdition-Handler-1-en-US: Play
MicroEdition-Handler-2: example.Browser, text/html, open, .html
MicroEdition-Handler-2-en-US: View
MicroEdition-Handler-ID: http://jsr-211.java.net/example
MicroEdition-Handler-Access: http://jsr-211.java.net/demos
MIDlet-Jar-Size: 2751
MIDlet-Jar-URL: http://java.net/example/jarFileName.jar
MIDlet-Name: Example Content Handlers
MIDlet-Vendor: Sun Microsystems, Inc.
MIDlet-Version: 1.0
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-2.0
Registro dinâmico
try {
// Create a content handler instance for our Generic PNG Handler
String[] chTypes = { “image/png” };
String[] chSuffixes = { “.png” };
String[] chActions = { ContentHandler.ACTION_OPEN };
String chClassname = “example.content.PNGHandler”;
ContentHandler handler =
Registry.register(chClassname, chTypes, chSuffixes, chActions);
// Set the applications that are allowed access
String[] chAccessRestricted = { “http://jsr-211.java.net/demos” };
Registry.setAccessRestricted(chAccessRestricted);
} catch (ContentHandlerException ex) {
// Handle exception
}
Modelo Siemens x75
 As funcionalidades do JSR 211 irão encapsular
o acesso ao OMA (Object Manager)
 A API deverá encapsular a lógica necessária
para invocar aplicações externas (tanto nativas
quanto Java). Ex.: tocar um arquivo de mídia,
gravar um novo som, etc.
 A MVM deverá permitir que content handlers
fiquem “always on”, de forma a permitir a
execução em paralelo e fazer com que não seja
necessário recarregar os MIDlets a cada
execução.
Referências
 JSR 211 – Content Handler API
http://www.jcp.org/en/jsr/detail?id=211