Erweitern Minimieren

Richtlinien für Office 2010 Mobile Service (Teil 1 von 3)

Office 2010

Zusammenfassung:   In diesem Thema wird das Erstellen und Hosten von Webdiensten für Microsoft Office 2010 Mobile Service (OMS) erläutert. In diesem Artikel wird die OMS-Architektur und der OMS-Nachrichtenfluss vorgestellt, und es werden die Kommunikationsprotokolle zwischen OMS-Clients und Webdiensten erläutert. Beachten Sie, dass Office Mobile Service in Office 2010 die aktualisierte Version von Outlook Mobile Service in Microsoft Office System 2007 ist. (20 gedruckte Seiten)

Letzte Änderung: Donnerstag, 7. April 2011

Gilt für: 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

Inhalt dieses Artikels
Einführung in Office Mobile Service
Architektur und Nachrichtenfluss
Kommunikationsprotokolle
Webdienst-URL-Umleitung
Zusammenfassen von eingehenden Mobiltelefonnachrichten
Schlussbemerkung
Weitere Ressourcen

Inhalt

Microsoft Office 2010 Mobile Service (OMS) ist die für Microsoft Outlook 2010 und Microsoft SharePoint 2010 entwickelte Messagingkomponente. Mit OMS können Benutzer die mobilen Funktionen von Outlook und SharePoint nahtlos in ihre mobilen Geräte integrieren.

Dank der von OMS bereitgestellten mobilen Messagingfunktionalität können Benutzer folgende Aktionen ausführen:

  • Erstellen neuer Textnachrichten und Multimedianachrichten in Outlook.

  • Weiterleiten von Outlook-Elementen (einschließlich E-Mail-Nachrichten, Besprechungen und Kontakten) als Text- oder Multimedianachricht.

  • Empfangen von Antworten von mobilen Geräten und Nutzen einer zweiseitigen Kommunikation zwischen Outlook und Mobiltelefonen.

  • Empfangen von SharePoint-Benachrichtigungstexten auf Mobiltelefonen.

  • Erweitern der Messagingfunktionen von Outlook und SharePoint-OMS über das bereitgestellte Objektmodell.

Office Mobile Service in Outlook

Mit den von OMS bereitgestellten Funktionen zur Elementumleitung können Benutzer nicht nur Text- und Multimedianachrichten in Outlook erstellen und senden, sondern sie können Erinnerungen, E-Mail-Nachrichten und den Terminplan des nächsten Tags automatisch an ein Mobiltelefon umleiten, indem sie einfache Bedingungen festlegen. Zudem können E-Mail-Nachrichten, Termine und Besprechungsanforderungen an Mobiltelefone und andere E-Mail-Adressen gesendet werden.

Da OMS in den Outlook-Kontoeinstellungen enthalten ist, ist eine nahtlose Integration möglich, sodass die Benutzer mobile Messagingkonten parallel mit E-Mail-Konten verwalten können. Mobiltelefonnummern werden wie eine Art Adresse behandelt, und Benutzer können einer Mobiltelefonnachricht Empfänger hinzufügen, indem sie AutoVervollständigen verwenden oder Namen direkt aus dem Outlook-Adressbuch auswählen. Zudem können die Benutzer Mobiltelefonnachrichten in Outlook-Ordnern speichern und verwalten.

Vom OMS-Client, der in Outlook und SharePoint integriert ist, werden Text- und Multimedianachrichten an einen Webdienst gesendet, der von Partnern erstellt und gehostet wird, die entweder Netzbetreiber oder Inhaltsdienstanbieter von Mobiltelefonnachrichten sind. Die Nachricht wird dann vom Webdienst an ein Service Center des Netzbetreibers für Textnachrichten oder Multimedianachrichten gesendet.

Office Mobile Service in SharePoint 2010

In SharePoint 2010 kann ein Benutzer Warnungen in Form von Textnachrichten (SMS) über OMS empfangen. Der Benutzer kann über den Status von Dokumenten oder SharePoint-Listen informiert werden und Textnachrichten mit Änderungen sowie bei Bedarf mit der URL des Dokuments oder der Liste empfangen.

Zusätzliche Informationen

Dies ist der erste Teil einer dreiteiligen Serie von Artikeln, in denen OMS vorgestellt wird und Richtlinien und Verweisinformationen zum Verwenden des Diensts bereitgestellt werden. Empfehlungen zum Implementieren eines OMS-Webdiensts finden Sie unter Richtlinien für Office 2010 Mobile Service (Teil 2 von 3). Informationen zum XML-Schema für Daten, die zwischen OMS-Webanbietern und OMS-Clients übergeben werden, finden Sie unter Richtlinien für Office 2010 Mobile Service (Teil 3 von 3).

