How to develop a call queue with periodically played informational messages in C# for improving your VoIP PBX

In order to make your call queue more user-friendly, you can improve it by implementing some advanced functionalities as well as periodically played informational message streaming. As a result, your callers will be informed about the currently estimated waiting time. This way - figuratively speaking - you can reduce the waiting time and keep your callers’ calm. It also encourages your callers to do not hang up the phone while they are waiting in the call queue. In this section I am going to show you how to create this feature.

I used the CallQueueHandlerContainer (Code example 7) and the CallHistory (Code example 8) classes to let the text-to-speech engine read a prewritten message for the queued callers. This message will inform them about the expected waiting time in every 15 seconds.

As you can see below, the CallQueueHandlerContainer class stores the callQueueCallHandler objects in a list (in other words: the calls) and masks all the operations can be performed (as well as Add, Count, GetIndex, Remove and Next). As a result, the rank of the call in the call queue can be easily identified. You only need to call the GetIndex method.

using System;  
using System.Collections.Generic;  
  
namespace MyPBX.CallQueue  
{  
    class CallQueueHandlerContainer  
    {  
        List<CallQueueCallHandler> callQueueCallHandlers;  
  
        public CallQueueHandlerContainer()  
        {  
            callQueueCallHandlers = new List<CallQueueCallHandler>();      
        }  
  
        public void Add(CallQueueCallHandler callHandler)  
        {  
            callQueueCallHandlers.Add(callHandler);  
        }  
  
        public int Count()  
        {  
            return callQueueCallHandlers.Count;  
        }  
  
        public int GetIndex(CallQueueCallHandler callHandler)  
        {  
            return callQueueCallHandlers.IndexOf(callHandler);  
        }  
  
        public void Remove(CallQueueCallHandler callHandler)  
        {  
            callQueueCallHandlers.Remove(callHandler);  
        }  
  
        public CallQueueCallHandler Next()  
        {  
            if (callQueueCallHandlers.Count == 0)  
                return null;  
            return callQueueCallHandlers[0];  
        }  
    }  
}

Code example 7: The CallQueueHandlerContainer class

Code example 8 presents the CallHistory class that handles the built-in system calls, and makes these data accessible. You only need to call the GetCallHistrory method.

using System.Collections.Generic;  
using Ozeki.VoIP.PBX.Services;  
using Ozeki.VoIP.PBX.PhoneCalls.Session;  
  
namespace MyPBX.CallQueue  
{  
    class CallHistory  
    {  
        static Dictionary<string, List<ISession>> callHistoryStatistics = new Dictionary<string, List<ISession>>();  
   
        public static void Init(ICallManager callManager)  
        {  
            callManager.SessionClosed += callManager_SessionClosed;  
        }  
  
        public static List<ISession> GetCallHistory(string userId)  
        {  
            if(!callHistoryStatistics.ContainsKey(userId))  
                return new List<ISession>();  
  
            return callHistoryStatistics[userId];  
        }  
  
        static void callManager_SessionClosed(object sender, Ozeki.VoIP.VoIPEventArgs<Ozeki.VoIP.PBX.PhoneCalls.Session.ISession> e)  
        {  
            var callee = e.Item.CalleeInfo.Owner.Account.UserName;  
  
            UpdateCallStatistics(callee, e.Item);  
  
        }  
  
        private static void UpdateCallStatistics(string party, ISession session)  
        {  
            if (!callHistoryStatistics.ContainsKey(party))  
                callHistoryStatistics[party] = new List<ISession>();  
  
            callHistoryStatistics[party].Add(session);  
        }  
    }  
}

Code example 8: The CallHistory class

To implement the automated informative message playing, you need to create a textToSpeech object within the CallQueueCallHandler class. As a result, your caller will be informed about his/her position in the queue and the estimated waiting time. Concerning to the fact that before and after an informative message an mp3 music can be heard, you need to link these with the calls by using the AudioMixesMediaHandler.

Code example 9 shows the timer_Elapsed method that can be used to calculate the expected waiting time. 

void timer_Elapsed(object sender, ElapsedEventArgs e)  
        {  
            if (!call.CallState.IsInCall())  
                return;  
  
            var memb = new List<string>(members);  
              
            foreach (var activeSession in callManager.ActiveSessions)  
            {  
                var callee = activeSession.CalleeInfo.Owner.Account.UserName;  
                var caller = activeSession.CallerInfo.Owner.Account.UserName;  
  
                memb.Remove(callee);  
                memb.Remove(caller);  
  
                double sum = 0;  
                var callCounter = 0;  
                  
                foreach (var m in memb)  
                {  
                    List<ISession> historyResult = CallHistory.GetCallHistory(m);  
  
                    foreach (var session in historyResult)  
                    {  
                        ++callCounter;  
                        sum += session.TalkDuration.TotalSeconds;  
                    }  
                }  
  
                if (sum != 0)  
                {  
                    waitingTime = sum / callCounter;  
                }  
            }  
  
            if(!blindTransferEnabled)  
                return;  
  
            foreach (var member in memb)  
            {  
                if (extensionContainer.GetExtension(member) != null)  
                {  
                    call.BlindTransfer(member);  
                }  
            }  
        }

Code example 9: The timer_Elapsed method

To determine the estimated waiting time, the program will go through the agent's call historyin order to calculate the average duration of a call. (Please note that in this project one agent has been used.)

To be able to provide information for the callers continuously, you need to create a new timer. It will run out in every 15 seconds then call the timerAgent_Elapsed method (Code example 10). This method will pause the mp3 streaming until the textToSpeech method reads the position of the client and the estimated waiting time. (If the are not any active call, the program will not calculate the waiting time and the informative message will not be played, since the caller will be directed to the agent.) The textToSpeech needs to be cleared by using the Clear method.

void timerAgent_Elapsed(object sender, ElapsedEventArgs e)  
        {  
            mp3Player.PauseStreaming();  
            textToSpeech.Clear();  
  
            if (waitingTime == 0)  
            {  
                textToSpeech.AddAndStartText(string.Format("{0} more customers are waiting in line before you. Please be patient.",  
                                                           callQueueHandlerContainer.GetIndex(this)));  
            }  
            else  
            {  
                textToSpeech.AddAndStartText(string.Format("{0} more customers are waiting in line before you. " +  
                                                           "Your estimated wait time is approximately {1} seconds. Please be patient.",  
                                                           callQueueHandlerContainer.GetIndex(this),  
                                                           (int)waitingTime));  
            }  
        }

Code example 10: The timerAgent_Elapsed method

As you can see below, the textToSpeech method will be carried out when it ends (that is, it is signed up to the TextToSpeechCompleted method). Here you can reset the streaming of the mp3 music.

void TextToSpeechCompleted(object sender, EventArgs e)  
        {  
            mp3Player.StartStreaming();  
            textToSpeech.Clear();  
        }

Code example 11: The TextToSpeechCompleted method

Summary

To sum it up, due to the VoIP technology, your existing VoIP PBX can be easily improved by implementing some useful additional functionalities. An important one of the possible features is call queuing. In this article I described how to create a virtual call queue extension to be able to accept the simultaneous incoming calls. I have tried to make my call queue more user-friendly by implementing mp3 music streaming and prediodical informational message playing. My solution has been written in C#, and I worked with Microsoft Visual Studio and Ozeki VoIP SIP SDK.