/// <summary>
 /// Stub to alert on cancellation.
 /// </summary>
 /// <param name="ua">The ua.</param>
 /// <param name="request">The request.</param>
 /// <param name="sipStack">The sip stack.</param>
 public abstract void Cancelled(UserAgent ua, Message request, SIPStack sipStack);

 public void SendMessage(string uri, string message, string contentType = "text/plain")
 {
     uri = checkURI(uri);
     UserAgent mua = new UserAgent(Stack) { LocalParty = PublicServiceIdentity, RemoteParty = new Address(uri) };
     Useragents.Add(mua);
     Message m = mua.CreateRequest("MESSAGE", message);
     m.InsertHeader(new Header(contentType, "Content-Type"));
     mua.SendRequest(m);
 }

 public override string[] Authenticate(UserAgent ua, Header header, SIPStack sipStack)
 {
     throw new NotImplementedException();
 }

 public override void ReceivedResponse(UserAgent ua, Message response, SIPStack stack)
 {
     Log.Info("Received response with code " + response.ResponseCode + " " + response.ResponseText);
     Log.Debug("\n\n" + response.ToString());
     if (ResponseRecvEvent != null)
     {
         ResponseRecvEvent(this, new SipMessageEventArgs(response));
     }
 }

 public void SendInvite(string uri)
 {
     uri = checkURI(uri);
     UserAgent cua = new UserAgent(Stack) { LocalParty = PublicServiceIdentity, RemoteParty = new Address(uri) };
     Useragents.Add(cua);
     Message invite = cua.CreateRequest("INVITE");
     cua.SendRequest(invite);
 }

        private static void UpdateServiceMetrics(Dictionary<string, float> metrics)
        {
            UserAgent pua = new UserAgent(_app.Stack)
            {
                RemoteParty = new Address("<sip:" + ServerURI + ">"),
                LocalParty = _localParty
            };
            Message request = pua.CreateRequest("PUBLISH");
            request.InsertHeader(new Header("service-description", "Event"));
            request.InsertHeader(new Header("application/SERV_DESC+xml", "Content-Type"));
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load("Resources/ServiceDescription.xml");
            XmlNode node = xmlDoc.SelectSingleNode("Service/Metrics/TotalCPU");
            node.InnerText = String.Format("{0:0.##}", metrics["totalCPU"]);

            node = xmlDoc.SelectSingleNode("Service/Metrics/CPU");
            node.InnerText = String.Format("{0:0.##}", metrics["cpu"]);

            node = xmlDoc.SelectSingleNode("Service/Metrics/TotalMemory");
            node.InnerText = String.Format("{0:0.##}", metrics["memAvailable"]) + " MB";

            node = xmlDoc.SelectSingleNode("Service/Metrics/Memory");
            node.InnerText = String.Format("{0:0.##}", ((metrics["memUsed"] / 1024) / 1024)) + " MB";

            request.Body = xmlDoc.OuterXml;
            pua.SendRequest(request);
        }

 public override void DialogCreated(Dialog dialog, UserAgent ua, SIPStack stack)
 {
     Useragents.Remove(ua);
     Useragents.Add(dialog);
     Log.Info("New dialog created");
 }

 /// <summary>
 /// Passes a received request to the associated SIP application.
 /// </summary>
 /// <param name="ua">The ua.</param>
 /// <param name="request">The request.</param>
 public void ReceivedRequest(UserAgent ua, Message request)
 {
     App.ReceivedRequest(ua, request, this);
 }

 /// <summary>
 /// Passes a received response to the associated SIP application.
 /// </summary>
 /// <param name="ua">The ua.</param>
 /// <param name="response">The response.</param>
 public void ReceivedResponse(UserAgent ua, Message response)
 {
     App.ReceivedResponse(ua, response, this);
 }

 /// <summary>
 /// Creates a timer on the associated SIP application.
 /// </summary>
 /// <param name="obj">The obj.</param>
 /// <returns>Timer.</returns>
 public Timer CreateTimer(UserAgent obj)
 {
     return App.CreateTimer(obj, this);
 }

 /// <summary>
 /// Notifies the associated SIP application that a dialog has been created.
 /// </summary>
 /// <param name="dialog">The dialog.</param>
 /// <param name="ua">The ua.</param>
 public void DialogCreated(Dialog dialog, UserAgent ua)
 {
     App.DialogCreated(dialog, ua, this);
 }

 /// <summary>
 /// Passes the notification of a cancellation to the associated SIP application.
 /// </summary>
 /// <param name="ua">The ua.</param>
 /// <param name="request">The request.</param>
 public void Cancelled(UserAgent ua, Message request)
 {
     App.Cancelled(ua, request, this);
 }

 /// <summary>
 /// Authenticates through the associated SIP application.
 /// </summary>
 /// <param name="ua">The ua.</param>
 /// <param name="header">The header.</param>
 /// <returns>System.String[][].</returns>
 public string[] Authenticate(UserAgent ua, Header header)
 {
     return App.Authenticate(ua, header, this);
 }

 /// <summary>
 /// Stub to create timers.
 /// </summary>
 /// <param name="obj">The obj.</param>
 /// <param name="sipStack">The sip stack.</param>
 /// <returns>Timer.</returns>
 public abstract Timer CreateTimer(UserAgent obj, SIPStack sipStack);

        public void SendIM(string uri, string message,string contentType = "text/plain")
        {
            uri = checkURI(uri);
            if (IsRegistered())
            {

                UserAgent mua = new UserAgent(Stack) {LocalParty = RegisterUA.LocalParty, RemoteParty = new Address(uri)};
                Useragents.Add(mua);
                Message m = mua.CreateRequest("MESSAGE", message);
                m.InsertHeader(new Header(contentType, "Content-Type"));
                mua.SendRequest(m);
            }
        }

 /// <summary>
 /// Sends a particular message through the associated SIP application.
 /// </summary>
 /// <param name="ua">The ua.</param>
 /// <param name="message">The message.</param>
 public void Sending(UserAgent ua, Message message)
 {
     App.Sending(ua, message, this);
 }

 private static void PublishService(bool determineIP, int port)
 {
     UserAgent pua = new UserAgent(_app.Stack) { RemoteParty = new Address("<sip:" + ServerURI + ">"), LocalParty = _localParty };
     Message request = pua.CreateRequest("PUBLISH");
     request.InsertHeader(new Header("service-description", "Event"));
     request.InsertHeader(new Header("application/SERV_DESC+xml", "Content-Type"));
     XmlDocument xmlDoc = new XmlDocument();
     xmlDoc.Load("Resources/ServiceDescription.xml");
     if (determineIP)
     {
         XmlNode IPnode = xmlDoc.SelectSingleNode("Service/Service_Config/Server_IP");
         IPnode.InnerText = _localIP;
     }
     XmlNode Portnode = xmlDoc.SelectSingleNode("Service/Service_Config/Server_Port");
     Portnode.InnerText = Convert.ToString(port);
     xmlDoc.Save("Resources/ServiceDescription.xml");
     request.Body = xmlDoc.OuterXml;
     pua.SendRequest(request);
     ConsoleLog.Info("Sent service information to SRS");
 }

 public override Timer CreateTimer(UserAgent app, SIPStack stack)
 {
     return new Timer(app);
 }

 public override string[] Authenticate(UserAgent ua, Header header, SIPStack stack)
 {
     return new[] { Username + "@" + Realm, Password };
 }

 public override void ReceivedRequest(UserAgent ua, Message request, SIPStack stack)
 {
     Log.Info("Received request with method " + request.Method.ToUpper());
     Log.Debug("\n\n" + request.ToString());
     if (RequestRecvEvent != null)
     {
         RequestRecvEvent(this, new SipMessageEventArgs(request, ua));
     }
 }