Die Leser dieses Artikels sollten mit dem Entwickeln und Bereitstellen von Webdiensten vertraut sein. Allgemeine Informationen zu Webdiensten finden Sie unter Webdienste. Weitere Informationen zum Entwickeln von Webdiensten finden Sie in der Dokumentation, die mit Ihrem Entwicklungstool bereitgestellt wurde.

Die Gesamtarchitektur von OMS besteht aus einem auf Webdiensttechnologie basierenden Clientdienstframework. Der in Outlook oder SharePoint integrierte OMS-Client codiert eine Mobiltelefonnachricht als SOAP-Nachricht und sendet diese an den OMS-Webdienst, wo sie dann codiert und an die Gateway für Mobiltelefonnachrichten des Netzbetreibers übermittelt wird. Die Nachricht wird dann über die Funknetzwerke des Netzbetreibers an das angegebene Mobiltelefon eines Benutzers übermittelt. Der OMS-Webdienst wird von einem Dienstanbieter erstellt und gehostet, der entweder ein Mobiltelekommunikationsbetreiber oder -aggregator ist (Internetinhaltsanbieter, Internetdienstanbieter oder ein Drittanbieter, der einen Mobilfunkdienst bereitstellt). Die OMS-Webdienstspezifikation und Kommunikationsprotokolle zwischen dem OMS-Client und dem Webdienst sind im Abschnitt Kommunikationsprotokolle in diesem Artikel beschrieben.

Zurzeit werden Mobiltelefonnachrichten nur einseitig von SharePoint 2010 an einen OMS-Webdienst übermittelt, in Outlook ist jedoch eine zweiseitige Kommunikation mit dem OMS-Webdienst möglich. Nachrichten können wie in Abbildung 1 dargestellt zwischen Outlook und dem Mobiltelefon des Empfängers über den OMS-Webdienst und die Infrastruktur des Netzbetreibers hin und her fließen. Antworten vom Mobiltelefon des Empfängers können in das Outlook-Postfach, an das mobile Gerät des Absenders oder je nach Benutzereinstellungen an beides gesendet werden. Zur Übermittlung der Antworten an das Outlook-Postfach des Benutzers fasst der Dienstanbieter diese in SMTP-E-Mail-Nachrichten (Simple Mail Transfer Protocol) gemäß der von Microsoft definierten Spezifikation zusammen (siehe Abschnitt Zusammenfassen von eingehenden Mobiltelefonnachrichten in diesem Artikel).

Abbildung 1. Meldungsfluss für Office Mobile Service in Outlook

Architektur und Nachrichtenfluss

Beim Entwickeln eines OMS-Webdiensts müssen mehrere Regeln befolgt werden. Erstens muss der OMS-Webdienst der Web Services Description Language (WSDL) folgen. Dadurch kann der OMS-Client eine Verbindung mit dem Dienst herstellen, ohne dass eine dienstspezifische Codeänderung erforderlich ist.

Zweitens müssen die folgenden Webmethoden vom OMS-Webdienst unterstützt werden:

  • string GetServiceInfo() - Ruft die Eigenschaften des OMS-Webdiensts ab.

  • string GetUserInfo(string xmsUser) - Ruft die Benutzerinformationen ab.

  • string DeliverXms(string xmsData) - Sendet Mobiltelefonnachrichten an den Webdienst.

  • string DeliverXmsBatch(string packageXml) - Sendet mehrere xmsData-Zeichenfolgen in einem Batch an den Webdienst.

Drittens muss der OMS-Webdienst den Richtlinien für das Senden von Mobiltelefonnachrichten an den Outlook-OMS-Client als E-Mail folgen, wie im Abschnitt Zusammenfassen von eingehenden Mobiltelefonnachrichten in diesem Artikel beschrieben.

Hinweis Hinweis

Wenn Sie ein Upgrade des OMS-Webdiensts von Microsoft Office Outlook 2007 ausführen, müssen Sie beachten, dass die SendXms-Webmethode seit Outlook 2007 Service Pack 1 (SP1) in DeliverXms umbenannt wurde. Falls Ihr OMS-Webdienst die RTM-Version von Outlook 2007 sowie Outlook 2007 SP1 oder Outlook 2010 verwenden muss, müssen Sie sowohl SendXms als auch DeliverXms unterstützen, indem Sie dieselbe Definition für SendXms und für DeliverXms angeben. Nachdem alle Abonnenten das Upgrade zu Outlook 2007 SP1 oder Outlook 2010 ausgeführt haben, können Sie die Unterstützung für SendXms einstellen.

Beispiel für die Implementierung eines einfachen Webdiensts

