Which Lync SDK? Send IMs from managed code

Question

I have a server application which - in the rare event of an unexpected error - should send an instant message to a lync user (endpoint).

From what I read I cannot use the Lync Client SDK as it relies on a running Lync client on the application server. This is however not possible. UCWA seems to be a fair choise but I don't really want to start writing my own Lync API, hiding all the HttpClient chatter in a managed code wrapper.

What's my best option for this simple use case here?

Answer 1

I would recommend using UCMA - the Unified Communications Managed API. If it's a one-off Instant Message you're sending out and you don't need an application that scales to handle many simultaneous conversation etc, you could use a UserEndpoint as it's a bit less work and setup than an ApplicationEndpoint.

I have a working example of doing this on my blog here: http://thoughtstuff.co.uk/2013/03/creating-ucma-applications-with-a-userapplication-instance-example-sending-ims/ which also has a bit more information about the different options you have.

However, for completeness (and because SO will be around longer than my blog I expect!) here's the code:

using Microsoft.Rtc.Collaboration;
using System;

namespace SimpleUserUCMA
{
    class Program
    {
        private const string sipaddress = "sip:[e-mail]";
        private const string username = "USERNAME";
        private const string password = "PASSWORD";
        private const string domain = "DOMAIN";
        private const string destinationSip = "sip:[e-mail]";
        private const string IMMessage = "Hello!";

        static CollaborationPlatform _collabPlatform { get; set; }
        static UserEndpoint _endpoint { get; set; }
        static bool _OKToQuit = false;


        static void Main(string[] args)
        {
            string userAgent = "ClientPlatformExample";

            var platformSettings = new ClientPlatformSettings(userAgent, Microsoft.Rtc.Signaling.SipTransportType.Tls);
            _collabPlatform = new CollaborationPlatform(platformSettings);

            //Start up the platform, calling back asynchronously once it's done.
            _collabPlatform.BeginStartup(EndCollabPlatformStartup, null);

            //In this example, wait for everything to finish before exiting
            while (!_OKToQuit)
            {
                System.Threading.Thread.Sleep(2000);
            }
        }

        private static void EndCollabPlatformStartup(IAsyncResult ar)
        {
            _collabPlatform.EndStartup(ar);

            //A collaboration plaform can have one or more Endpoints. An Endpoint is tied to a SIP Address.            
            UserEndpointSettings settings = new UserEndpointSettings(sipaddress);
            settings.Credential = new System.Net.NetworkCredential(username, password, domain);
            settings.AutomaticPresencePublicationEnabled = true;

            _endpoint = new UserEndpoint(_collabPlatform, settings);
            _endpoint.BeginEstablish(UserEndpointEstablishCompleted, null);

        }


        private static void UserEndpointEstablishCompleted(IAsyncResult ar)
        {
            _endpoint.EndEstablish(ar);

            //Once the endpoint is in place, create a Conversation and an IM Call. 
            var Conversation = new Conversation(_endpoint);
            var Call = new InstantMessagingCall(Conversation);

            //When the call is established, Flow will be created. Flow is how you sent IMs around. Therefore, just before
            //establishing, we attach an event handler to catch the flow being setup (it's state will change to Active)
            Call.InstantMessagingFlowConfigurationRequested += Call_InstantMessagingFlowConfigurationRequested;

            Call.BeginEstablish(destinationSip, new CallEstablishOptions(), EndBeginEstablish, Call);
        }

        private static void EndBeginEstablish(IAsyncResult ar)
        {
            Call call = (Call)ar.AsyncState;
            call.EndEstablish(ar);
        }

        static void Call_InstantMessagingFlowConfigurationRequested(object sender, InstantMessagingFlowConfigurationRequestedEventArgs e)
        {
            //Once we're notified about this, we get a handle to the newly created Flow. Let's use this to register for state changes.
            e.Flow.StateChanged += Flow_StateChanged;
        }

        static void Flow_StateChanged(object sender, MediaFlowStateChangedEventArgs e)
        {
            if (e.State == MediaFlowState.Active)
            {
                //The flow is now active! We can use it to send messages.
                InstantMessagingFlow flow = (InstantMessagingFlow)sender;
                flow.BeginSendInstantMessage(IMMessage, EndBeginSendInstanceMessage, flow);
            }
        }

        private static void EndBeginSendInstanceMessage(IAsyncResult ar)
        {
            InstantMessagingFlow flow = (InstantMessagingFlow)ar.AsyncState;
            flow.EndSendInstantMessage(ar);

            //Having sent the message, terminate the conversation
            flow.Call.Conversation.BeginTerminate(EndBeginTerminate, flow.Call.Conversation);
        }

        private static void EndBeginTerminate(IAsyncResult ar)
        {
            Conversation conversation = (Conversation)ar.AsyncState;
            conversation.EndTerminate(ar);

            _OKToQuit = true;
        }


    }
}