Vue d’ensemble du développement d’une messagerie mobile

Article
09/24/2014

Dernière modification : mercredi 14 avril 2010

S’applique à : SharePoint Foundation 2010

Cette rubrique donne une vue d’ensemble de l’ajout de fonctionnalités de messagerie mobile à un projet de développement Microsoft SharePoint Foundation à l’aide des API de messagerie mobile du Kit de développement logiciel (SDK) SharePoint Foundation. Ces API peuvent être divisées en deux groupes : un groupe qui prend en charge la messagerie SMS (Short Message Service) à l’aide du protocole de communication OMS (Office Mobile Service) et un autre qui permet d’assurer la prise en charge d’autres protocoles de structure de message ou de communication. Dans la plupart des scénarios de développement, l’expéditeur des messages est l’application Web SharePoint Foundation et non pas un utilisateur en particulier. Le déploiement SharePoint Foundation doit donc avoir un compte auprès d’un fournisseur de service de messagerie mobile (MSP) qui prend en charge le protocole de communication utilisé par votre solution.

Le protocole OMS (Office Mobile Service) est un protocole de communication qui fournit une implémentation des protocoles de structure de message SMS et MMS (Multimedia Message Service). Le protocole OMS nécessite le protocole SOAP pour l’accès au service Web. Les API prenant en charge le protocole OMS décrites dans la section Solutions de messagerie OMS-SMS ci-dessous ont été conçues pour la messagerie SMS. Les classes ou les membres contenus dans l’espace de noms Microsoft.SharePoint.MobileMessage et dont le nom contient « MMS » ou qui sont adaptés au contexte de la message MMS sont destinés uniquement à un usage interne et ne doivent pas être appelés à partir de votre code. Pour développer des solutions de messagerie qui n’utilisent pas le protocole OMS en tant que protocole de communication ou qui l’utilisent pour les messages MMS, employez le niveau le plus abstrait des API traité dans la section Développement de solutions pour d’autres protocoles ci-dessous.

Solutions de messagerie OMS-SMS

SharePoint Foundation fournit des API qui effectuent tous les appels de méthode Web OMS, ainsi que toutes les analyses et les écritures de code XML à votre place. Votre code doit simplement appeler les API dans une syntaxe orientée objet.

Création d’un compte auprès d’un MSP pour une application Web

Chaque application Web SharePoint Foundation, notamment l’application Web Administration centrale, peut avoir un compte auprès d’un fournisseur de service de messagerie mobile (MSP). Ces comptes sont normalement définis par un administrateur de la batterie de serveurs dans la section Gestion des applications de l’application Administration centrale. Vous avez toutefois la possibilité de créer un compte et de l’affecter par programme à une application Web. Tout d’abord, vous devez appeler un constructeur SPMobileMessagingAccount() qui ne nécessite pas de paramètre SPMobileMessageServiceProvider. Vous devez ensuite appeler la méthode UpdateSmsAccount(SPMobileMessagingAccount) pour affecter le compte à une application Web. Dans l’extrait de code ci-après, webApp est une référence à un objet SPWebApplication. (Pour plus d’informations sur l’obtention d’une référence à ce type d’objet, voir Obtention de références aux sites, applications Web et autres objets clés.) L’extrait de code suppose que le fichier possède des instructions using pour Microsoft.SharePoint et System.Security. Notez que l’appel à UpdateSmsAccount(SPMobileMessagingAccount) est transmis en tant que délégué anonyme à la méthode RunWithElevatedPrivileges(SPSecurity.CodeToRunElevated).

SecureString password = new SecureString();
password.AppendChar(‘a’);
password.AppendChar(‘Z’);
password.AppendChar(‘3’);
password.AppendChar(‘&’);

SPMobileMessagingAccount account = new SPMobileMessagingAccount("Contoso Messaging",
                                                                "https://contoso.com/services/mobilemessages",
                                                                 "BobG",
                                                                 password);

SPSecurity.RunWithElevatedPrivileges(delegate() {webApp.UpdateSmsAccount(account);
                                                 webApp.Update();});

Dim password As New SecureString()
        password.AppendChar("a")
        password.AppendChar("z")
        password.AppendChar("3")
        password.AppendChar("&")

        Dim account As New SPMobileMessagingAccount("Contoso Messaging", "https://contoso.com/services/mobilemessages", "BobG", password)


        SPSecurity.RunWithElevatedPrivileges(Sub()
                                                 webApp.UpdateSmsAccount(account)
                                                 webApp.Update()
                                             End Sub)