Im folgenden Codebeispiel wird eine vereinfachte Implementierung des OMS-Webdiensts erläutert. Die Methoden GetUserInfo() und GetServiceInfo() geben Informationen und den entsprechenden Fehlercode zurück. Die zurückzugebenden Informationen und Fehlercodes sind als XML-Dateien gespeichert. In diesem Beispiel wird vorausgesetzt, dass eine LoadXmlFromFile(string filename)-Methode erstellt wurde, die die XML-Dateien aus einer Datei laden und das Ergebnis als Zeichenfolge zurückgeben kann, und dass eine private Klasse CUserLogon implementiert worden ist, die Funktionen zur Benutzerüberprüfung bereitstellt.

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="http://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
{
    // ....
};

In den folgenden Abschnitten werden die OMS-Webdienstmethoden ausführlicher erläutert, und es sind auch Beispielcode und Beispiele für XML-formatierte Zeichenfolgen (serviceInfo, userInfo und xmsResponse) vorhanden, die von diesen Methoden oder an diese übergeben werden. Die WSDL für diese Webmethoden und auch die Schemas für die XML-formatierten Zeichenfolgen, die von diesen Methoden oder an diese übergeben werden, sind im letzten Artikel dieser Serie enthalten: Richtlinien für Office 2010 Mobile Service (Teil 3 von 3).

string GetServiceInfo()-Webdienstmethode

Von GetServiceInfo() wird eine XML-formatierte Zeichenfolge mit dem Namen serviceInfo zurückgegeben, die grundlegende Eigenschaften des OMS-Webdiensts enthält, z. B. Angaben zu unterstützten Diensttypen, zu Parametern der unterstützten Dienste und zu Authentifizierungstypen.

Der in Outlook integrierte OMS-Client ruft GetServiceInfo() zum Abrufen der Eigenschaften eines OMS-Webdiensts auf, wenn ein Benutzer ein neues Konto einrichtet, oder zum Aktualisieren von Diensteigenschaften, nachdem der OMS-Webdienst veröffentlicht wurde. Mit diesen Eigenschaften wird der Webdienst von OMS als ein unterstützter Dienstanbieter auf der Clientseite konfiguriert.

Das folgende Codebeispiel zeigt eine von GetServiceInfo() zurückgegebene serviceInfo-Zeichenfolge.

<?xml version="1.0" encoding="utf-8"?>
<serviceInfo 
    xmlns="http://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>

Entwickler sollten auch Folgendes beachten:

  • Die serviceInfo-Zeichenfolge wird als Unicode-Zeichenfolge übergeben und dann als UTF-16 codiert.

  • Der serviceUri-Wert wird zur eindeutigen Identifikation des Diensts verwendet. Falls der serviceUri-Wert eines OMS-Webdiensts geändert wird, behandelt der OMS-Client den Dienst als neuen OMS-Webdienst.

  • Zur Unterstützung langer Textnachrichten kann ein Dienstanbieter die Attribute maxSbcsPerMessage und maxDbcsPerMessage des SMS_SENDER-Elements auf Werte festlegen, die von den meisten von den Abonnenten verwendeten Modellen verwendet werden können.

  • Falls das supportSlide-Attribut des MMS_SENDER-Elements der serviceInfo-Zeichenfolge eines OMS-Webdiensts auf true festlegt ist, wird damit angezeigt, dass der Webdienst das SMIL-Format (Synchronized Multimedia Integration) unterstützt. Eine Nachricht, die SMIL verwendet, befindet sich im Folienmodus. Falls ein OMS-Webdienst, der SMIL nicht unterstützt, eine Nachricht im Folienmodus empfängt, muss der Webdienst entweder einen Fehler vom Typ other zurückgeben oder die Nachricht in einen Nicht-Folienmodus konvertieren.

string GetUserInfo(string xmsUser)-Webdienstmethode

Der in Outlook integrierte OMS-Client ruft die Mobiltelefonnummer und andere Informationen eines Benutzers durch Aufrufen von GetUserInfo() mit einer xmsUser-Zeichenfolge als Parameter ab. xmsUser ist eine XML-formatierte Zeichenfolge mit den Authentifizierungsinformationen des Benutzers, einschließlich Benutzer-ID und Kennwort. Von GetUserInfo() wird eine XML-formatierte Zeichenfolge mit dem Namen userInfo zurückgegeben, die ein error-Element mit dem auf failure festgelegten severity-Attribut enthält. Das Schema für xmsUser ist im letzten Artikel dieser Serie enthalten: Richtlinien für Office 2010 Mobile Service (Teil 3 von 3).

In Tabelle 1 sind Fehlercodes enthalten, die in der Regel in einer userInfo-Zeichenfolge zurückgegeben werden.

