Instructions relatives à Office 2010 Mobile Service (partie 1/3)
Synthèse : découvrez comment générer et héberger des services Web pour Microsoft Office 2010 Mobile Service (OMS). Cet article présente l’architecture et le flux de messages OMS, et décrit les protocoles de communication entre les clients OMS et les services Web. Notez qu’Office Mobile Service dans Office 2010 est la version mise à jour d’Outlook Mobile Service présent dans Microsoft Office System 2007 (20 pages imprimées).
Dernière modification : lundi 9 mars 2015
S’applique à : Excel 2010 | Office 2007 | Office 2010 | Office Mobile | Open XML | Outlook 2010 | Outlook Mobile | PowerPoint 2010 | SharePoint Foundation 2010 | SharePoint Server 2010 | VBA | Word 2010
Dans cet article
Présentation d’Office Mobile Service
Architecture et flux de messages
Protocoles de communication
Redirection de l’URL du service Web.
Empaquetage des messages mobiles entrants
Conclusion
Ressources supplémentaires
Sommaire
Présentation d’Office Mobile Service
Architecture et flux de messages
Protocoles de communication
Redirection de l’URL du service Web.
Empaquetage des messages mobiles entrants
Conclusion
Ressources supplémentaires
Présentation d’Office Mobile Service
Microsoft Office 2010 Mobile Service (OMS) est le composant de messagerie développé pour Microsoft Outlook 2010 et Microsoft SharePoint 2010. Avec OMS, les utilisateurs peuvent intégrer en toute transparence les fonctionnalités mobiles d’Outlook et de SharePoint à leurs appareils mobiles.
Les fonctionnalités de messagerie mobile proposées par OMS permettent aux utilisateurs d’effectuer les tâches suivantes :
Composer de nouveau messages texte et multimédias dans Outlook
Transférer des éléments Outlook (y compris des messages électroniques, des réunions et des contacts) en tant que messages texte ou multimédias
Recevoir des réponses provenant d’appareils mobiles et établir une communication bidirectionnelle entre Outlook et les téléphones mobiles
Recevoir des messages d’alerte provenant de SharePoint sur des téléphones mobiles
Étendre les fonctionnalités de messagerie d’Outlook et de SharePoint OMS par l’intermédiaire du modèle d’objet fourni
Office Mobile Service dans Outlook
Grâce à la fonctionnalité de redirection d’éléments fournie par OMS, les utilisateurs peuvent non seulement composer et envoyer des messages texte et multimédias à partir d’Outlook, mais aussi rediriger automatiquement des rappels, des messages électroniques et le calendrier du lendemain vers un téléphone mobile en définissant des conditions simples. Ils peuvent également envoyer des messages électroniques, des rendez-vous et des demandes de réunion à des téléphones mobiles et à d’autres adresses de messagerie.
OMS est intégré aux paramètres de compte Outlook, ce qui permet aux utilisateurs de gérer leurs comptes de messagerie mobile parallèlement à leurs comptes de messagerie en toute transparence. Les numéros de téléphone mobile sont traités comme un type d’adresse, et les utilisateurs peuvent ajouter des destinataires à un message mobile en utilisant la saisie semi-automatique ou en sélectionnant des noms directement dans le Carnet d’adresses Outlook. Ils peuvent également stocker et gérer des messages mobiles dans des dossiers Outlook.
Le client OMS, qui est intégré à Outlook et SharePoint, envoie des messages texte et multimédias à un service Web créé et hébergé par des partenaires qui sont soit des opérateurs, soit des fournisseurs de services de contenu de message mobile. Le service Web remet ensuite le message à un centre d’opérateurs de service de message texte ou multimédia.
Office Mobile Service dans SharePoint 2010
Dans SharePoint 2010, un utilisateur peut recevoir des alertes par message texte (SMS) via OMS. L’utilisateur peut être notifié de l’état de documents ou de listes SharePoint et recevoir des message texte signalant tout changement, ainsi que l’URL du document ou de la liste si nécessaire.
Informations supplémentaires
Cet article, premier volet d’une série en trois parties, présente OMS et fournit des instructions et des informations de référence sur l’utilisation du service. Pour des recommandations sur la façon d’implémenter un service Web OMS, voir Instructions sur Office Mobile Service 2010 (Partie 2/3). Pour plus d’informations sur le schéma XML concernant les données passées entre les fournisseurs Web OMS et les clients OMS, voir Instructions relatives à Office 2010 Mobile Service (partie 3/3).
Le public visé par cet article doit posséder des connaissances en matière de développement et de déploiement de services Web. Pour obtenir des informations générales sur les services Web, voir Services Web (éventuellement en anglais). Pour plus d’informations sur le développement de services Web, consultez la documentation fournie avec l’outil de développement que vous utilisez.
Architecture et flux de messages
L’architecture globale d’OMS est une infrastructure de service client basée sur la technologie des services Web. Le client OMS, qui est intégré à Outlook ou SharePoint, code un message mobile en tant que message SOAP et l’envoie au service Web OMS, où il est alors codé et remis à la passerelle de message mobile de l’opérateur. Le message est ensuite remis au téléphone mobile d’un utilisateur prévu par le biais des réseaux sans fil mobiles de l’opérateur. Le service Web OMS est créé et hébergé par un fournisseur de services qui est un opérateur de téléphonie mobile ou un agrégateur (fournisseur de contenu Internet, fournisseur de services Internet ou tout autre tiers en mesure de fournir un service de messagerie mobile). La spécification du service Web OMS et les protocoles de communication entre le client OMS et le service Web sont décrits dans la section Protocoles de communication de cet article.
À l’heure actuelle, SharePoint 2010 remet les messages mobiles à un service Web OMS en sens unique, mais Outlook peut établir une communication bidirectionnelle avec le service Web OMS. Les messages circulent entre Outlook et le téléphone mobile du destinataire par l’intermédiaire du service Web OMS et l’infrastructure de l’opérateur, comme illustré à la figure 1. Les réponses du téléphone mobile du destinataire peuvent être acheminées dans la Boîte de réception Outlook, l’appareil mobile de l’expéditeur ou les deux selon les préférences de l’utilisateur. Pour remettre des réponses dans la Boîte de réception Outlook d’un utilisateur, le fournisseur de services les empaquette en tant que messages électroniques SMTP (Simple Mail Transfer Protocol) selon la spécification définies par Microsoft (voir la section Empaquetage des messages mobiles entrants de cet article).
Figure 1. Flux de messages pour Office Mobile Service dans Outlook
.gif "Architecture et flux de messages")
Protocoles de communication
Il y a plusieurs règles à respecter lors du développement d’un service Web OMS. Premièrement, le service Web OMS doit adhérer au langage WSDL (Web Services Description Language). Ainsi, le client OMS peut se connecter au service sans avoir à modifier le code spécifique au service.
Deuxièmement, le service Web OMS doit prendre en charge les méthodes Web suivantes :
string GetServiceInfo() : récupère les propriétés du service Web OMS.
string GetUserInfo(string xmsUser) : récupère les informations de l’utilisateur.
string DeliverXms(string xmsData) : envoie un message mobile au service Web.
string DeliverXmsBatch(string packageXml) : envoie plusieurs chaînes xmsData dans un lot au service Web.
Troisièmement, le service Web OMS doit respecter les instructions relatives à l’envoi de messages mobiles au client Outlook OMS sous forme de messages électroniques, comme décrit dans la section Empaquetage des messages mobiles entrants de cet article.
Notes
Si vous mettez à niveau votre service Web OMS à partir de Microsoft Office Outlook 2007, notez que la méthode Web SendXms a été renommée DeliverXms depuis Outlook 2007 Service Pack 1 (SP1). Si vous souhaitez que votre service Web OMS fonctionne avec la version RTM d’Outlook 2007, ainsi qu’avec Outlook 2007 SP1 ou Outlook 2010, vous devez prendre en charge SendXms et DeliverXms en spécifiant la même définition pour SendXms et DeliverXms. Une fois que tous vos abonnés ont effectué la mise à niveau vers Outlook 2007 SP1 ou Outlook 2010, vous pouvez cesser la prise en charge de SendXms.
Exemple d’implémentation simple d’un service Web
L’exemple de code suivant décrit une implémentation simplifiée du service Web OMS. Les méthodes GetUserInfo() et GetServiceInfo() retournent des informations et le code d’erreur approprié. Les informations et les codes d’erreur à retourner sont stockés sous forme de fichiers XML. Cet exemple suppose qu’une méthode LoadXmlFromFile(string filename) a été créée pour charger le code XML d’un fichier et retourner le résultat sous forme de chaîne, et qu’une classe privée CUserLogon a été implémentée pour fournir la fonctionnalité de validation des utilisateurs.
using System;
using System.IO;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Web.Mail;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
[WebService(Namespace="https://schemas.microsoft.com/office/Outlook/2006/OMS")]///<Do not change the namespace!/>
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class OMSService : System.Web.Services.WebService
{
/// <Get service information, such as the capacities of supported services./>
[WebMethod]
public string GetServiceInfo()
{
return LoadXmlFromFile("SampleServiceInfo.xml");
}
/// <Get user information including SMTP address and mobile phone number./>
[WebMethod]
public string GetUserInfo(string xmsUser)
{
if (!m_schemaProvider.FValidXml(xmsUser, "xmsUserSchema.xsd"))
{
return LoadXmlFromFile("SchemaError.xml");
}
CUserLogon usrLogon = new CUserLogon(xmsUser);
if (!usrLogon.FLogon())
{
return LoadXmlFromFile("LogonFailed.xml");
}
return LoadXmlFromFile("SampleUserInfo.xml");
}
/// <Send SMS or MMS message data to specific recipients./>
[WebMethod]
public string DeliverXms(string xmsData)
{
if (!m_schemaProvider.FValidXml(xmsUser, "xmsDataSchema.xsd"))
{
return LoadXmlFromFile("SchemaError.xml");
}
CUserLogon usrLogon = new CUserLogon(xmsData);
if (!usrLogon.FLogon())
{
return LoadXmlFromFile("LogonFailed.xml");
}
return LoadXmlFromFile("SampleResponse.xml");
}
// <Load XML file./>
private string LoadXmlFromFile(string strFile)
{
// ...
}
// Helps validate XMS schemas
private CSchemaProvider m_schemaProvider;
};//OMSService
// Extract user logon information from XML string and process logon validation.
private class CUserLogon
{
// ....
};
// Cache schema validators
private class CSchemaProvider
{
// ....
};
Les sections suivantes décrivent les méthodes du service Web OMS plus en détail et incluent un exemple de code et des exemples de chaînes au format XML (serviceInfo, userInfo et xmsResponse) qui sont passées entre ces méthodes. Le WSDL relatif à ces méthodes Web, ainsi que les schémas des chaînes au format XML passées entre ces méthodes, sont inclus dans le dernier article de cette série, Instructions relatives à Office 2010 Mobile Service (partie 3/3).
Méthode de service Web string GetServiceInfo()
GetServiceInfo() retourne une chaîne au format XML appelée serviceInfo qui contient les propriétés de base du service Web OMS, telles que les types de service pris en charge, les paramètres des services pris en charge et les types d’authentification.
Le client OMS intégré à Outlook appelle GetServiceInfo() pour récupérer les propriétés d’un service Web OMS lorsqu’un utilisateur établit un nouveau compte ou pour mettre à jour des propriétés de service après la publication du service Web OMS. Avec ces propriétés, OMS configure le service Web en tant que fournisseur de services pris en charge côté client.
L’exemple de code suivant illustre une chaîne serviceInfo retournée par GetServiceInfo().
<?xml version="1.0" encoding="utf-8"?>
<serviceInfo
xmlns="https://schemas.microsoft.com/office/Outlook/2006/OMS/serviceInfo">
<serviceProvider>ABC Company</serviceProvider>
<serviceUri>http://www.abc.com.cn/OMS3/XMS.asmx</serviceUri>
<signUpPage>http://www.abc.com.cn/ws/xmssignup.aspx/</signUpPage>
<targetLocale>2052</targetLocale>
<localName>ABC Mobile Service</localName>
<englishName>ABC Mobile Service</englishName>
<authenticationType>Other</authenticationType>
<supportedService>
<SMS_SENDER maxRecipientsPerMessage="50" maxMessagesPerSend="20"
maxSbcsPerMessage="140" maxDbcsPerMessage="70" />
<MMS_SENDER supportSlide="true" maxRecipientsPerMessage="100"
maxSizePerMessage="30000" maxSlidesPerMessage="10" />
</supportedService>
</serviceInfo>
Les développeurs doivent également noter les points suivants :
La chaîne serviceInfo est transférée en tant que chaîne Unicode, puis codée au format UTF-16.
La valeur serviceUri est utilisée pour identifier de manière unique le service. Si le serviceUri d’un service Web OMS est modifié, le client OMS traite le service comme un nouveau service Web OMS.
Pour prendre en charge les messages texte longs, un fournisseur de services peut attribuer aux attributs maxSbcsPerMessage et maxDbcsPerMessage de l’élément SMS_SENDER des valeurs qui peuvent être prises en charge par la plupart des modèles utilisés par ses abonnés.
Si un service Web OMS attribue à l’attribut supportSlide de l’élément MMS_SENDER de sa chaîne serviceInfo la valeur « true », cela signifie que le service Web prend en charge le format SMIL (Synchronized Multimedia Integration). On dit d’un message qui utilise SMIL qu’il est en mode Diapositive. Si un service Web OMS qui ne prend en charge pas SMIL reçoit un message en mode Diapositive, le service Web doit signaler une erreur de type « other » ou convertir le message en mode Non-diapositive.
Méthode de service Web string GetUserInfo(string xmsUser)
Le client intégré à Outlook récupère le numéro de téléphone mobile d’un utilisateur et d’autres informations en appelant GetUserInfo() avec une chaîne xmsUsercomme paramètre. xmsUser est une chaîne au format XML qui contient les informations d’authentification de l’utilisateur, y compris l’ID de l’utilisateur et le mot de passe. GetUserInfo() retourne une chaîne au format XML appelée userInfo qui contient un élément error dont l’attribut severity a la valeur « failure ». Le schéma pour xmsUser est inclus dans le dernier article de cette série, Instructions relatives à Office 2010 Mobile Service (partie 3/3).
Les codes d’erreur qui sont généralement retournés dans une chaîne userInfo sont répertoriés dans le tableau 1.
Tableau 1. Erreurs retournées par un appel à GetUserInfo()
Code |
Sévérité |
|---|---|
Ok |
Neutral |
invalidUser |
Failure |
unregisteredUser |
Failure |
expiredUser |
Failure |
Pour obtenir la liste complète des codes d’erreur qu’un service Web OMS peut envoyer, voir la section « Codes d’erreur OMS » dans Instructions relatives à Office 2010 Mobile Service (partie 3/3). Notez, toutefois, que le schéma userInfo ne contient pas les éléments enfants content ou recipientList mentionnés dans cette section. Par ailleurs, l’attribut severity est facultatif pour une erreur dans une chaîne userInfo, bien qu’il soit obligatoire dans une chaîne xmsResponse. Si aucun attribut severity n’est défini pour un élément error dans une chaîne userInfo, le client OMS suppose que la sévérité de l’erreur est « neutral ».
Notes
Les chaînes xmsUser et userInfo sont transférées en tant que chaînes Unicode et codées au format UTF-16.
L’exemple de code suivant illustre une implémentation de GetUserInfo() qui utilise un objet XmlTextWriter pour écrire les information de l’utilisateur et le code d’erreur dans une chaîne au format XML.
// ...
private const string m_sOmsNamespace = "https://schemas.microsoft.com/office/Outlook/2006/OMS";
public string GetUserInfo(string xmsUser)
{
StringWriter stringWriter = null;
XmlTextWriter writer = null;
try
{
// Add code to verify user logon password
// and retrieve user information.
// ...
stringWriter = new StringWriter(new StringBuilder());
writer = new XmlTextWriter(stringWriter);
writer.WriteStartElement("userInfo", m_sOmsNamespace);
writer.WriteStartElement("replyPhone");
writer.WriteString(**replyPhone value**);
writer.WriteEndElement(); // </replyPhone>
writer.WriteStartElement("smtpAddress");
writer.WriteString(**smtpAddress value**);
writer.WriteEndElement(); // </smtpAddress>
writer.WriteStartElement("error");
writer.WriteAttributeString("code", "ok"); // return "ok" if no errors
writer.WriteEndElement(); // </error>
writer.WriteEndElement(); // </userInfo>
return stringWriter.GetStringBuilder().ToString();
}
finally
{
if (writer != null)
writer.Close();
if (stringWriter != null)
stringWriter.Close();
}
}
Les exemples suivants illustrent des chaînes xmsUser et userInfo.
Exemple de chaîne xmsUser
<?xml version="1.0" encoding="utf-8"?>
<xmsUser client="Microsoft Office Outlook 12.0" xmlns = "https://schemas.microsoft.com/office/Outlook/2006/OMS">
<userId>myname</userId>
<password>mypwd</password>
<customData/>
</xmsUser>
Exemple de chaîne userInfo retournée par GetUserInfo() après un appel réussi
<?xml version="1.0" encoding="utf-8"?>
<userInfo xmlns = "https://schemas.microsoft.com/office/Outlook/2006/OMS">
<replyPhone>090123456</replyPhone>
<smtpAddress>userid.spmail@spdomain.com</smtpAddress>
<error code="ok"/>
</userInfo>
Exemple de chaîne userInfo retournée après une erreur
<?xml version="1.0" encoding="utf-8"?>
<userInfo xmlns = "https://schemas.microsoft.com/office/Outlook/2006/OMS">
<error code="unregistered" severity="failure"/>
</userInfo>
Examinons maintenant de plus près les éléments d’une chaîne userInfo . L’élément replyPhone contient le numéro mobile dont s’est servi l’utilisateur pour s’abonner au service auprès du fournisseur de services. La valeur de replyPhone est affichée dans la boîte de dialogue des paramètres de compte dans Outlook comme le numéro de mobile par défaut de l’utilisateur. Le client OMS obtient la valeur de replyPhone en appelant GetUserInfo() lorsque l’utilisateur configure un compte. Le client OMS appelle également GetUserInfo() pour mettre à jour replyPhone d’un utilisateur lorsqu’il affiche ou modifie le compte sans entrer de numéro mobile, ou lorsque le service Web OMS notifie au client que les informations de service sont modifiées par le biais du code d’erreur « serviceUpdate ».
Dans Outlook 2007, l’élément replyPhone était utilisé comme numéro de rappel par défaut pour certains marchés, comme la Corée, où un numéro de rappel est requis et pris en charge. Dans Outlook 2010, la fonctionnalité n’existe plus et cet élément n’est pas requis.
Enfin, l’élément smtpAddress contient une adresse SMTP unique que le fournisseur de services génère pour chaque abonné. Le fournisseur de services utilise l’adresse SMTP pour renvoyer les réponses d’un téléphone mobile vers Outlook. La création d’adresses SMTP uniques pour chaque abonné est exigée des fournisseurs de services OMS pour empêcher les utilisateurs malveillants d’envoyer des messages indésirables à l’aide de l’adresse SMTP.
Méthode de service Web string DeliverXms(string xmsData)
Le client OMS qui est intégré à Outlook ou SharePoint appelle DeliverXms() pour remettre un message mobile au fournisseur de services. Le contenu du message est empaqueté sous forme d’une chaîne au format XML appelée xmsData. Lorsque le fournisseur de services tente d’envoyer le message, il retourne une chaîne au format XML appelée xmsResponse qui contient un ou plusieurs éléments error indiquant la réussite ou l’échec de la tentative d’envoi du message à chaque destinataire prévu.
L’exemple de code suivant illustre une implémentation de DeliverXms() qui utilise un objet XmlTextWriter pour écrire la réussite ou l’échec de l’appel dans une chaîne xmsResponse.
// ...
private const string m_sOmsNamespace = "https://schemas.microsoft.com/office/Outlook/2006/OMS";
public string DeliverXms(string xmsData)
{
StringWriter stringWriter = null;
XmlTextWriter writer = null;
try
{
stringWriter = new StringWriter(new StringBuilder());
writer = new XmlTextWriter(stringWriter);
writer.WriteStartElement("xmsResponse", m_sOmsNamespace);
// XML format validation.
if (!m_schemaProvider.FValidXml(xmsData, "xmsDataSchema.xsd"))
{
BuildError(writer, "invalidFormat", true /* failure */, "", "");
return stringWriter.GetStringBuilder().ToString();
}
// User validation.
CUserLogon usrLogon = new CUserLogon(xmsData);
if (!usrLogon.FLogon())
{
BuildError(writer, "invalidUser", true /* failure */, "", "");
return stringWriter.GetStringBuilder().ToString();
}
// Add your code for your business logic to send the xmsData
//to the intended recipients.
// ...
// Sent out OK.
BuildError(writer, "ok", false /* success */, "", "");
return stringWriter.GetStringBuilder().ToString();
}
catch (XmlException ex)
{
// Handle exceptions.
return "<?xml version=\"1.0\" encoding=\"utf-16\"?>"
+ " <xmsResponse xmlns=\
"https://schemas.microsoft.com/office/Outlook/2006/OMS\">"
+ " <error code=\"others\" severity=\"failure\"> <content>"
+ ex.Message + " </content> </error>"
+ "</xmsResponse>";
}
finally
{
if (writer != null)
writer.Close();
if (stringWriter != null)\
stringWriter.Close();
}
}//end DeliverXms
// Build error elements.
private void BuildError(XmlTextWriter wr,
string errCode,
bool bFailed,
string strContent,
string strRecipients)
{
wr.WriteStartElement("error");
wr.WriteAttributeString("code", errCode);
wr.WriteAttributeString("severity", bFailed ? "failure" : "neutral");
if (strContent.Length > 0)
{
wr.WriteStartElement("content");
wr.WriteString(strContent);
wr.WriteEndElement(); // </content>
}
if (strRecipients.Length > 0)
{
wr.WriteStartElement("recipientList");
wr.WriteString(strRecipients);
wr.WriteEndElement(); // </recipientList>
}
wr.WriteEndElement(); // </error>
}//end BuildError
xmsData
La chaîne xmsData sert à empaqueter un message texte ou multimédia, ce qui signifie que les message texte et les messages multimédias partagent le même schéma. Les exemples suivants illustrent une chaîne xmsData contenant un message au format MMS et une chaîne xmsData contenant un message au format SMS.
Exemple de chaîne xmsData contenant un message au format SMS
<?xml version="1.0" encoding="utf-8"?>
<xmsData client="Microsoft Office Outlook 12.0" xmlns = "https://schemas.microsoft.com/office/Outlook/2006/OMS">
<user>
<userId>myname</userId>
<password>mypwd</password>
<replyPhone>13801391350</replyPhone>
<customData/>
</user>
<xmsHead>
<scheduled>2005-04-20T14:20:00Z</scheduled>
<requiredService>SMS_SENDER</requiredService>
<to>
<recipient>135xxxx</recipient>
<recipient>139xxxx</recipient>
</to>
</xmsHead>
<xmsBody format="SMS">
<content contentType="text/plain" contentId="Att0.txt@AB1B43B2B0594564.B94EF7ABB12B49BA"
contentLocation="1.txt">(1/2)This is the first SMS message...</content>
<content contentType="text/plain" contentId="Att1.txt@AB1B43B2B0594564.B94EF7ABB12B49BA"
contentLocation="2.txt">(2/2)This is the second SMS message...</content>
</xmsBody>
</xmsData>
Exemple de chaîne xmsData contenant un message au format MMS
<?xml version="1.0" encoding="utf-8"?>
<xmsData client="Microsoft Office Outlook 12.0"xmlns = "https://schemas.microsoft.com/office/Outlook/2006/OMS">
<user>
<userId>myname</userId>
<password>mypwd</password>
<replyPhone>13801391350</replyPhone>
<customData/>
</user>
<xmsHead>
<scheduled>2005-04-20T14:20:00Z</scheduled>
<requiredService>MMS_SENDER</requiredService>
<sourceType>reminder</sourceType>
<to>
<recipient>135xxxx</recipient>
<recipient>139xxxx</recipient>
</to>
<subject>My Message</subject>
</xmsHead>
<xmsBody format="MMS">
<mmsSlides>
<head>
<meta name="author" content="msOfficeOutlookOms" />
<layout>
<root-layout width="120" height="120" background-color="#ffffff" />
<region id="image" left="0" top="0" width="120" height="90" />
<region id="text" left="0" top="90" width="120" height="30" />
</layout>
</head>
<body>
<par dur="3000">
<img src="cid:Att1.gif@AB1B43B2B0594564.B94EF7ABB12B49BA" region="image" />
<text src="cid:Att0.txt@AB1B43B2B0594564.B94EF7ABB12B49BA" region="text"/>
<audio src="cid:Att2.mid@AB1B43B2B0594564.B94EF7ABB12B49BA" />
</par>
</body>
</mmsSlides>
<content contentType="text/plain" contentId="Att0.txt@AB1B43B2B0594564.B94EF7ABB12B49BA"
contentLocation="1.txt">This is the text part</content>
<content contentType="image/gif" contentId="Att1.gif@AB1B43B2B0594564.B94EF7ABB12B49BA"
contentLocation="106675.gif">/9j/4AAQ ...... AVExISEyccHhcgLikxMC4p</content>
<content contentType="audio/midi" contentId="Att2.mid@AB1B43B2B0594564.B94EF7ABB12B49BA"
contentLocation="1898.mid">/wDQjVYUrl ...... GoJ4e8j</content>
</xmsBody>
</xmsData>
Méthode de service Web string DeliverXmsBatch(string packageXml)
Le client OMS qui est intégré à SharePoint appelle DeliverXmsBatch() pour remettre un certain nombre d’éléments xmsData dans une seule transaction XML au fournisseur de services. Le contenu du message est empaqueté sous forme d’une chaîne au format XML appelée packageXml. Lorsque le fournisseur de services tente d’envoyer le message, il retourne une chaîne au format XML appelée xmsResponses qui contient un ou plusieurs éléments qui indiquent la réussite ou l’échec de chaque tentative d’envoi du message à chaque destinataire prévu.
L’exemple de code suivant illustre une implémentation de DeliverXmsBatch() qui utilise un objet XmlTextWriter pour écrire la réussite ou l’échec de l’appel dans une chaîne xmsResponses.
// ...
private const string m_sOmsNamespace = "https://schemas.microsoft.com/office/Outlook/2006/OMS";
[WebMethod]
public String DeliverXmsBatch(String packageXml)
{
if (String.IsNullOrEmpty(packageXml))
{
throw new ArgumentNullException("packageXml", "packageXml can't be null or empty!");
}
String xmsDataTag = "xmsData";
String xmsBatchTag = "xmsBatch";
StringWriter responseStringWriter = new StringWriter();
XmlWriter responseXmlWriter = CreateXmlWriter(responseStringWriter);
Stack<String> stack = new Stack<String>();
using (XmlReader reader = XmlReader.Create(new StringReader(packageXml)))
{
int messageCount = 0;
responseXmlWriter.WriteStartElement("xmsResponses", m_sOmsNamespace);
String nameSpace = String.Empty;
while (!reader.EOF)
{
if (stack.Count == 0)
{
if (reader.IsStartElement() && reader.LocalName == xmsBatchTag)
{
stack.Push(xmsBatchTag);
nameSpace = reader.NamespaceURI;
}
}
else if (reader.IsStartElement() && stack.Peek() == xmsBatchTag)
{
if (reader.IsStartElement(xmsDataTag, nameSpace))
{
String response = String.Empty;
if (++messageCount <= m_MaxBatchSize)
{
// Process this node and its subnodes.
response = SendOneXms(reader.ReadOuterXml(), true);
}
else
{
String xmsId = reader.GetAttribute("Id");
using (StringWriter stringWriter = new StringWriter(new StringBuilder()))
{
using (XmlTextWriter writer = new XmlTextWriter(stringWriter))
{
writer.WriteStartElement("xmsResponse");
if (!String.IsNullOrEmpty(xmsId))
{
writer.WriteAttributeString("Id", xmsId);
}
String content = String.Format(
"One batch can only contain {0} messages at maximum.", m_MaxBatchSize);
BuildError(writer, "perbatchmsglimit", true, content, "");
response = stringWriter.GetStringBuilder().ToString();
}
}
reader.ReadOuterXml(); //skip this node and its sub-nodes.
}
responseXmlWriter.WriteRaw(response);
continue;
}
}
reader.Read();
}
}
responseXmlWriter.WriteEndElement();
responseXmlWriter.Flush();
return responseStringWriter.ToString();
}
public string SendOneXms(string xmsData, bool batchMode)
{
String xmsId = "0";
StringWriter stringWriter = null;
XmlTextWriter writer = null;
try
{
XmlReader reader = XmlReader.Create(new StringReader(xmsData));
stringWriter = new StringWriter(new StringBuilder());
writer = new XmlTextWriter(stringWriter);
writer.WriteStartElement("xmsResponse", batchMode ? "" : m_sOmsNamespace);
// Update xmsId with your code (for example, reader.GetAttribute("Id")).
if (!String.IsNullOrEmpty(xmsId))
{
writer.WriteAttributeString("Id", xmsId);
}
// User validation.
CUserLogon usrLogon = new CUserLogon(xmsData);
if (!usrLogon.FLogon())
{
BuildError(writer, "invalidUser", true /* failure */, "", "");
return stringWriter.GetStringBuilder().ToString();
}
// Add your code for your business logic to send the xmsData
// to the intended recipients.
// ...
// Sent out OK.
reader.Close();
BuildError(writer, "ok", false /* success */, "", "");
return stringWriter.GetStringBuilder().ToString();
}
catch (XmlException ex)
{
// Handle exceptions.
String attrText = batchMode ? "Id=\"" + xmsId + "\"" : "xmlns=
\"https://schemas.microsoft.com/office/Outlook/2006/OMS\"";
return "<?xml version=\"1.0\" encoding=\"utf-16\"?>"
+ " <xmsResponse " + attrText + ">"
+ " <error code=\"others\" severity=\"failure\"> <content>"
+ ex.Message + "</content> </error>" + "</xmsResponse>";
}
finally
{
if (writer != null)
writer.Close();
if (stringWriter != null)
stringWriter.Close();
}
}
packageXml
La chaîne packageXml sert à empaqueter un certain nombre d’éléments de xmsData (messages texte ou multimédias) dans un schéma XML. L’exemple suivant illustre une chaîne packageXml contenant deux messages au format SMS.
Exemple de chaîne packageXml contenant deux messages au format SMS
<?xml version="1.0" encoding="utf-8"?>
<xmsBatch client="Microsoft Windows SharePoint Service" xmlns="https://schemas.microsoft.com/office/Outlook/2006/OMS">
<xmsData id="0">
<user>
<userId>ddguo</userId>
<password />
<customData />
</user>
<xmsHead>
<requiredService>SMS_SENDER</requiredService>
<sourceType>wssAlert</sourceType>
<to>
<recipient>13671121236</recipient>
</to>
</xmsHead>
<xmsBody format="SMS">
<content contentType="text/plain" contentId="1.txt@5ca13ed023024ed59cfae6c0e185a5db" contentLocation="1.txt">This is a testing message.</content>
</xmsBody>
</xmsData>
<xmsData id="1">
<user>
<userId>ddguo</userId>
<password />
<customData />
</user>
<xmsHead>
<requiredService>SMS_SENDER</requiredService>
<sourceType>wssAlert</sourceType>
<to>
<recipient>13671121236</recipient>
</to>
</xmsHead>
<xmsBody format="SMS">
<content contentType="text/plain" contentId="1.txt@ecf25304326e497c8775a929a3178311" contentLocation="1.txt">This is a testing message.</content>
</xmsBody>
</xmsData>
</xmsBatch>
Types de contenu pris en charge
Les messages SMS (Short Message Service) prennent en charge le type de contenu « text/plain ». OMS prend en charge les objets multimédias répertoriés dans le tableau 2 pour les messages MMS (Multimedia Messaging Service). Côté client, OMS convertit d’autres types d’éléments multimédias en ces formats standard si nécessaire.
Tableau 2. Types de contenu pris en charge
Contenu |
Type MIME |
Description |
|---|---|---|
Texte |
text/plain |
Texte brut. Peut être utilisé par les messages SMS et MMS. |
Image statique |
image/jpeg |
96 ppp. Inférieure ou égale à la taille de l’écran mobile définie dans l’élément root-layout de la chaîne xmsData. Codé en mode Base64. S’applique uniquement aux messages MMS. |
Image multiframe |
image/gif |
GIF89a, 96 ppp, 256 couleurs maximum. Inférieure ou égale à la taille de l’écran mobile définie dans l’élément root-layout de la chaîne xmsData. Codé en mode Base64. S’applique uniquement aux messages MMS. |
Format audio MIDI |
Audio/mid |
Format MIDI. Codé en mode Base64. S’applique uniquement aux messages MMS. |
Format audio AMR |
Audio/AMR |
Format AMR, monocanal, 8 KHz. Codé en mode Base64. S’applique uniquement aux messages MMS. |
Le service Web OMS est chargé de vérifier si les messages qu’il reçoit dans une chaîne xmsData sont conformes aux limitations définies par le service, et de prendre les mesures nécessaires ou de renvoyer des erreurs en utilisant les codes d’erreur appropriés.
xmsResponse et xmsResponses
DeliverXms() retourne une chaîne au format XML nommée xmsResponse qui contient un ou plusieurs éléments error. Comme pour la chaîne userInfo, un élément error dont l’attribut code a la valeur « ok » et l’attribut severity la valeur « neutral » est utilisé pour indiquer la réussite.
DeliverXmsBatch() retourne une chaîne au format XML nommée xmsResponses qui contient un ou plusieurs éléments xmsResponse d’erreur pour chaque tentative de remise d’élément xmsData dans ce lot.
L’élément error possède deux éléments enfants : content (chaîne contenant une description ou des paramètres de l’erreur) et recipientList (chaîne contenant une liste des destinataires séparés par des points-virgules qui sont affectés par l’erreur).
Au plus, un élément content et un élément recipientList peuvent être définis pour chaque élément d’erreur. L’absence d’un élément recipientList signifie que l’erreur s’applique à tous les destinataires.
Chaque code d’erreur possède deux attributs requis : code et severity. Le code d’erreur ne respecte pas la casse. Les valeurs de gravité possibles sont les suivantes :
La valeur « neutral » est la valeur par défaut, ce qui signifie soit que l’envoi a réussi, soit que le service envoie un message sans erreur au client OMS.
La valeur « failure » signifie que le message n’a pas été remis à un ou plusieurs destinataires.
Vous trouverez ci-après des notes sur l’utilisation de l’élément error et de l’attribut severity :
Si l’élément error n’est pas inclus dans la chaîne xmsResponse, le client OMS suppose qu’une erreur « failure » s’est produite.
Si l’élément error sans l’attribut code est inclus dans une chaîne xmsResponse, le client OMS suppose qu’une erreur « failure » inconnue s’est produite.
Si l’élément error sans l’attribut severity est inclus dans une chaîne xmsResponse, le client OMS suppose que la gravité est « neutral ».
Si plusieurs codes d’erreur sont retournés, l’erreur ayant la gravité la plus élevée décide si le client OMS doit générer une notification d’échec de remise et l’envoyer à l’utilisateur. S’il y a une ou plusieurs erreurs de type « failure », le client OMS génère une notification d’échec de remise qui notifie à l’utilisateur que le message n’a pas été remis.
Vous trouverez ci-après des exemples de chaînes xmsResponse.
Exemple de chaîne xmsReponse indiquant que le message a été envoyé correctement
<?xml version="1.0" encoding="utf-8"?>
<xmsResponse xmlns="https://schemas.microsoft.com/office/Outlook/2006/OMS">
<error code="ok" severity="neutral"/>
</xmsResponse>
Exemple de chaîne xmsReponse avec une erreur de type « failure »
<?xml version="1.0" encoding="utf-8"?>
<xmsResponse xmlns="https://schemas.microsoft.com/office/Outlook/2006/OMS">
<error code="perDayMsgLimit" severity="failure">
<content>20 SMS</content>
<recipientList>13601391354;13601391388</recipientList>
</error>
</xmsResponse>
Exemple de chaîne xmsResponses retournée par DeliverXmsBatch()
<?xml version="1.0" encoding="utf-8"?>
<xmsResponses xmlns="https://schemas.microsoft.com/office/Outlook/2006/OMS">
<xmsResponse id="0">
<error code="ok" severity="neutral" />
<error code="serviceupdate" severity="neutral">
<content>2008-08-28T08:59:10Z</content>
</error>
</xmsResponse>
<xmsResponse id="1">
<error code="ok" severity="neutral" />
<error code="serviceupdate" severity="neutral">
<content>2008-08-28T08:59:11Z</content>
</error>
</xmsResponse>
</xmsResponses>
Redirection de l’URL du service Web.
Si l’URL exacte au service Web OMS n’a pas été spécifiée, la redirection de l’URL vers l’URL du service Web réel pour OMS est fournie aux clients OMS. Pour obtenir l’URL réelle du service Web, le client OMS envoie d’abord une demande HTTP POST vide au service Web suivie d’une demande SOAP, puis appelle DeliverXms(), DeliverXmsBatch() et GetUserInfo() avec une chaîne vide comme paramètre. Le service Web doit traiter de tels appels ou demandes HTTP POST vides comme des demandes standard et les ignorer.
Empaquetage des messages mobiles entrants
Pour permettre la communication bidirectionnelle des messages mobiles entre Outlook et un téléphone mobile, le service Web OMS doit empaqueter la réponse envoyée depuis un téléphone mobile dans un message électronique SMTP au format MIME (Multipurpose Internet Mail Extensions) avec une classe de contenu définie par OMS. Le service Web OMS envoie ensuite les messages électroniques à une adresse de messagerie désignée par l’utilisateur. Lorsqu’Outlook reçoit les messages électroniques SMTP, il reconnaît la classe de contenu et la traite comme un message mobile.
La figure 2 et la figure 3 proposent des exemples de réponses SMS et MMS codées dans des messages électroniques au format MIME. Les sections suivantes décrivent les étapes requises pour empaqueter des messages mobiles en tant que messages électroniques.
En-têtes de message
Lorsque vous codez une réponse dans un message électronique, définissez les en-têtes SMTP comme décrit dans les sections suivantes de sorte que le client OMS puisse identifier correctement les messages électroniques entrants comme provenant d’un téléphone mobile.
Content-Class
Attribuez à l’en-tête de message « Content-class » l’une des valeurs suivantes :
Classe de contenu de message SMS : MS-OMS-SMS
Classe de contenu de message MMS : MS-OMS-MMS
Lorsqu’Outlook reçoit des messages électroniques avec ces classes de contenu, il les identifie comme messages texte ou multimédias et affiche des icônes spécifiques. Si vous ouvrez, transférez ou répondez à ces messages, ces derniers sont automatiquement traités comme des messages mobiles.
Pour vous assurer que le client affiche correctement les messages mobiles entrants empaquetés sous forme de messages électroniques, définissez le jeu de caractères approprié pour tous les en-têtes contenant du texte non-US ASCII et des parties MIME dont le type d’élément multimédia est « text ».
X-MS-Reply-To-Mobile
Ajoutez l’en-tête suivant pour transmettre spécifiquement le numéro mobile de l’expéditeur :
X-MS-Reply-To-Mobile:
L’en-tête doit être un numéro de téléphone mobile valide.
Voici l’exemple d’un en-tête X-MS-Reply-To-Mobile (les deux premiers chiffres du numéro mobile représentent le code du pays) :
X-MS-Reply-To-Mobile:+8613601391354
To
La valeur du champ To est une adresse de messagerie fournie par l’utilisateur pour recevoir les messages mobiles entrants :
To: someone@example.com
From
La valeur du champ From est l’adresse de messagerie utilisée pour envoyer la réponse. Les fournisseurs de services OMS doivent fournir une adresse SMTP unique à chaque abonné pour renvoyer les réponses. Le champ From doit ressembler à ce qui suit :
From: userid.spmail@spdomain.com
Subject
Si le message électronique de réponse concerne un message SMS entrant, la valeur recommandée du champ Subject est soit les 40 premiers caractères (plus ou moins) du corps du message SMS, soit la première ligne du message SMS (si le corps de message comprend plusieurs lignes).
Si le message électronique de réponse concerne un message MMS entrant, définissez le Subject du message électronique comme Subject du message MMS. Étant donné que les messages MMS ne peuvent pas être entièrement affichés dans le volet de visualisation d’Outlook, ajoutez un commentaire au Subject du message MMS pour rappeler aux utilisateurs d’afficher le contenu du message en ouvrant le message, comme indiqué dans l’exemple suivant :
Subject of MMS Message (Open the message to view content)
Corps du message
Message SMS entrant
Pour composer le corps du message pour un message SMS entrant, comme illustré à la figure 2, créez une partie MIME en texte brut pour le contenu du message SMS en ajoutant les en-têtes suivants :
Content-Type: text/plain; charset=xxxx
Content-Transfer-Encoding: quoted-printable
« us-ascii » (ASCII) et « gb2312 » (Chinois simplifié) sont des exemples de valeurs charset valides. Les fournisseurs de services peuvent également utiliser un type de contenu multipart/alternative et fournir une vue HTML du corps du message.
Figure 2. Exemple de message SMS entrant empaqueté sous forme de message électronique
From: "Mobile Inbound Agent" incomingmessage@example-service-provider.com To: someone@example.com Subject: Ceci est un message texte Date: Lundi 7 novembre 2005 17:52:00 +0800 Content-class: MS-OMS-SMS X-MS-Reply-to-mobile: +8613601391354 MIME-Version: 1.0 Content-Type: text/plain; charset="gb2312" Content-Transfer-Encoding: quoted-printable Ceci est un message texte d’un téléphone mobile répondant à un message texte Outlook. |
Message MMS entrant
Lorsque vous composez le corps du message pour des messages MMS entrants, respectez la norme 3GPP pour coder les messages MMS en tant que messages électroniques SMTP au format MIME.
Si SMIL est disponible, composez le corps MIME en tant que multipart/related :
Content-Type: multipart/related; type="application/smil";
La première partie MIME du fichier SMIL doit être :
Content-Type: application/smil; name = "mmspresent.smil"
Les parties multimédias du message MMS doivent être codées en tant que parties MIME avec les types d’éléments multimédias correspondants suivant le fichier SMIL.
Si SMIL n’est pas disponible, composez le corps MIME en tant que multipart/mixed :
Content-type: multipart/mixed
Codez les parties multimédias du message MMS en tant que parties MIME avec les types multimédias correspondants. La figure 3 est un exemple de message MMS codé au format MIME.
Figure 3. Exemple de message MMS entrant empaqueté sous forme de message électronique
From: "Mobile Inbound Agent" incomingmessage@example-service-provider.com To: someone@example.com Subject: Message multimédia (ouvrir le message pour en afficher le contenu) Date: Lundi 7 novembre 2005 17:52:00 +0800 Content-class: MS-OMS-MMS X-MS-Reply-to-mobile: +8613601391354 MIME-Version: 1.0 Content-Type: multipart/related; type="application/smil"; boundary="--------------Boundary=_thisisboundary" Ceci est un message en plusieurs parties au format MIME. --------------Boundary=_thisisboundary Content-Type: application/smil; name="mmspresent.smil" Content-Location: ”mmspresent.smil” Content-Transfer-Encoding: Base64 PHNtaWw+… 1pbD4= --------------Boundary=_thisisboundary Content-Type: text/plain; name="textpart.txt" Content-Transfer-Encoding: Base64 Content-Location: textpart.txt 6Zi/5YWs5Y+45rOV5b6L5biI6IyD5Zu057uV6YGT6LCi --------------Boundary=_thisisboundary Content-Type: image/gif; name="imagepart.gif" Content-Transfer-Encoding: Base64 Content-Location:imagepart.gif R0lGODlheABaAPf/…BDQi6j4uQAxwcixRzZErI5ROjfvSHJcmRMGBAAOw== --------------Boundary=_thisisboundary Content-Type: audio/midi; name="audiopart.mid" Content-Transfer-Encoding: Base64 Content-Location: audiopart.mid TVRoZAAAAAY…XBDfwA/fwA6f4dAOgAAPwAAQwAA/y8A --------------Boundary=_thisisboundary |
Sécurité de la connexion
Pour protéger les informations lors de leur transfert sur Internet, les services Web OMS doivent prendre en charge le chiffrement SSL (Secure Socket Layer). SSL peut être utilisé pour établir des connexions plus sécurisées sur des réseaux non approuvés, tels qu’Internet. SSL autorise le chiffrement et le déchiffrement des messages échangés entre le client et le serveur, empêchant de ce fait la lecture des messages pendant le transfert.
Conclusion
Cet article présente l’architecture du service Web OMS et définit et explique les interfaces entre le service Web OMS et le client OMS. Pour obtenir des instructions sur l’hébergement d’un service Web OMS, voir Instructions sur Office Mobile Service 2010 (Partie 2/3). Pour le schéma XML et le WSDL pour les services Web OMS, voir Instructions relatives à Office 2010 Mobile Service (partie 3/3).
Ressources supplémentaires
Pour plus d’informations, consultez les ressources suivantes :