Une fois le compte auprès d’un MSP affecté à l’application Web, votre code peut utiliser la propriété OutboundSmsServiceAccount en tant que référence à l’objet de compte de l’application Web.

Création d’un objet de service Web

Lorsque vous disposez d’un SPMobileMessagingAccount, votre code peut l’utiliser pour créer un objet SPMobileMessageWebService contenant les méthodes pour l’envoi des messages SMS. Dès que vous obtenez une référence à un objet SPMobileMessagingAccount persistant, il est recommandé de toujours vérifier qu’il n’a pas la valeur null et que sa propriété IsValidAccount() a la valeur true. L’extrait de code ci-après illustre la création d’un objet de service Web. webApp est une référence à un objet SPWebApplication.

SPMobileMessagingAccount account = webApp.OutboundSmsServiceAccount;
if (account == null || !account.IsValidAccount())
{
    throw new SPException("The account passed in is invalid.");
}
else
{
    SPMobileMessageWebService messagingWebService = new SPMobileMessageWebService(account);
}

Dim account As SPMobileMessagingAccount = webApp.OutboundSmsServiceAccount
If account Is Nothing OrElse (Not account.IsValidAccount()) Then
    Throw New SPException("The account passed in is invalid.")
Else
    Dim messagingWebService As New SPMobileMessageWebService(account)
End If

Création et envoi d’un message mobile

La création et l’envoi du message constitue les deux tâches essentielles suivantes.

Création d’un message

Avec un objet SPMobileMessageWebService, votre code peut appeler les méthodes Web OMS du service à l’aide des méthodes de l’objet en tant que proxies. La méthode la plus importante parmi celles-ci est SendMessage(String). Avant de pouvoir l’appeler, votre code doit toutefois créer le message. Pour ce faire, il existe trois méthodes.

Votre code peut appeler la méthode BuildSmsMessage(SPMobileMessagingAccount, String, String) statique et lui transmettre les paramètres du compte de l’expéditeur, un destinataire et le texte du message. Il s’agit de la méthode la plus simple et la moins souple.
Votre code peut appeler l’une des surcharges de SetTextContent(). Cela vous demande de construire d’abord SPMobileMessageSmsBuilder, d’ajouter des destinataires avec des appels de la méthode AddRecipient(String) et de convertir également le message depuis l’objet SPMobileSmsMessage créé par SetTextContent() pour le code XML de message du protocole OMS. Cette méthode de création de message vous offre toutefois la possibilité d’avoir plusieurs destinataires. Elle vous permet également de définir une limite inférieure en ce qui concerne le nombre de pages enfants à celle imposée par le fournisseur de services (ContentParts).
Votre code peut créer une transaction de création de message. Une telle transaction se compose des éléments suivants :
1. un appel de StartTextMessage() ;
2. un ou plusieurs appels de AddChunk(String) ;
3. un appel de l’une des surcharges de EndTextMessage().
Cette méthode de création de message offre tous les possibilités et tous les inconvénients de la méthode précédente. Elle permet toutefois de contrôler davantage la division du message en pages ainsi que d’autres options comme ajouter des numéros de page.

Quelle que soit la méthode utilisée, si un message dépasse la limite du fournisseur de services en ce qui concerne le nombre de caractères, l’algorithme de construction du message tente de le diviser en plusieurs messages, c’est-à-dire en plusieurs « fragments » de texte. Un fragment de texte est une suite de caractères qui doivent rester regroupés dans un seul message, si possible. La série de messages obtenue est ainsi plus cohérente que si le message parent avait été divisé arbitrairement en parts égales. Si un fragment spécifique dépasse la limite de caractères, il est divisé. Seule la troisième méthode de création d’un message permet à votre code d’avoir un contrôle sur le fractionnement du message. L’extrait de code ci-après illustre cette troisième méthode. Notez les remarques suivantes concernant cet exemple :