Tabelle 1. Durch einen Aufruf von 'GetUserInfo()' zurückgegebene Fehler

Code

Schweregrad

Ok

Neutral

invalidUser

Failure

unregisteredUser

Failure

expiredUser

Failure

Eine vollständige Liste der Fehlercodes, die von einem OMS-Webdienst gesendet werden können, finden Sie im Abschnitt "OMS-Fehlercodes" in Richtlinien für Office 2010 Mobile Service (Teil 3 von 3). Beachten Sie jedoch, dass das userInfo-Schema die in diesem Abschnitt genannten untergeordneten Elemente content oder recipientList nicht enthält. Auch das severity-Attribut ist für einen Fehler in einer userInfo-Zeichenfolge optional, obwohl es in einer xmsResponse-Zeichenfolge erforderlich ist. Falls kein severity-Attribut für ein error-Element in einer userInfo-Zeichenfolge definiert ist, wird vom OMS-Client vorausgesetzt, dass der Schweregrad des Fehlers Neutral ist.

Hinweis Hinweis

Die Zeichenfolgen xmsUser und userInfo werden als Unicode-Zeichenfolgen übergeben und als UTF-16 codiert.

Das folgende Codebeispiel zeigt eine Implementierung der GetUserInfo()-Methode, die ein XmlTextWriter-Objekt zum Schreiben der Benutzerinformationen und des Fehlercodes in eine XML-Zeichenfolge verwendet.


// ...
private const string m_sOmsNamespace = "http://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();
    }
}

Die folgenden Beispiele zeigen die Zeichenfolgen xmsUser und userInfo.

Beispiel für die Zeichenfolge "xmsUser"


<?xml version="1.0" encoding="utf-8"?>
<xmsUser client="Microsoft Office Outlook 12.0" xmlns = "http://schemas.microsoft.com/office/Outlook/2006/OMS">
    <userId>myname</userId>
    <password>mypwd</password>
    <customData/>
</xmsUser>

Beispiel für die Zeichenfolge "userInfo", die von "GetUserInfo()" nach einem erfolgreichen Aufruf zurückgegeben wird


<?xml version="1.0" encoding="utf-8"?>
<userInfo xmlns = "http://schemas.microsoft.com/office/Outlook/2006/OMS">
    <replyPhone>090123456</replyPhone>
        <smtpAddress>userid.spmail@spdomain.com</smtpAddress> 
    <error code="ok"/>
</userInfo> 

Beispiel für die Zeichenfolge "userInfo", die nach einem Fehler zurückgegeben wird


<?xml version="1.0" encoding="utf-8"?>
<userInfo xmlns = "http://schemas.microsoft.com/office/Outlook/2006/OMS">
    <error code="unregistered" severity="failure"/>
</userInfo>

Sehen wir uns nun die Elemente einer userInfo -Zeichenfolge näher an. Das replyPhone-Element enthält die Mobiltelefonnummer, die der Benutzer beim Anmelden am Dienst des Dienstanbieters verwendet hat. Der replyPhone-Wert wird im Dialogfeld mit den Kontoeinstellungen in Outlook als Standardmobiltelefonnummer des Benutzers angezeigt. Der OMS-Client ruft den replyPhone-Wert durch einen Aufruf von GetUserInfo() ab, wenn der Benutzer ein Konto einrichtet. Vom OMS-Client wird darüber hinaus GetUserInfo() aufgerufen, um den replyPhone-Wert eines Benutzers zu aktualisieren, wenn der Benutzer das Konto anzeigt oder ändert und keine Mobiltelefonnummer eingegeben hat, oder wenn der OMS-Webdienst den Client darüber informiert, dass die Dienstinformationen über den Fehlercode serviceUpdate geändert wurde.

In Outlook 2007 wurde das replyPhone-Element als Standardrückrufnummer für einige Märkte verwendet, z. B. Korea, wo eine Rückrufnummer erforderlich ist und unterstützt wird. In Outlook 2010 wird dieses Feature nicht mehr bereitgestellt, und dieses Element ist nicht mehr erforderlich.

Schließlich enthält das smtpAddress-Element eine eindeutige SMTP-Adresse, die der Dienstanbieter für jeden Abonnenten generiert. Der Dienstanbieter verwendet die SMTP-Adresse zum Senden von Antworten von einem Mobiltelefon zurück an Outlook. Das Erstellen eindeutiger SMTP-Adressen ist für jeden Abonnenten des OMS-Diensts erforderlich, damit verhindert werden kann, dass böswillige Benutzer Junk-E-Mail-Nachrichten mithilfe der SMTP-Adresse senden können.

