Source code explanation for MediaGateway SIP Example for Ozeki VoIP SIP SDK

Download:

web-sip-designed-gui.zip

This page is an explanation article for the source code of MediaGateway SIP Example for Ozeki VoIP SIP SDK to provide an overall view. Please find the source code parts and their explanation below this page.

Server implementation

In this sample program, the server is responsible for keeping connection with the SIP PBX, and also for setting up/accepting calls, hanging up calls, forwarding media data between the PBX/SIP device and the Silverlight client and distributing accounts that are required for logging into the PBX. The server also makes these accounts logged into the PBX for the Silverlight clients.

These tasks will be realized by the SIPGateway class in order to exploit the functions provided by Ozeki VoIP SIP SDK. It has been derived from the MediaGateway class. Furthermore, in order to implement SIP functionality quickly and easily, it uses the tools ensured by Ozeki VoIP SIP SDK.

SIPGateway Constructor

A SIPAccountPool is built in the class constructor that includes a certain number of accounts that belongs to a SIP PBX (in this example, it is Asterisk PBX). All connected clients are demonstrated by a SIPClient object, they are recorded in a ConcurrentDictionary. In order to exploit the implementation of the easy-to-handle, two-way communication between the client and the server, the stream service is got with the MediaGateway GetService<IStreamService>(); command (Code 1).

public SIPGateway()
        {
            sipClients = new ConcurrentDictionary<IClient, SIPClient>();
            softPhone = SoftPhoneFactory.CreateSoftPhone("192.168.113.6", 5060, 5800, 5060);

            sipAccountPool = new SIPAccountPool();

            for (int i = 80; i < 99; i++)
            {
                var name = "oz8" + i;
                var sipAccount = new SIPAccount(true, name, name, name, name, "192.168.115.1", 5060);

                sipAccountManager.AddSIPAcount(sipAccount);
            }

            streamService = GetService<IStreamService>();
        }

The softphone object that can be seen in the code is provided by the Ozeki VoIP SIP SDK. It represents a telephone with full functionality. Based on the SDK licensing, it is possible to add even more telephone lines through which calls are handled. The softphone can be created with the use of SoftPhoneFactory.CreateSoftPhone method call, in this example, the IP address and port range of Asterisk PBX is also used.

SipGateWay Public methods

OnClientConnect is an overridden method (Code 2). It can originally be found in SIPGateway class. Via this method the VoIP SIP SDK notifies if a client tries to connect.

public override void OnClientConnect(IClient client, object[] parameters)
        {
            Console.WriteLine("New client connected");

            var sipAccount = sipAccountPool.GetSIPAccount();

            if(sipAccount == null)
            {
                client.InvokeMethod("OnRegistrationStateChanged", RegistrationState.ConnectionLimit);
                client.Close();
                return;
            }

            var sipClient = new SIPClient(client, streamService, softPhone, sipAccount);
            sipClients.TryAdd(client, sipClient);

            sipClient.Register();
        }

If there is a free SIP account in the SipAccountPool for the client that tries to connect, then the SipClient object of the client is created with this account and the necessary parameters. In case there is no free account, the client that tries to connect will be notified and the connection is closed.

OnClientDisconnect method (Code 3) is only responsible for removing the connected client's reference from ConcurrentDictionary and for releasing the SIP account that has been used by the client and for unregistering the account from the PBX.

public override void OnClientDisconnect(IClient client)
        {
            Console.WriteLine("Client disconnected");

            SIPClient sipClient;
            if (sipClients.TryRemove(client, out sipClient))
            {
                sipClient.Unregister();
                sipAccountPool.AddSIPAcount(sipClient.Account);
            }
        }

OnSteamPublishStart (Code 4) will be invoked when the given client published its MediaStreamSender object, this way, it will be subscribed its stream MediaDataReceived event for the MediaDataReceived event handler of the SIPClient. This will forward the received data to the proper direction. The code implements these issues as follows:

public override void OnStreamPublishStart(IClient client, IMediaStream mediaStream)
        {
            Console.WriteLine("Media stream published. Stream name {0}", mediaStream.Name);

            SIPClient sipClient;
            if (sipClients.TryGetValue(client, out sipClient))
                mediaStream.MediaDataReceived += sipClient.MediaDataReceived;
        }

OnStreamClose (Code 5) makes the opposite of OnSteamPublishStart. OnStreamClose finishes the data transfer of the published stream by unsubscribing the event handler of the previously subscribed event.