account est une référence à un objet SPMobileMessagingAccount.
Bien qu’il n’y ait qu’un seul appel de AddRecipient(String), vous pouvez l’appeler plusieurs fois pour envoyer le même message à plusieurs destinataires, jusqu’à la limite imposée par le MSP.
SplitLongMessage est défini dans le bloc de code qui suit ci-après.
message est un objet String qui contient le message.
Lorsque la transaction de création du message est terminée, l’objet SPMobileMessageSmsBuilder contient le message dans sa propriété Message.

SPMobileMessageSmsBuilder smsBuilder = new SPMobileMessageSmsBuilder(account);
smsBuilder.AddRecipient(mobile_telephone_number);

// Begin the message building transaction
smsBuilder.StartTextMessage();

// Add the message text, split as needed into chunks.
List<StringBuilder> messageParts = SplitLongMessage(message)
foreach (StringBuilder chunk in messageParts)
{
    smsBuilder.AddChunk(chunk.ToString());
}

// Finish the transaction
smsBuilder.EndTextMessage();

// At this point, the smsBuilder.Message property holds the message as an SPMobileSmsMessage object.

Dim smsBuilder As New SPMobileMessageSmsBuilder(account)
smsBuilder.AddRecipient(mobile_telephone_number)

' Begin the message building transaction
smsBuilder.StartTextMessage()

' Add the message text, split as needed into chunks.
Dim messageParts As List(Of StringBuilder) = SplitLongMessage(message)
For Each chunk As StringBuilder In messageParts
    smsBuilder.AddChunk(chunk.ToString())
Next

' Finish the transaction
smsBuilder.EndTextMessage()

' At this point, the smsBuilder.Message property holds the message as an SPMobileSmsMessage object

La méthode SplitLongMessage implémente un algorithme simple pour s’assurer qu’aucun fragment de message ne dépasse la limite SMS de 133 caractères (codés sur un octet) pour chaque fragment d’un message SMS concaténé, également appelé « message SMS long ». De plus, elle veille à ce que les fractionnements soient toujours effectués au niveau des espaces de sorte qu’aucun mot ne soit coupé entre les parties du message. Un algorithme plus complexe est nécessaire si votre solution de messagerie mobile ne peut garantir que tous les caractères du message seront codés sur un octet.

public static List<StringBuilder> SplitLongMessage(String message)
{
    // Split the original message at white space.
    String[] words = message.Split(null);

    List<StringBuilder> chunks = new List<StringBuilder>();
    StringBuilder latestChunk = new StringBuilder(132);

    // Reconstruct the message in chunks of up to 133 characters.
    foreach (String word in words)
    {
        if (word.Length + latestChunk.Length <= 132) //Not 133 because a space will be added
        {
            latestChunk.Append(word + " "); // Add back the white space
        }
        else
        {
            // Add a copy of the chunk to the list
            chunks.Add(new StringBuilder(latestChunk.ToString()));

            // Empty out latest chunk so the next one can be started
            latestChunk.Remove(0, latestChunk.Length);

            // The word that exceeded the limit becomes the first word of the next chunk
            latestChunk.Append(word + " ");
        }
    }

    // Add the last short chunk
    if (latestChunk.Length > 0)
    {
        chunks.Add(latestChunk);
    }

    return chunks;
}

Public Shared Function SplitLongMessage(ByVal message As String) As List(Of StringBuilder)
    ' Split the original message at white space.
    Dim words() As String = message.Split(Nothing)

    Dim chunks As New List(Of StringBuilder)()
    Dim latestChunk As New StringBuilder(132)

    ' Reconstruct the message in chunks of up to 133 characters.
    For Each word As String In words
        If word.Length + latestChunk.Length <= 132 Then 'Not 133 because a space will be added
            latestChunk.Append(word & " ") ' Add back the white space
        Else
            ' Add a copy of the chunk to the list
            chunks.Add(New StringBuilder(latestChunk.ToString()))

            ' Empty out latest chunk so the next one can be started
            latestChunk.Remove(0, latestChunk.Length)

            ' The word that exceeded the limit becomes the first word of the next chunk
            latestChunk.Append(word & " ")
        End If
    Next word

    ' Add the last short chunk
    If latestChunk.Length > 0 Then
        chunks.Add(latestChunk)
    End If

    Return chunks
End Function