string DeliverXms(string xmsData)-Webdienstmethode

Der in Outlook oder SharePoint integrierte OMS-Client ruft DeliverXms() zum Übermitteln einer Mobiltelefonnachricht an den Dienstanbieter auf. Der Inhalt der Nachricht wird als XML-formatierte Zeichenfolge mit dem Namen xmsData zusammengefasst. Nachdem der Dienstanbieter das Senden der Nachricht versucht hat, wird eine XML-formatierte Zeichenfolge mit dem Namen xmsResponse zurückgegeben, die mindestens ein error-Element enthält, das den Erfolg oder Fehler des Versuchs enthält, die Nachricht an jeden angegebenen Empfänger zu senden.

Das folgende Codebeispiel zeigt eine Implementierung der DeliverXms()-Methode, die ein XmlTextWriter-Objekt zum Schreiben des Erfolgs oder Fehlers für den Aufruf in eine xmsResponse-Zeichenfolge verwendet.

// ...
private const string m_sOmsNamespace = "http://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=\
            "http://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"

Die xmsData-Zeichenfolge ist so konzipiert, dass eine Text- oder Multimedianachricht zusammengefasst wird, d. h., dass Textnachrichten und Multimedianachrichten dasselbe Schema verwenden. In den folgenden Beispielen wird eine xmsData-Zeichenfolge gezeigt, die eine als MMS formatierte Nachricht enthält, und eine xmsData-Zeichenfolge, die eine als SMS formatierte Nachricht enthält.

Beispiel für eine Zeichenfolge "xmsData" mit einer als SMS formatierten Nachricht


<?xml version="1.0" encoding="utf-8"?>
<xmsData client="Microsoft Office Outlook 12.0" xmlns = "http://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>

Beispiel für eine Zeichenfolge "xmsData" mit einer als MMS formatierten Nachricht


<?xml version="1.0" encoding="utf-8"?>
<xmsData client="Microsoft Office Outlook 12.0"xmlns = "http://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>

string DeliverXmsBatch(string packageXml)-Webdienstmethode

Der in SharePoint integrierte OMS-Client ruft DeliverXmsBatch() zum Übermitteln einiger xmsData-Elemente in einer einzelnen XML-Transaktion an den Dienstanbieter auf. Der Inhalt der Nachricht wird als XML-formatierte Zeichenfolge mit dem Namen packageXml zusammengefasst. Nachdem der Dienstanbieter das Senden der Nachricht versucht hat, wird eine XML-formatierte Zeichenfolge mit dem Namen xmsResponses zurückgegeben, die mindestens ein Fehlerelement enthält, das den Erfolg oder Fehler jedes Versuchs enthält, die Nachricht an jeden angegebenen Empfänger zu senden.

Das folgende Codebeispiel zeigt eine Implementierung der DeliverXmsBatch()-Methode, die ein XmlTextWriter-Objekt zum Schreiben des Erfolgs oder Fehlers für den Aufruf in eine xmsResponses-Zeichenfolge verwendet.

// ...
private const string m_sOmsNamespace = "http://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=    
            \"http://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"

Die packageXml-Zeichenfolge ist so konzipiert, dass einige xmsData-Elemente (Textnachrichten oder Multimedianachrichten) in einem XML-Schema zusammengefasst werden. Im folgenden Beispiel wird eine packageXml-Zeichenfolge gezeigt, die zwei als SMS formatierte Nachrichten enthält.

Beispiel für eine Zeichenfolge "packageXml" mit zwei als SMS formatierten Nachrichten

<?xml version="1.0" encoding="utf-8"?>
<xmsBatch client="Microsoft Windows SharePoint Service" xmlns="http://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>

Unterstützte Inhaltstypen

SMS-Nachrichten (Short Message Service) unterstützen den Inhaltstyp text/plain. Von OMS werden die in Tabelle 2 aufgeführten Medienobjekte für MMS-Nachrichten (Multimedia Messaging Service) unterstützt. Auf der Clientseite werden andere Medientypen von OMS bei Bedarf in diese Standardformate konvertiert.

Tabelle 2. Unterstützte Inhaltstypen

Inhalt

MIME-Typ

Beschreibung

Text

text/plain

Nur-Text. Kann sowohl von SMS- als auch von MMS-Nachrichten verwendet werden.

Statisches Bild

image/jpeg

96 DPI. Kleiner oder gleich der Größe des mobilen Bildschirms, die im Element root-layout der xmsData-Zeichenfolge definiert ist. In Base64 codiert. Gilt nur für MMS-Nachrichten.

Bild mit mehreren Frames

image/gif

