1
APIs PARA J2ME
JSR 120 (SMS), JSR 205 (WMAPI 2.0) e JSR 180 (SIP)
TÓPICOS EM ENGENHARIA DE COMPUTAÇÃO V
Prof. José Mario De Martino
ALUNO: Julian Mauricio Prada Sanmiguel
RA: 079928
2 ÍNDICE. ÍNDICE 2 1. PROTOCOLO SIP 3 1.1. Desenho do protocolo 3 1.2. Funcionamento do protocolo 3 1.2.1. Agentes de usuário 4 1.2.2. Servidores de registro 4 1.2.3. Servidores Proxy e de redirecionamento 4 1.2.4. Formato das mensagens 5 1.3. JSR 180: SIP API PARA J2ME 5
1.4. EXEMPLOS 8
1.4.1. Conexão cliente 8
1.4.2. Conexão servidor 8
1.4.3. Conexão servidor, o porto é atribuído pelo sistema 8
1.4.4. Outros 9
2. JSR 120 (SMS) E JSR 205 (WMAPI 2.0) 11
2.1. API JSR 120 (SMS) 11
2.1.1. Passos para enviar uma mensagem (SMS) 13 2.1.2. Passos para receber uma mensagem (SMS) de forma assíncrona 14 2.1.3. Passos para receber uma mensagem (SMS) de forma síncrona 14 2.1.4. Configuração do MessageConnection 14
2.2. EXEMPLOS SMS 15
2.2.1. Modo Cliente 15
2.2.2. Modo Servidor 15
2.2.3. Envio de um SMS no modo texto e binário 15
2.3. API JSR 205 (MMS) 19
2.4. EXEMPLOS MMS 19
2.4.1. Enviar um MMS usando JRS 205 19
3 1. PROTOCOLO DE INICIAÇÃO DE SESSÃO (SIP) – API JSR 180
O Protocolo de Iniciação de Sessão (SIP) é um protocolo desenvolvido pela Internet Engineering Task Force (IETF), com a intenção de ser um padrão para a iniciação, modificação y finalização de sessões de comunicação interativa entre usuários onde intervêm elementos multimídia como o vídeo, a voz, a mensageira instantânea, os jogos online e a realidade virtual, aplicando o modelo “petição – resposta”, similar ao HTTP.
1.1. DESENHO DO PROTOCOLO
O protocolo SIP foi desenhado com o conceito de “caixa de ferramentas”, isto é, o protocolo SIP utiliza as funções contribuídas por outros protocolos e não volta a desenvolvê-las, ele se concentra no estabelecimento, modificação y terminação das sessões e complementa-se entre outros, com o SDP, que descreve o conteúdo multimídia da sessão, por exemplo, que direciones IP, portos e códecs se usarão durante a comunicação.
O protocolo SIP adota o modelo cliente – servidor e é transacional. O cliente realiza petições (request) que o servidor atende e gera uma ou mais respostas, por exemplo, para iniciar uma sessão o cliente realiza uma petição com o método INVITE em onde indica com que usuário (ou recurso) quer estabelecer a sessão, o servidor responde já seja recusando ou aceitando essa petição numa série de respostas, as respostas levam um código de estado que brindam informação a respeito de se as petições foram resolvidas com sucesso ou se se produziu um erro. A petição inicial e todas suas respostas constituem uma transação.
Os servidores, por defeito, utilizam o porto 5060 em TCP (Transmission Control Protocol) e UDP (User Datagram Protocol) para receber as petições dos clientes SIP.
1.2. FUNCIONAMENTO DO PROTOCOLO.
O protocolo SIP permite o estabelecimento de sessões multimídia entre dois ou mais usuários, ele faz isto mediante o intercambio de mensagens entres as partes que se querem comunicar.
4 1.2.1. AGENTES DE USUÁRIO.
Os usuários, que podem ser seres humanos ou aplicações de software, utilizam para estabelecer sessões, o que o protocolo SIP denomina “Agentes de Usuário”, estes são os pontos extremos do protocolo, os que emitem e recebem as mensagens do protocolo SIP, por exemplo, um videoteléfone, um telefone, um cliente de software (softphone) ou qualquer outro dispositivo similar, o protocolo não se ocupa da interface destes dispositivos com o usuário final, só se interessa nas mensagens que estes geram e recebem.
Os agentes de usuário se comportam como clientes (UAC: User Agent Clients) ou como servidores (UAS: User Agent Servers), são UAC quando realizam uma petição e são UAS quando a recebem.
1.2.2. SERVIDORES DE REGISTRO.
O protocolo SIP permite estabelecer a localização física de um usuário determinado na rede, para isto utiliza o mecanismo de registro.
Cada usuário tem uma direção lógica que é invariável respeito da localização física do usuário, um endereço lógico do protocolo SIP é da forma usuario@dominio, da mesma forma que um endereço de correio eletrônico. O endereço físico (endereço de contato) é dependente do lugar onde o usuário está conectado (IP), quando um usuário inicializa seu terminal (por exemplo, conectando seu telefone o abrindo seu software de telefonia SIP) o agente de usuário SIP que está em esse terminal envia uma petição com o método REGISTER a um Servidor de Registro, informando a que endereço físico deve associar-se o endereço lógico do usuário, então o servidor de registro realiza a associação (binding).
1.2.3. SERVIDORES PROXY E DE REDIRECIONAMENTO.
Um conjunto de usuários que pertencem a uma companhia ou provedor de serviços de comunicações conformam um domínio, este domínio, que é indicado num endereço SIP depois do caractere “@”, é normalmente atendido por um servidor o qual recebe as petições para seus usuários será o encarregado de determinar o endereço físico do usuário chamado.
5
• Como Proxy
• Como Rediretor
Quando atua como Proxy o servidor determina a localização do usuário chamado, e envia a petição ao endereço físico do usuário chamado, as respostas do agente de usuário chamado também são enviadas ao Proxy o qual as remite para o usuário de origem.
Como rediretor o servidor gera uma resposta que indica à origem o endereço físico do usuário para que este possa realizar uma petição e enviá-la ao endereço físico do usuário desejado. Um mesmo servidor pode atuar como Rediretor o como Proxy dependendo da situação.
1.2.4. FORMATO DAS MENSAGENS
As mensagens que se intercambiam no protocolo SIP podem ser petições ou respostas, as petições têm uma línea de petição, uns encabeçados e um corpo, e as respostas tem uma línea de resposta, uns encabeçados e um corpo.
A línea de petição indica o propósito e o destinatário da petição, e a línea de resposta indica o código de estado da resposta o qual indica o resultado do processamento da petição.
Os encabeçados das petições e respostas são utilizados para diversas funções do protocolo relacionadas com o encaminhamento das mensagens, autenticação dos usuários, entre outras. O corpo das mensagens é opcional e é utilizado para transportar as descrições das sessões que se querem estabelecer, utilizando a sintaxe do protocolo SDP.
1.3. JSR 180: SIP API PARA J2ME
JSR 180 define um pacote opcional que fornece a API SIP para clientes J2ME, de modo que aplicações SIP podem operar em dispositivos com pouca memória. Esta interface lhe permite a JAVA habilitar dispositivos móveis para enviar e receber mensagens SIP.
A API é compacta y genérica, de modo que pode usar-se com qualquer perfil J2ME, não só MIDP. Como mínimo, requere da versão 1.0 do CLDC (Connected Limited Device Configuration).
As APIs são definidas no pacote javax.microedition.sip. e contém 8 interfaces e 4 classes:
6
INTERFACES DESCRIÇÃO
SipConnection Tem as propriedades e métodos comuns das
subinterfaces SipClientConnection e
SipServerConnection.
SipClientConnection Representa uma transação tipo cliente SIP e pode ser
criada pelo aplicativo usando
javax.microedition.io.Connector ou
SipDialog.
SipServerConnection Representa uma transação tipo servidor SIP e é criado pela SipConnectionNotifier quando uma nova petição é recebida.
SipConnectionNotifier Define uma conexão tipo servidor SIP que espera qualquer mensagem entrante. Ao receber as petições de entrada, as aplicações usam o método
acceptAndOpen() da interface, a qual aceita e abre uma nova SipServerConnection. se não existirem mensagens na fila de espera, o método é bloqueado até que uma nova petição é recebida.
SipServerConnectionListener É um ouvinte SIP para as petições.
SipClientConnectionListener É um ouvinte SIP para as respostas.
SipDialog Representa um dialogo SIP, pode ser recuperado a
partir de um objeto SipConnection quando ele estiver disponível, o que acontece depois de uma petição de INVITE ou SUBSCRIBE.
SipResfreshListener É um ouvinte para a classe RefreshHelper; declara um método refreshEvent() que pega um
refreshID para identificar a tarefa de atualização correspondente e uma statusCOde que representa o resultado da atualização: 0 de cancelamento, 200 para o êxito, e qualquer outra coisa, em caso de erros.
CLASSES DESCRIÇÃO
SipAddress Pode ser utilizada para analisar um endereço SIP, ou para construir um.
SipHeader Pode ser usado para analisar encabeçados String lidos dos SIP mensagens, ou para construí-los.
SipRefreshHelper Implementa uma funcionalidade que facilita o tramite de petições
Refresh.
7 SIP API para J2Me está destinada a ser utilizada por aplicações que necessitam implementar a funcionalidade “Agente de Usuário SIP”, eles podem usar a interface SipClientConnection
para implementar um Agente de Usuário SIP como cliente, e usar as interfaces
SipConnectionNotifier e SipServerConnection para implementar um Agente de Usuário SIP como servidor. Os dispositivos móveis podem atuar como Clientes SIP enviando petições aos Servidores SIP e também como Servidores SIP aceitando petições dos Clientes SIP.
O SIP API está integrado no CLDC’s Generic Connection Framework, por exemplo, uma aplicação instancia uma nova conexão SIP chamando ao Connector.open(), o qual retornara um SipClientConnection ou um SipServerConnection, dependendo de que SIP URI foi enviada ao Connector.open().
O SIP URI tem a seguinte sintaxe:
{ scheme } : [ { target } ] [ { params } ]
Onde:
• scheme é o esquema SIP suportado pelo sistema e pode ser: sip ou sips. No protocolo sips, a conexão do servidor aceita só petições através de um transporte seguro, como está definida na norma RFC 3261.
Novo
Novo
Resposta Petição
Resposta
DISPOSITIVO SIP (A) DISPOSITIVO SIP (B)
SipClientConnection SipConnectionNotifier SipConnectionNotifier SipServerConnection SipClientConnection SipServerConnection Petição REDE SIP
8
• target é a endereço do usuário, a qual pode ser algo como
userName@target-host.com: portNumber ou apenas um número de telefone.
• params representa parâmetros adicionais; por exemplo, transport=udp para especificar o UDP como protocolo de transporte.
Se o target host está incluído, uma nova conexão Cliente é aberta, se ele não é, será aberta uma nova conexão Servidor.
1.4. EXEMPLOS:
1.4.1. Conexão cliente:
1.4.2. Conexão servidor:
1.4.3. Conexão servidor, onde o numero de porto é atribuído pelo sistema. ... SipClientConnection scc = (SipClientConnection) Connector.open("sip:max@company.com"); SipClientConnection scc2 = (SipClientConnection) Connector.open("sip:jack@128.11.1.2:5100"); ... ... SipConnectionNotifier scn = (SipConnectionNotifier) Connector.open("sip:5500"); ... ... SipConnectionNotifier scn2 = (SipConnectionNotifier) Connector.open("sip:"); ...
9 1.4.4. OUTROS
O seguinte método demonstra como abrir uma conexão Cliente SIP a um servidor que está no Host 102.12.1.1 e no porto 5050.
O seguinte segmento de código implementa o método notifyRequest() da interface SipServerConnectionListener. Quando o servidor recebe a petição de inicialização SIP MESSAGE, ele recupera os encabeçados da mensagem e seu conteúdo e, em seguida, envia uma resposta de volta para o cliente.
private void sendMessage(String message) { SipClientConnection sc = null;
try {
//abre a conexão SIP ao servidor 102.12.1.1 no porto 5050 sc = (SipClientConnection)
Connector.open(sip:user@102.12.1.1:5050); // inicializa a petição SIP da mensagem sc.initRequest("MESSAGE", null);
// envia o encabeçado da mensagem
sc.setHeader("Subject", subject.getString()); sc.setHeader("Content-Type", "text/plain"); sc.setHeader("Content-Length", ""+text.length()); // envia a mensagem á rede.
OutputStream os = sc.openContentOutputStream(); os.write(message.getBytes()); os.close(); // fecha a conexão } catch(Exception ex) { ex.printStackTrace(); } }
public void notifyRequest(SipConnectionNotifier scn) { try {
ssc = scn.acceptAndOpen();
if(ssc.getMethod().equals("MESSAGE")) {
String contentType = ssc.getHeader("Content-Type"); String contentLength = ssc.getHeader("Content-Length"); int length = Integer.parseInt(contentLength);
if((contentType != null) && contentType.equals("text/plain")) { InputStream is = ssc.openContentInputStream();
int i=0;
byte testBuffer[] = new byte[length]; i = is.read(testBuffer);
String tmp = new String(testBuffer, 0, i); // a mensagem recebido } ssc.initResponse(200); // OK ssc.send(); } } catch(IOException ex) { } }
10 Uma implementação de referencia para JSR 180 está disponível em NOKIA, ela está construída sobre CLDC 1.1 e MIDP 2.0. e suporta mensagens SIP reais sobre uma rede local, permitindo às aplicações enviar e receber mensagens SIP.
Para fazer o download do JSR 180 RI, você deve ser estar registrado no Fórum Nokia o qual é gratuito, o diretório tem a seguinte estrutura:
O diretório midp contém vários subdiretórios, um dos quais é bin. Este diretório contém várias ferramentas, incluindo sipa-midp.exe, o qual lança o SIP-Enable Emulator.
/sip/sip1_0-ri-bin
/examples (aplicações de exemplo) /lib (arquivo JAR contém as SIP APIs)
11 2. JSR 120 (SMS) E JSR 205 (WMAPI 2.0)
WMA são as siglas de Wireless Message API, uma extensão das especificações do CLDC e MIDP para o envio, a recepção e a gestação do SMS desde MIDLets.
Apesar de ser uma extensão opcional, a grande maioria dos terminais a levam instalada e pronta para ser usada desde as aplicações J2ME.
Versões da especificação WMA:
• Versão 1.0: Especificação inicial. Descreve as funções básicas para o envio e a recepção de SMS (JSR 120).
• Versão 1.1: É uma ampliação da especificação 1.0, para suportar o novo modelo de seguridade do MIDP 2.0.
• Versão 2.0: É uma ampliação das anteriores para a gestão de mensagens multimídia (MMS). (JSR 205).
2.1. API JSR 120 (SMS)
O API JSR 120 está composto exclusivamente de interfaces localizadas no pacote javax.wireless.messaging.
Estas interfaces são:
INTERFACE DESCRIÇÃO
javax.wireless.messagin g.Message
Define a funcionalidade genérica do todos os tipos de mensagens.
Permite:
• Especificar o destinatário da mensagem.
public void setAddress(String addr).
• Obtiver o emissor da mensagem.
public String getAddress().
12 java.util.Date
getTimestamp().
javax.wireless.messagin g.TextMessage
Representa uma mensagem de texto. Herda a
funcionalidade de
javax.wireless.messaging.Message adicionando os métodos public void setPayloadText(String data) e public String getPayloadText() para especificar ou obtiver os dados da mensagem.
javax.wireless.messagin g.BinaryMessage
Representa uma mensagem binário. Herda a funcionalidade
de javax.wireless.messaging.Message
adicionando os métodos public void
setPayloadData(byte[] data) e public byte[] getPayloadData() para especificar ou obtiver os dados da mensagem.
javax.wireless.messagin g.MessageListener
Ouvinte de mensagens entrantes. Esta interface é útil em javax.wireless.messaging.MessageConnectio n que funciona em modo servidor.
javax.wireless.messagin g.MessageConnection
Interface através da qual se realiza o envio e a recepção de mensagens.
Métodos da classe MessageConnection:
• public Message newMessage(String type, String address):
Cria uma nova mensagem para ser enviada, no argumento type se especifica o tipo de mensagem que se deseja enviar:
MessageConnection.TEXT_MESSAGE para mensagens de texto. MessageConnection.BINARY_MESSAGE para mensagens binários.
No argumento address se deve especificar a endereço do destinatário da mensagem, usualmente seu número de telefono.
• public int numberOfSegments(Message msg):
13 Por exemplo, para enviar uma mensagem extensa via SMS são necessários mais de um segmento (um segmento é igual a um SMS) e este método devolvera ou um número grande ou um valor “0” indicando que não se pode enviar a informação desejada.
• public Message receive() throws IOException,
InterruptedIOException:
Devolve uma mensagem enviada à aplicação, mas há que ter várias coisas presentes:
• É um método bloqueante, pelo que geralmente deverá ser chamado num hilo diferente ao principal onde está executando-se o Midlet.
• A aplicação é responsável de guardar a informação recebida, na memória não volátil quando seja necessário.
• public void send(Message msg) throws IOException,
InterruptedIOException:
Envia a mensagem ao destinatário, este método deve ser chamado num hilo diferente ao principal onde está executando-se o Midlet.
Para especificar o destinatário da mensagem se deve usar o método setAddress(String addr) definido na interface javax.wireless.messaging.Message da qual herdam javax.wireless.messaging.TextMessage e javax.wireless.messaging. BinaryMessage.
• public void setMessageListener(MessageListener I) throws IOException:
Registra uma classe que implementa a interface
javax.wireless.messaging.MessageListerner, a plataforma J2ME chamará o método notifyIncomingMessage() quando receba uma mensagem.
Este método só tem sentido quando a classe funciona no modo servidor.
2.1.1. Passos para enviar uma mensagem (SMS).
1. Obtiver um MessageConnection no modo cliente.
14 3. Especificar o conteúdo e o destinatário da mensagem.
4. Usar o método send da interface MessageConnection para enviar a mensagem.
2.1.2. Passos para receber uma mensagem (SMS) de forma assíncrona. 1. Obtiver um MessageConnection em modo servidor.
2. Implementar a interface MessageListener numa das classes. 3. Associar a classe anterior ao MessageConnection.
4. Quando o método notifyIncomingMessage() da interface MessageListener seja invocado, isso significa que a mensagem foi recebido.
5. Invocar o método receive() da interface MessageConnection num hilo independente.
6. Fazer o tratamento da mensagem.
2.1.3. Passos para receber uma mensagem (SMS) de forma síncrona. 1. Obtiver um MessageConnection em modo servidor.
2. Invocar o método receive() da interface MessageConnection num hilo independente.
3. Fazer o tratamento da mensagem.
Nota: Em J2ME, todas as comunicações que requerem os MIDLets com o exterior (Bluetooth, HTTP, etc.) se obterem através da classe javax.microedition.io.Connector que forma parte do CLDC. Esta classe devolve uma instancia de uma classe que implementa a interface javax.microedition.io.Connection para o modo de comunicação desejada. A interface javax.wireless.messaging.MessageConection não é mais que um javax.microedition.io.Connection para comunicação via SMS.
Basicamente através desta interface se pode criar, enviar e receber SMS tanto de forma síncrona como assíncrona.
2.1.4. Configuração de javax.wireless.messaging.MessageConnection. javax.wireless.messaging.MessageConection pode funcionar de duas formas:
15
• Em modo servidor, serve para receber e processar os SMS que são dirigidos para ele. Neste modo também se podem enviar SMS.
A forma de especificar o modo de funcionamento desejado se realiza através da cadeia de conexão que se lhe passa à classe javax.microedition.io.Connector.
2.2.EXEMPLOS SMS
2.2.1. Exemplo de como especificar o modo cliente: MessageConnection conn = (MessageConnection) Connector.open(“sms://+573005611621”);
MessageConnection conn = (MessageConnection) Connector.open(“sms://+573005611621:5555”);
Em ambos casos o SMS será enviado ao telefone 3005611621 da Colombia (pelo prefixo +57), mas com uma importante diferencia, num primeiro caso, o SMS será processado pela aplicação que por defeito tem instalada o telefone, enquanto, no segundo caso, o SMS será processado pela aplicação que esteja escutando nesse porto.
2.2.2. Exemplo de como especificar o modo servidor: MessageConnection conn = (MessageConnection) Conector.open(“sms://:5555”);
Os SMS que cheguem ao porto 5555 serão atendido pelo MIDLet.
Em realidade, “5555” não é um porto senão um identificador que lhe indica à plataforma JAVA que deseja tratar os SMS que cheguem com esse identificador.
2.2.3. Envio de um SMS no modo texto e binário. Classe do Midlet:
import javax.microedition.lcdui.*; import javax.microedition.midlet.*;
public class WMAMidlet extends javax.microedition.midlet.MIDlet { private boolean started;
public WMAMidlet(){
this.started = false;
}
16 Classe de configuração da mensagem em modo texto:
import java.io.*;
import javax.microedition.io.*; import javax.microedition.lcdui.*; import javax.wireless.messaging.*;
public class WMAMainForm extends javax.microedition.lcdui.TextBox
implements javax.microedition.lcdui.CommandListener {
// Referencia ao MIDLet
private javax.microedition.midlet.MIDlet midlet; // Envia o SMS
private javax.microedition.lcdui.Command cmdSend; // Finaliza a aplicação
private javax.microedition.lcdui.Command cmdExit;
// Janela principal da aplicação
public WMAMainForm(javax.microedition.midlet.MIDlet midlet) { super("Mensagem a enviar", "", 166, TextField.ANY);
this.midlet = midlet;
this.createUI();
}
// Cria e configura a interface gráfica da janela. private void createUI(){
this.setTicker(new Ticker("Exemplo envio SMS"));
this.cmdSend = new Command("Enviar", Command.OK, 1);
this.cmdExit = new Command("Salir", Command.STOP, 1);
this.addCommand(cmdSend);
this.addCommand(cmdExit);
this.setCommandListener(this);
}
protected void startApp() throws MIDletStateChangeException {
Display.getDisplay(this).setCurrent(new WMAMainForm(this));
}
protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
this.destroyApp(true);
}
protected void pauseApp() { }
17
// O usuário deseja enviar o SMS
private void sendSMSClick() throws java.io.IOException {
MessageConnection conn = null;
TextMessage msg = null;
try {
System.out.println(this.getString());
// Passo 1: Obtiver uma implementação do Connection que se enviara o // SMS
conn = (MessageConnection) Connector.open("sms://+34699221570");
// Passo 2: Criar o SMS
msg = (TextMessage) conn.newMessage(MessageConnection.TEXT_MESSAGE);
// Passo 3: Estabelecer o contendo o SMS
msg.setPayloadText(this.getString());
System.out.println(this.getString());
// Passo 4: Enviar o SMS
conn.send(msg);
} finally {
// Passo 5: Fechar a conexão
this.closeQuietly(conn);
conn = null;
} }
private void closeQuietly(javax.microedition.io.Connection conn){
try {
conn.close();
} catch (Exception ex){
} }
public void commandAction(Command arg0, Displayable arg1) {
try {
if (arg0 == cmdSend){
this.sendSMSClick();
} else if (arg0 == cmdExit){
this.midlet.notifyDestroyed();
}
} catch (Exception ex){
this.setString(ex.toString());
} } }
18 Classe da configuração da mensagem em modo binário:
// O usuario deseja enviar O SMS em modo binário
private void sendBinarySMSClick() throws java.io.IOException {
MessageConnection conn = null;
BinaryMessage msg = null;
ByteArrayOutputStream bout = null;
try {
// Passo 1: Obtiver uma implementação do Connection que se enviara o
// SMS conn = (javax.wireless.messaging.MessageConnection) Connector.open("sms://+34699221570"); // Passo 2: Criar o SMS msg = (BinaryMessage) conn.newMessage(MessageConnection.BINARY_MESSAGE);
// Passo 3: Estabelecer o contendo o SMS
bout = new ByteArrayOutputStream();
dout = new DataOutputStream(bout);
dout.writeBoolean(true); // ¿Solteiro?
dout.writeByte(23); // Idade
dout.writeUTF("Bogota D.C."); // Cidade de nascimento
dout.writeUTF("Colombia"); // País. dout.writeLong(91536765); // C.C. msg.setPayloadData(bout.toByteArray()); // Passo 4: Enviar o SMS conn.send(msg); } finally {
// Passo 5: Fechar a conexão
this.closeQuietly(bout); this.closeQuietly(dout); this.closeQuietly(conn); dout = null; dout = null; conn = null; } }
private void closeQuietly(java.io.OutputStream out){
try {
out.close();
} catch (Exception ex){
} }
private void closeQuietly(javax.microedition.io.Connection conn){
try {
conn.close();
} catch (Exception ex){
} }
19 2.3. API JSR 205 (MMS)
As diferenças entre as versões 1.1 (JSR 120 - SMS) y 2.0 (JSR 205 - MMS) do WMA são principalmente o suporte de mensagens multi-part usados pelas mensagens MMS.
As interfaces adicionais da versão 2.0 são as seguintes:
INTERFACES DESCRIÇÃO
javax.wireless.messagin g.MessagePart
Define uma parte de uma mensagem que pode ser aderida a
um MultipartMessage
javax.wireless.messagin g.MultipartMessage
Representa um MultipartMessage e proporciona métodos Set e Get.
javax.wireless.messagin g.sizeExceededException
Exceção lançada se o MultiparMessage é maior que a memória disponível.
2.4. EXEMPLOS MMS
2.4.1. Enviar um MMS usando JRS 205
A mensagem MMS conte duas partes: o encabeçado e o corpo, o corpo é uma mensagem multi-part onde cada multi-parte da mensagem tem um encabeçado e um corpo. Como os MMS são mensagens multi-part a gente pode incluir imagens ou arquivos em cada MMS.
Subject: DeliveryDate: Priority: From: To: MIME-Type: Content-ID: Content-Location: Content: MIME-Type: Content-ID: Content-Location: Content: Corpo da Mensagem Encabeçado da mensagem MessagePart Encabeçado MessagePart Encabeçado MessagePart Corpo MessagePart Corpo
20 Ao criar a Message Connection e Header (encabeçado) a gente pode usar a seguinte código: Este MMS é enviado a um numero telefônico e a um endereço E-Mail.
Aqui é aderida a mensagem de texto ao MMS:
O construtor MessagePart tomará todos os parâmetros do encabeçado e a mensagem contido como um byte array.
Aqui é aderida uma imagem ao MMS:
String address = "mms://+1555444333"; msgConn = (MessageConnection)Connector.open(address); mulMsg = (MultipartMessage)msgConn.newMessage(MessageConnection.MULTIPART_MESSAGE); mulMsg.setAddress(address); mulMsg.setAddress("mms://mail@mail.com"); mulMsg.setSubject("JAVA MMS TEST");
String mimeType = "text/plain"; String encoding = "UTF-8";
String text = "Hello from my java midlet"; byte[] contents = text.getBytes(encoding);
MessagePart msgPart = new MessagePart(contents, 0, contents.length, mimeType, "id1", "contentLocation", encoding);
mulMsg.addMessagePart(msgPart);
InputStream is = getClass().getResourceAsStream("image.jpg"); mimeType = "image/jpeg";
contents = new byte[is.available()]; is.read(contents);
msgPart = new MessagePart(contents, 0, contents.length, mimeType, "id2", "bg.jpg", null);
21 Quando a mensagem é criada e as partes da mensagem são aderidas à mensagem a gente pode enviar o MMS:
22 3. BIBLIOGRAFIA. • http://developers.sun.com/mobility/apis/articles/sip/index.html • http://developer.sonyericsson.com/site/global/techsupport/tipstrickscode/java/p_send_ mms_jsr205.jsp • http://developers.sun.com/mobility/midp/articles/wma2/index.html • http://www.forum.nokia.com/info/sw.nokia.com/id/24d26b19-c625-46a2-99c6-6e463bd09f5c/sipa1_0_1-ri-bin_Installer.zip.html • http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=wma • http://es.wikipedia.org/wiki/Session_Initiation_Protocol