Que vous créiez l’objet SPMobileSmsMessage (référencé dans la propriété SPMobileMessageBuilder.Message) à l’aide d’un appel de SetTextContent() ou d’une transaction de création de message, votre code doit convertir cet objet en code XML de message au format OMS. Cette conversion est effectuée au moyen d’un appel de la méthode GetMessageXml(). Cette étape d’écriture de code supplémentaire n’est pas nécessaire si vous créez votre message à l’aide d’un appel de la méthode BuildSmsMessage(SPMobileMessagingAccount, String, String), car il renvoie le code XML du message.

String messageXml = smsBuilder.GetMessageXml();

Dim messageXml As String = smsBuilder.GetMessageXml()

Envoi d’un message

Un message est envoyé en transmettant le code XML complet du message compatible OMS à la méthode SendMessage(String) d’un objet SPMobileMessageWebService. Pour plus d’informations sur la création d’un tel objet, voir la section Création d’un objet de service Web ci-dessus. Dans l’extrait de code ci-après, messagingWebService est un objet SPMobileMessageWebService, et messageXml est le message compatible OMS complet.

SPMobileMessageDeliveryReport report = messagingWebService.SendMessage(messageXml);

Dim report As SPMobileMessageDeliveryReport = messagingWebService.SendMessage(messageXml)

Le rapport renvoyé par SendMessage(String) contient des informations indiquant si le message a été correctement envoyé et, si ce n’est pas le cas, la raison de cet échec. Il est recommandé d’inclure du code qui traite le rapport, enregistre les messages ayant réussi dans un journal et répond aux échecs. Pour plus d’informations sur la structure du rapport, voir SPMobileMessageDeliveryReport.

Envoi des lots de messages

Si votre solution utilise les envois par lots, votre code doit stocker les messages créés entre les traitements par lots dans une structure de type file d’attente qui peut être vidée lorsque le lot est envoyé, par exemple List<T><SPMobileSmsMessage>. Le traitement par lots commence par la création d’un objet SPMobileMessageBatchPackage auquel chaque objet de message est ajouté. Le package est ensuite transmis à la méthode BatchSendMessages(SPMobileMessageBatchPackage).

Dans l’extrait de code ci-après, messageCollection est un objet List<T><SPMobileSmsMessage> et messagingWebService, un objet SPMobileMessageWebService. Pour plus d’informations sur la création d’un tel objet, voir la section Création d’un objet de service Web ci-dessus.

SPMobileMessageBatchPackage package = new SPMobileMessageBatchPackage();

foreach (SPMobileSmsMessage message in messageCollection)
{
    package.AddMessage(message);
}

List<SPMobileMessageDeliveryReport> reports = messagingWebService.BatchSendMessages(package);

Dim package As New SPMobileMessageBatchPackage()

For Each message As SPMobileSmsMessage In messageCollection
    package.AddMessage(message)
Next message

Dim reports As List(Of SPMobileMessageDeliveryReport) = messagingWebService.BatchSendMessages(package)

Notez qu’il n’est pas nécessaire de convertir de façon explicite les objets SPMobileSmsMessage qui se trouvent dans le package en messages XML compatibles OMS. Le package renvoie tout le code XML du programme de traitement par lots dans sa propriété Xml. C’est ce code XML que la méthode BatchSendMessages(SPMobileMessageBatchPackage) envoie au service Web de messagerie.

Il est recommandé d’inclure du code qui traite la liste des rapports renvoyée par la méthode BatchSendMessages(SPMobileMessageBatchPackage), qui enregistre les messages ayant réussi dans un journal et qui répond aux échecs.

Autres méthodes de service Web

La classe SPMobileMessageWebService comporte deux autres méthodes, GetUserInfo(String) et GetServiceInfo(), qui jouent le rôle de proxies pour les méthodes Web OMS GetUserInfo et GetServiceInfo, respectivement.

Développement de solutions pour d’autres protocoles

Microsoft ne prend pas en charge la dérivation des classes de Microsoft.SharePoint.MobileMessage pour créer une solution de messagerie mobile n’utilisant pas le protocole OMS. Si vous souhaitez que votre solution fonctionne avec un fournisseur MSP n’utilisant pas le protocole OMS, vous devez envisager de créer un service Web jouant le rôle de couche intermédiaire entre les API de messagerie mobile SharePoint Foundation et le MSP qui utilise un autre protocole. Le service accepterait les messages de protocole OMS de SharePoint Foundation et les transformerait en messages adéquats pour le MSP utilisant l’autre protocole.

Partager via