GIF89a, 96 DPI, maximal 256 Farben. Kleiner oder gleich der Größe des mobilen Bildschirms, die im Element root-layout der xmsData-Zeichenfolge definiert ist. In Base64 codiert. Gilt nur für MMS-Nachrichten.

MIDI-Audioformat

Audio/mid

MIDI-Format. In Base64 codiert. Gilt nur für MMS-Nachrichten.

AMR-Soundformat

Audio/AMR

AMR-Format, einzelner Kanal, 8 KHz. In Base64 codiert. Gilt nur für MMS-Nachrichten.

Vom OMS-Webdienst muss überprüft werden, ob die in einer xmsData-Zeichenfolge empfangenen Nachrichten den vom Dienst festgelegten Einschränkungen entspricht, und es müssen die erforderlichen Aktionen ausgeführt werden oder Fehler mithilfe der entsprechenden Fehlercodes zurückgegeben werden.

"xmsResponse" und "xmsResponses"

Von DeliverXms() wird eine XML-formatierte Zeichenfolge mit dem Namen xmsResponse zurückgegeben, die mindestens ein error-Element enthält. Wie bei der userInfo-Zeichenfolge wird zum Anzeigen eines Erfolgs das error-Element verwendet, für das das code-Attribut auf ok und das severity-Attribut auf neutral festgelegt ist.

Von DeliverXmsBatch() wird eine XML-formatierte Zeichenfolge mit dem Namen xmsResponses zurückgegeben, die mindestens ein xmsResponse-Fehlerelement enthält, für jeden einzigen Übermittlungsversuch des xmsData-Elements in diesem Batch.

Das error-Element besitzt zwei untergeordnete Elemente: content, eine Zeichenfolge mit einer Beschreibung oder den Parametern des Fehlers, und recipientList, eine Zeichenfolge mit einer durch Semikolon getrennten Liste von Empfängern, die von dem Fehler betroffen sind.

Maximal können ein content-Element und ein recipientList-Element für jedes Fehlerelement definiert werden. Das Fehlen eines recipientList-Elements bedeutet, dass der Fehler für alle Empfänger gilt.

Jeder Fehlercode enthält zwei erforderliche Attribute: code und severity. Beim Fehlercode wird die Groß-/Kleinschreibung nicht berücksichtigt. Folgende Werte sind für den Schweregrad möglich:

  • Der Wert neutral ist der Standardwert und gibt entweder einen abgeschlossenen und erfolgreichen Sendevorgang an, oder der Dienst sendet eine Nicht-Fehlermeldung an den OMS-Client.

  • Der Wert failure bedeutet, dass die Nachricht an mindestens einen Empfänger nicht übermittelt werden konnte.

Es folgen einige Hinweise zum Verwenden des error-Elements und des severity-Attributs:

  • Falls das error-Element nicht in der xmsResponse-Zeichenfolge enthalten ist, wird vom OMS-Client vorausgesetzt, dass ein Fehler aufgetreten ist.

  • Falls das error-Element ohne das code-Attribut in einer xmsResponse-Zeichenfolge enthalten ist, wird vom OMS-Client vorausgesetzt, dass ein unbekannter Fehler aufgetreten ist.

  • Falls das error-Element ohne das severity-Attribut in einer xmsResponse-Zeichenfolge enthalten ist, wird vom OMS-Client vorausgesetzt, dass der Schweregrad neutral ist.

  • Falls mehrere Fehlercodes zurückgegeben werden, wird durch den Fehler mit dem höchsten Schweregrad entschieden, ob der OMS-Client einen Unzustellbarkeitsbericht (Non-Delivery Report, NDR) generiert und an den Benutzer sendet. Falls mindestens ein Fehler vom Typ failure vorhanden ist, generiert der OMS-Client einen Unzustellbarkeitsbericht, mit dem der Benutzer darüber informiert wird, dass die Nachricht nicht übermittelt werden konnte.

Im Folgenden finden Sie Beispiele für xmsResponse-Zeichenfolgen:

Beispiel für die Zeichenfolge "xmsReponse", die das erfolgreiche Senden der Nachricht anzeigt


<?xml version="1.0" encoding="utf-8"?>
<xmsResponse xmlns="http://schemas.microsoft.com/office/Outlook/2006/OMS">
    <error code="ok" severity="neutral"/> 
</xmsResponse>

Beispiel für die Zeichenfolge "xmsReponse" mit einem Fehler vom Typ "failure"


<?xml version="1.0" encoding="utf-8"?>
<xmsResponse xmlns="http://schemas.microsoft.com/office/Outlook/2006/OMS">
    <error code="perDayMsgLimit" severity="failure">
        <content>20 SMS</content>
        <recipientList>13601391354;13601391388</recipientList>
    </error> 
