Introduzione
La progettazione di una applicazione Web per l'invio di MMS adopera 2 primitive del servizio MMS. Per implementare la gestione di un rapporto di consegna è necessario adoperare anche una terza primitiva.
L'invio di un MMS corrisponde alle due primitive M-Send.req e M-Send.conf, mentre la primitiva M-Delivery.ind viene utilizzata per la gestione del rapporto di consegna.

Figura 1- L 'architettura di riferimento

Le primitive che realizzano la connessione tra centro MMS e il destinatario sono state discusse nell'articolo precedente di Marzo 2004.

Analisi - Inviare un MMS da un form HTML
Analizziamo una applicazione per l'invio di un MMS da un form HTML, descrivendo gli headers generati e le loro caratteristiche.
Questo il semplice form HTML:

Figura 2 - Un form HTML per inviare MMS

Il click sul pulsante Send invia il messaggio ai tre destinatari, dove nei campi To e Cc sono stati inseriti dei numeri di telefono mentre nel campo Bcc è stato inserito un indirizzo di posta elettronica.
La primitiva M-Send.req è un pacchetto MMS composto da una parte di intestazione (gli headers) e dal corpo del messaggio. Qui il corpo del messaggio è composto da un testo e da una immagine (scelta tra le due disponibili).
Gli headers del pacchetto MMS sono 17 e alcuni di questi sono gli stessi del servizio di posta elettronica le cui regole sono definite nel rapporto tecnico RFC 822, mentre gli altri (il cui nome inizia con X-Mms) sono propri del servizio MMS:

• X-Mms-Message-Type - obbligatorio, descrive il tipo di primitiva che qui assume il valore M-Send.req.
• X-Mms-Transaction-ID - obbligatorio, identifica univocamente la primitiva M-Send.req e la primitiva di risposta M-Send.conf.
• X-Mms-MMS-Version - obbligatorio, la versione degli MMS che ora è la 1.0.
• Date - opzionale, è la data di invio del messaggio.
• From - obbligatorio, indirizzo del mittente.
• To, Cc, Bcc - almeno un campo è obbligatorio, sono i destinatari del messaggio. Il valore di ognuno di questi campi può essere un numero di telefono, un indirizzo di posta elettronica, e non solo.
• Subject - opzionale, il soggetto del messaggio (qui è "Un semplice MMS").
• X-Mms-Message-Class - opzionale, la classe di appartenenza del messaggio. Il campo può assumere il valore AUTO, INFORMATIONAL, ADVERTISEMENT e PERSONAL (qui è PERSONAL).
• X-Mms-Expiry - opzionale, questo campo assume un valore temporale che indica dopo quanto tempo il messaggio deve essere cancellato dal centro MMS. Infatti bisogna ricordare che il messaggio, dopo essere stato ricevuto con successo dal centro MMS, può non venire consegnato (ad esempio perché il telefono del destinatario non è più raggiungibile per un qualche motivo). Di default comunque il valore di questo campo è "maximum".
• X-Mms-Delivery-Time - opzionale, indica dopo quanto tempo il messaggio dal centro MMS deve essere consegnato al destinatario. Di default questo campo assume il valore immediato.
• X-Mms-Priority - opzionale, la priorità del messaggio che può essere NORMAL, LOW, HIGH. Di default il campo assume il valore NORMAL ( e qui è HIGH).
• X-Mms-Sender-Visibility - opzionale, i casi sono due: il destinatario non può conoscere l'indirizzo del mittente ed allora il campo va impostato con il valore Hide, o viceversa ed allora il campo va impostato con il valore Show. Di default questo campo assume il valore Show.
• X-Mms-Delivery-Report - opzionale, il campo può assume il valore YES (il mittente desidera la ricezione del rapporto di consegna da ogni destinatario) o viceversa ed allora il campo assume il valore NO. La ricezione del rapporto di consegna descrive in realtà lo stato del messaggio, che può essere stato consegnato al destinatario/i oppure può anche non essere stato consegnato.
• X-Mms-ReadReply - opzionale, il campo può assumere il valore YES (il mittente desidera la ricezione del rapporto di lettura da ogni destinatario) o il valore NO. Questa funzionalità però dipende anche dalle caratteristiche del telefono del destinatario e tipicamente non viene utilizzata.
• Content-Type - obbligatorio, i casi sono due: c'è una presentazione multimediale ed allora il campo assume il valore application/vnd.wap.multipart.related o non c'è una presentazione ed allora il campo vale application/vnd.wap.multipart.mixed.
  