public override void OnStreamClose(IClient client, IMediaStream mediaStream)
        {
            Console.WriteLine("Media stream closed.");

            SIPClient sipClient;
            if (sipClients.TryGetValue(client, out sipClient))
                mediaStream.MediaDataReceived -= sipClient.MediaDataReceived;
        }

The described methods above can be considered as the basic methods of Ozeki VoIP SIP SDK. They have been overridden according to the current implementation in order to provide them the appropriate functionality.

The next 3 methods have the following functionality: Call initiation, HangUP - rejecting incoming calls/hangup active call - and the Accept call functionality.

These methods extend the built-in services of Ozeki VoIP SIP SDK. They can be invoked via the mechanisms of the SDK that are related to these functions. This is the follows: the InvokeOnConnection method of the created MediaConnection in the client (Code 6). For example, in the following way in case of Call:

mediaConnection.InvokeOnConnection("Call", dialNumber);

That will result the following method call on the server side (Code 7).

public void Call(IClient client, string phoneNumber)
        {
            SIPClient sipClient;
            if (sipClients.TryGetValue(client, out sipClient))
                sipClient.Call(phoneNumber);
        }

This will forward the request to the SIPClient class. Hangup and Accept methods work similarly to the Call method. This way it is not detailed here, but it can be checked in the source code available for download on this webpage.

The SIPClient class for representing the clients on the server-side

A server-side SIPClient object will be created for each connected client and handle the status of the phone line belonging to the client.

SIPClient constructor (Code 8) gets its client's reference, server stream service's reference, the softphone that is responsible for representing the telephone and an account derived from a SIPAccountPool in its constructor.

public SIPClient(IClient client, IStreamService streamService, ISoftPhone softPhone, SIPAccount account)
        {
            mediaConnector = new MediaConnector();
            myMediaSender = new MyMediaSender();
            phoneCallMediaSender = new PhoneCallMediaSender(VoIPMediaType.Audio);
            codecConverter = CodecConverter.Instance;

            mediaConnector.Connect(myMediaSender, phoneCallMediaSender);

            this.streamService = streamService;
            this.softPhone = softPhone;
            this.client = client;

            Account = account;
        }

The class has a Mediaconnector object that is a tool provided by Ozeki VoIP SIP SDK. It is responsible for connecting the media data receiving from the client to the PhoneCallMediaSender object provided by the Ozeki VoIP SIP SDK. The media data that is received from the client is matched with the mentioned PhoneCallMediaSender via a MyMediaSender wrapper class with the following command shown in Code 9.

mediaConnector.Connect(myMediaSender, phoneCallMediaSender);

Register() method (Code 10) will create the phone line that belongs to the client and it will also subscribe to the necessary events.

public virtual void Register()
        {
            phoneLine = softPhone.CreatePhoneLine(Account);

            if (phoneLine.RegisteredInfo == PhoneLineState.RegistrationSucceded)
               OnPhoneLineStateChanged(phoneLine.RegisteredInfo);

            phoneLine.PhoneLineStateChanged += PhoneLine_PhoneLineInformationCanged;
            softPhone.IncommingCall += SoftPhone_IncommingCall;


            softPhone.RegisterPhoneLine(phoneLine);
        }

OnPhoneLineStateChanged event is responsible for indicating the changes in the telephone line status. The IncommingCall event of Softphone is for indicating incoming calls. The Unregister() method unregisters the phoneline and unsubscribes from the previously subscribed events. Call(string dialNumber) will dial the telephone number provided in the parameter via the Call object provided by Ozeki VoIP SIP SDK, furthermore, it subscribes to the events of this object that are necessary for making the call (Code 11).

public virtual void Call(string dialNumber)
        {
            if (phoneLine == null)
            {
                System.Diagnostics.Debug.Fail("PhoneLine null");
                return;
            }

            if ((phoneLine.RegisteredInfo == PhoneLineState.RegistrationSucceded || phoneLine.RegisteredInfo == PhoneLineState.NoRegNeeded) && call == null)
            {
                call = softPhone.CreateCallObject(phoneLine, dialNumber);

                call.CallErrorOccured += Call_ErrorOccured;
                call.CallStateChanged += Call_StateChanged;
                call.MediaDataReceived += Call_MediaDataReceived;
                call.Start();
            }
        }