</xmsResponse>

Beispiel für die von "DeliverXmsBatch()" zurückgegebene Zeichenfolge "xmsResponses"

<?xml version="1.0" encoding="utf-8"?>
<xmsResponses xmlns="http://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>

Wenn die exakte URL des OMS-Webdiensts nicht angegeben wurde, wird für die OMS-Clients eine Umleitung der URL zur tatsächlichen Webdienst-URL für OMS bereitgestellt. Zum Abrufen der tatsächlichen URL des Webdiensts sendet der OMS-Client zunächst eine leere HTTP POST-Anforderung an den Webdienst gefolgt von einer SOAP-Anforderung, und anschließend werden DeliverXms(), DeliverXmsBatch() und GetUserInfo() mit einer leeren Zeichenfolge als Parameter aufgerufen. Der Webdienst sollte diese leeren HTTP POST-Anforderungen oder Aufrufe als typische Anforderungen behandeln und einfach ignorieren.

Wenn eine zweiseitige Kommunikation für Mobiltelefonnachrichten zwischen Outlook und einem Mobiltelefon möglich sein soll, muss der OMS-Webdienst die von einem Mobiltelefon gesendete Antwort in eine mit MIME (Multipurpose Internet Mail Extensions) formatierte SMTP-E-Mail-Nachricht mit einer OMS-definierten Inhaltsklasse zusammenfassen. Die E-Mail-Nachrichten werden dann vom OMS-Webdienst an eine vom Benutzer angegebene E-Mail-Adresse gesendet. Wenn Outlook die SMTP-E-Mail-Nachrichten empfängt, wird die Inhaltsklasse erkannt und als Mobiltelefonnachricht behandelt.

Abbildung 2 und Abbildung 3 enthalten Beispiele für SMS- und MMS-Antworten, die in als MIME formatierten E-Mail-Nachrichten codiert sind. In den folgenden Abschnitten werden die erforderlichen Schritte für das Zusammenfassen von Mobiltelefonnachricht als E-Mail-Nachrichten beschrieben.

Nachrichtenkopfzeilen

Beim Codieren einer Antwort als E-Mail-Nachricht müssen SMTP-Kopfzeilen wie in den folgenden Abschnitten beschrieben festgelegt werden, sodass der OMS-Client die eingehenden E-Mail-Nachricht ordnungsgemäß als von einem Mobiltelefon gesendet erkennen kann.

"Content-Class"

Legen Sie die Nachrichtenkopfzeile Content-class auf einen der folgenden Werte fest:

  • Inhaltsklasse für SMS-Nachrichten: MS-OMS-SMS

  • Inhaltsklasse für MMS-Nachrichten: MS-OMS-MMS

Wenn E-Mail-Nachrichten mit diesen content-class-Werten von Outlook empfangen werden, werden diese als Text- oder Multimedianachrichten erkannt, und es werden spezifische Symbole für sie angezeigt. Wenn diese Nachrichten geöffnet oder weitergeleitet werden oder auf sie geantwortet wird, werden sie automatisch als Mobiltelefonnachrichten behandelt.

Wenn Sie sicherstellen möchten, dass der Client eingehende Nachrichten, die als E-Mail-Nachrichten zusammengefasst sind, ordnungsgemäß anzeigt, legen Sie den entsprechenden Zeichensatz für alle Kopfzeilen fest, die Nicht-US ASCII-Text und MIME-Teile vom Medientyp text enthalten.

"X-MS-Reply-To-Mobile"

Fügen Sie die folgende Kopfzeile speziell zum Angeben der Mobiltelefonnummer des Absenders hinzu:

X-MS-Reply-To-Mobile:

Die Kopfzeile muss eine gültige Mobiltelefonnummer enthalten.

Es folgt ein Beispiel für eine Kopfzeile vom Typ X-MS-Reply-To-Mobile (die ersten beiden Stellen der Mobiltelefonnummer stellen den Ländercode dar):

X-MS-Reply-To-Mobile:+8613601391354

"To"

Der Wert des To-Felds ist eine E-Mail-Adresse, die der Benutzer zum Empfangen von eingehenden Mobiltelefonnachrichten bereitstellt:

To: someone@example.com

"From"

Der Wert des From-Felds ist die E-Mail-Adresse, die zum Senden der Antwort verwendet wird. OMS-Dienstanbieter müssen eine eindeutige SMTP-Adresse für jeden Abonnenten zum Zurücksenden von Antworten angeben. Das From-Feld sollte in etwa wie im folgenden Beispiel aussehen:

From: userid.spmail@spdomain.com

"Subject"