Quando si invia un MMS con una presentazione si possono impostare alcuni parametri come i secondi di visualizzazione di un immagine.
La primitiva M-Send.conf inviata dal centro MMS in risposta alla primitiva M-Send.req è un pacchetto MMS costituito esclusivamente da una parte di intestazione. Gli headers generati da questa primitiva sono indispensabili per conoscere se il messaggio è stato consegnato correttamente al centro MMS, ed anche per gestire eventualmente il rapporto di consegna.
La consegna con successo del messaggio al centro MMS non significa che il messaggio è stato o possa essere recapitato al destinatario, in modo analogo al servizio di posta elettronica.
Questi i 6 headers generati dalla primitiva M-Send.conf:

• X-Mms-Message-Type - obbligatorio, indica il tipo di primitiva che è sempre M-Send.conf.
• X-Mms-Transaction-ID - obbligatorio, identifica univocamente la primitiva M-Send.req e la primitiva di risposta M-Send.conf.
• X-Mms-MMS-Version - obbligatorio, la versione degli MMS che ora è la 1.0.
• X-Mms-Response-Status - obbligatorio, invia al mittente un codice di stato.
• X-Mms-Response-Text - obbligatorio, la descrizione del codice di stato.
• Message-Id - opzionale, quando il centro MMS accetta un messaggio assegna a questo un identificativo univoco al mondo. Questo identificativo viene inserito sempre in questo pacchetto MMS se il mittente ha richiesto il rapporto di consegna.

Le Nokia MMS Java Library versione 1.1
Il pacchetto com.nokia.mms [1] è costituito da una interfaccia e da 7 classi fondamentali, più altre classi per le eccezioni.
Questa una breve descrizione:

• interface IMMConstants, questa contiene un insieme di costanti per impostare alcuni valori di un messaggio come la priorità, le classi del messaggio e cosi via.
• class MMAddress, rappresenta un esemplare di indirizzo MMS.
• class MMMessage, descrive un messaggio ed espone i metodi per impostare ed ottenere i valori degli headers.
• class MMSender, fornisce i metodi per l'invio di un messaggio.
• class MMResponse, espone i metodi per accedere agli headers della primitiva M-Send.conf.
• class MMEncoder e class MMDecoder, utilizzata per codificare e decodificare un messaggio in un flusso di byte [2].
• class MMContent, per aggiungere un contenuto (testo, immagini, audio) al messaggio.

Implementazione - Inviare un MMS da un form HTML
Vediamo un po' più in dettaglio rispetto all'articolo di Marzo come costruire il messaggio ed inviare questo al centro MMS.

Implementare un'applicazione Web per l'invio di MMS richiede anche una analisi di alcune problematiche che però non fanno parte degli obiettivi dell'articolo e che qui vengono brevemente accennate:

1. autenticazione di una persona per accedere al form html.
2. le immagini, ma anche altri contenuti come audio clip, è più comodo se sono memorizzati in un basi di dati come file binari (blob).
3. alcune proprietà del messaggio come il mittente, il content type, la versione degli MMS, la possibilità di negare la visualizzazione dell'indirizzo del mittente e così via dovrebbero essere memorizzate in un file di proprietà o un file xml sullo strato software del processo server.

Questo il codice Java, non vengono evidenziate le eccezioni:

//La prima operazione è assemblare il messaggio MMS
//con l'intestazione ed il corpo del messaggio.
//Si crea un esemplare di MMMessage che non richiede
//nessun parametro di costruzione.
MMMessage messaggio = new MMMessage();

//Impostazione degli headers, di cui alcuni
//dovrebbero essere elaborati da un file
//di configurazione sullo strato server
//e gli altri catturati dal form html.
//Questi i primi: il tipo di primitiva, il transaction id, la versione
//del servizio MMS e cosi via.
messaggio.setMessageType(IMMConstants.MESSAGE_TYPE_M_SEND_REQ);
messaggio.setTransactionId("00000000001");
messaggio.setVersion(IMMConstants.MMS_VERSION_10);
messaggio.setFrom("123.124.125.125/TYPE=PLMN")
messaggio.setDeliveryReport(false);
messaggio.setReadReply(false);
messaggio.setSenderVisibility(IMMConstants.SENDER_VISIBILITY_SHOW);
messaggio.setDate(new Date(System.currentTimeMillis()));
messaggio.setContentType(IMMConstants.CT_APPLICATION_MULTIPART_MIXED);
//Headers elaborati in qualche modo dal form html
messaggio.addToAddress("3401212341/TYPE=PLMN");
messaggio.addCcAddress("3472333331/TYPE=PLMN");
messaggio.addBccAddress("john@enterprise.com");
messaggio.setMessageClass(IMMConstants.MESSAGE_CLASS_PERSONAL);
mm.setPriority(IMMConstants.PRIORITY_HIGH);