Falls die als Antwort gesendete E-Mail-Nachricht für eine eingehende SMS-Nachricht gesendet wird, enthält der empfohlene Wert für das Subject-Feld entweder die ersten ca. 40 Zeichen des SMS-Nachrichtentexts oder die erste Zeile der SMS-Nachricht (falls der Nachrichtentext aus mehreren Zeilen besteht).

Falls die als Antwort gesendete E-Mail-Nachricht für eine eingehende MMS-Nachricht gesendet wird, legen Sie den Subject-Wert der E-Mail-Nachricht als den Subject-Wert der MMS-Nachricht fest. Da MMS-Nachrichten nicht vollständig im Vorschaubereich von Outlook angezeigt werden können, fügen Sie einen Kommentar zum Subject-Wert der MMS-Nachricht ein, in dem Sie Benutzer daran erinnern, den Nachrichteninhalt durch das Öffnen der Nachricht wie im folgenden Beispiel gezeigt anzuzeigen:

Subject of MMS Message (Open the message to view content)

Nachrichtentext

Eingehende SMS-Nachricht

Erstellen Sie zum Konstruieren des Nachrichtentexts für eine eingehende SMS-Nachricht wie in Abbildung 2 zu sehen einen MIME-Teil vom Typ Nur-Text für den SMS-Nachrichteninhalt, indem Sie die folgenden Kopfzeilen hinzufügen:

Content-Type: text/plain; charset=xxxx

Content-Transfer-Encoding: quoted-printable

Beispiele für gültige Zeichensatzwerte sind us-ascii (ASCII) und gb2312 (Vereinfachtes Chinesisch). Dienstanbieter können auch einen Inhaltstyp multipart/alternative verwenden und eine HTML-Ansicht des Nachrichtentexts bereitstellen.

Abbildung 2. Beispiel für eine eingehende SMS-Nachricht, die als E-Mail-Nachricht zusammengefasst ist

From: "Mobile Inbound Agent" incomingmessage@example-service-provider.com

To: someone@example.com

Subject: This is a text message

Date: Mon, 7 Nov 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

This is a text message from a mobile phone replying to a text message from Outlook.

Eingehende MMS-Nachricht

Folgen Sie beim Erstellen des Nachrichtentexts für eingehende MMS-Nachrichten dem 3GPP-Standard beim Codieren von MMS-Nachrichten als in MIME formatierte SMTP-E-Mail-Nachrichten.

Falls SMIL verfügbar ist, erstellen Sie den MIME-Text vom Typ multipart/related:

Content-Type: multipart/related; type="application/smil";

Der erste MIME-Teil der SMIL-Datei sollte wie folgt lauten:

Content-Type: application/smil; name = "mmspresent.smil"

Medienteile der MMS-Nachricht sollten als MIME-Teile mit entsprechenden Medientypen auf die SMIL-Datei folgend codiert sein.

Falls SMIL nicht verfügbar ist, erstellen Sie den MIME-Text vom Typ multipart/mixed:

Content-type: multipart/mixed

Codieren Sie Teile der MMS-Nachricht als MIME-Teile mit den entsprechenden Medientypen. Abbildung 3 ist ein Beispiel für eine MMS-Nachricht, die im MIME-Format codiert ist.

Abbildung 3. Beispiel für eine eingehende MMS-Nachricht, die als E-Mail-Nachricht zusammengefasst ist

From: "Mobile Inbound Agent" incomingmessage@example-service-provider.com

To: someone@example.com

Subject: This is a multimedia message (Open the message to view its content)

Date: Mon, 7 Nov 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"

This is a multipart message in MIME format.

--------------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

Verbindungsicherheit

Zum Schutz der Daten bei der Übertragung über das Internet müssen OMS-Webdienste die SSL-Verschlüsselung (Secure Socket Layer) unterstützen. SSL kann zum Herstellen sicherer Verbindungen in nicht vertrauenswürdigen Netzwerken wie z. B. dem Internet verwendet werden. Mit SSL können Nachrichten, die zwischen Client und Server ausgetauscht werden, ver- und entschlüsselt werden, wodurch Nachrichten davor geschützt werden, während der Übertragung gelesen zu werden.

In diesem Artikel wird die OMS-Webdienstarchitektur vorgestellt, und es werden die Schnittstellen zwischen dem OMS-Webdienst und dem OMS-Client definiert und erläutert. Anleitungen zum Hosten eines OMS-Webdiensts finden Sie unter Richtlinien für Office 2010 Mobile Service (Teil 2 von 3). Informationen zum XML-Schema und zur WSDL für die OMS-Webdienste finden Sie unter Richtlinien für Office 2010 Mobile Service (Teil 3 von 3).

Anzeigen:
© 2014 Microsoft