//Adesso si aggiunge il corpo del messaggio: il testo
//elaborato dal form html ed il contenuto (una delle 2 immagini)
MMContent parte1 = new MMContent();
//il testo
String testo = "Ciao, questo è un messaggio multimediale"
byte[] buf1 = testo.getBytes();
parte1.setContent(buf1, 0, buf1.length);
parte1.setContentId("<0>");
parte1.setType(IMMConstants.CT_TEXT_PLAIN);
messaggio.addContent(parte1);
//l'immagine, da una query su basi di dati
MMContent parte2 = new MMContent();
byte[] query = . . . . . . .
byte[] buf2 = query;
parte2.setContent(buf2, 0, buf2.length);
parte1.setContentId("<1>");
parte2.setType(IMMConstants.CT_IMAGE_GIF);
messaggio.addContent(part2);

//Impacchettato il messaggio deve essere codificato
//secondo lo standard MMS
MMEncoder encoder=new MMEncoder();
encoder.setMessage(messaggio);
encoder.encodeMessage();
byte[] out = encoder.getMessage()

//Il messaggio viene inviato al centro MMS,
//l'indirizzo del centro MMS qui è
//l'emulatore EAIF MMSC
MMSender sender = new MMSender();
MMResponse risposta = sender.setMMSCURL("http://127.0.0.1:8189");

//L'esemplare risposta della classe MMResposne
//è il pacchetto MMS generato dalla primitiva M-Send.conf.
//Possiamo sapere se il messaggio è arrivato correttamente:
System.out.println("codice:" + risposta.getResponseCode());
System.out.println("descrizione:" + risposta.getResponseMessage());
//ma anche accedere agli altri headers:
Enumeration headerKeys = risposta.getHeadersList();
while(headerKeys.hasMoreElements())
{
String nomeHeader = (String)headerKeys.nextElement();
String valoreHeader = (String)risposta.getHeaderValue(nomeHeader);
System.out.println(nomeHeader + ":" + valoreHeader);
}

Testing - Inviare un MMS da un form HTML
Per testare l'applicazione è necessario adoperare un emulatore per il centro MMS, qui utilizziamo il
Nokia MMSC EAIF Emulator [3]. Questo emulatore sviluppato con il linguaggio Java si pone in ascolto su una determinata porta e quando riceve un MMS assegna al messaggio un Message-Id e visualizza le caratteristiche del messaggio stesso.
E' necessario installare l'emulatore e porsi in ascolto su una porta (menu Application - Originating) che di default è la 8189, comunque insieme con l'emulatore viene fornito il manuale di installazione e configurazione.
Questo il risultato della ricezione del messaggio assemblato precedentemente:

Figura 3 - Il messaggio appena consegnato

Figura 4 - I dettagli del messaggio

Conclusioni
Questo articolo ha analizzato alcuni particolari del servizio MMS e proposto una implementazione di un servizio per l'invio di MMS. Sono state utilizzate le Nokia MMS Java Library [1] e l'emulatore EAIF [3] per testare l'applicazione, queste librerie e l'emulatore sono stati sostituiti dall'ultimo ambiente di sviluppo il Nokia Mobile Server Services [4]. In ogni caso questi tools sono più semplici e comprensibili per lo studio del servizio MMS.

Bibliografia e Riferimenti
[1] Nokia MMS Java Library Ver 1.1, 4-Marzo-2002, www.forum.nokia.com.
[2] "MMS Encapsulation Protocol" Wap Forum www.wapforum.org.
[3] Nokia MMSC EAIF Emulator Ver 1.1, 2002, www.forum.nokia.com.
[4] Nokia Mobile Server Services SDK 1.3 20-Gennaio-2004, www.forum.nokia.com.