ivr.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client.Base;
    using Imps.Utils;
    using System;
    using System.Collections.Generic;
    using System.Text;

    public class IVR : UserItemBase
    {
        private Imps.Client.Core.Contact _contact;
        private int _cSeq;
        private IVRDialog _dialog;
        private bool _isAccpet;
        private bool _isCanceled;
        private bool _isClosed;
        private SipRequest _ivrRequest;
        private int _ringTimes;
        private IVRParticipantStatus _status;

        public IVR(Imps.Client.Core.Contact contact, User owner, IVRDialog dialog) : base(owner)
        {
            this._cSeq = 1;
            this._contact = contact;
            this._dialog = dialog;
            base.Owner.SipRequestReceived += new EventHandler<SipRequestReceivedEventArgs>(this, (IntPtr) this.Owner_SipRequestReceived);
        }

        public void AsyncSendBye()
        {
        }

        public void AsyncSendCancel()
        {
            if (!this.IsCanceled)
            {
                this.IsCanceled = true;
                if (this._ivrRequest != null)
                {
                    if (!this.OwnerDialog.IsBeInvite)
                    {
                        SipRequest req = this.InnerCreateSipRequest("C", this._ivrRequest.Message.CallId.CallId, this._ivrRequest.Message.CSeq.Number);
                        req.Message.AddHeader(new SipcToHeader(this.Contact.Uri.Raw));
                        ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                        base.SendSipMessage(req);
                        this.Status = IVRParticipantStatus.Cancel;
                        this.Close();
                    }
                    else
                    {
                        this.AsyncSendResponse(0x1f8, "Server Time-out", this._ivrRequest);
                    }
                }
            }
        }

        public void AsyncSendInvite()
        {
            long callId = base.Owner.SipConnection.NextCallId();
            SipRequest req = base.CreateSipRequest("I", callId, this._cSeq);
            req.Message.AddHeader(new SipcToHeader(this.Contact.Uri.Raw));
            req.Message.Body = this.GetInviteBody();
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.<AsyncSendInvite>b__0);
            this._ivrRequest = req;
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.SendSipMessage(req);
        }

        public void AsyncSendInviteResponse()
        {
            this.Status = IVRParticipantStatus.Accept;
            SipInviteResponse msg = new SipInviteResponse(this._ivrRequest);
            msg.Message.AddHeader(new SipcFromHeader(this._ivrRequest.Message.From.Value));
            msg.Message.Body = this.GetInviteBody();
            if (<>9__CachedAnonymousMethodDelegate4 == null)
            {
                <>9__CachedAnonymousMethodDelegate4 = new EventHandler<SipAckReceivedEventArgs>(null, (IntPtr) <AsyncSendInviteResponse>b__1);
            }
            msg.AckReceived += <>9__CachedAnonymousMethodDelegate4;
            msg.WaitAckTimeout += delegate {
            };
            if (<>9__CachedAnonymousMethodDelegate6 == null)
            {
                <>9__CachedAnonymousMethodDelegate6 = new EventHandler<FailedEventArgs>(null, (IntPtr) <AsyncSendInviteResponse>b__3);
            }
            msg.SendMessageFailed += <>9__CachedAnonymousMethodDelegate6;
            base.SendSipMessage(msg);
        }

        internal void AsyncSendResponse(SipRequest req)
        {
            SipResponse msg = base.CreateSipResponse(req);
            base.SendSipMessage(msg);
        }

        internal void AsyncSendResponse(int statusCode, string reasonPhrase, SipRequest req)
        {
            SipResponse msg = new SipResponse(statusCode, reasonPhrase, req);
            msg.Message.AddHeader(new SipcFromHeader(req.Message.From.Value));
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.SendSipMessage(msg);
        }

        private void AsyncSendRinging(object sender, EventArgs e)
        {
            this._ringTimes++;
            if (this._ringTimes < 12)
            {
                this.AsyncSendResponse(180, "Ringing", this._ivrRequest);
            }
            else
            {
                this.UnRegisterRing();
            }
        }

        public void Close()
        {
            if (!this._isClosed)
            {
                this._isClosed = true;
                this.UnRegisterRing();
                base.Owner.SipRequestReceived -= new EventHandler<SipRequestReceivedEventArgs>(this, (IntPtr) this.Owner_SipRequestReceived);
            }
        }

        public void DoReceiveCancel(SipRequest req)
        {
            if (!this.IsCanceled)
            {
                this.IsCanceled = true;
                this.AsyncSendResponse(req);
                this.Close();
                this.Status = IVRParticipantStatus.Cancel;
                if (this == this._dialog.InviteContactIVR)
                {
                    this._dialog.IsCanceled = true;
                }
            }
        }

        private string GetInviteBody()
        {
            string text = "";
            string text2 = "";
            if (base.Owner.SipConnection.LocalEndPoint != null)
            {
                text = base.Owner.SipConnection.LocalEndPoint.ToString();
                text2 = base.Owner.SipConnection.LocalEndPoint.Port.ToString();
            }
            StringBuilder builder = new StringBuilder();
            builder.AppendLine("v=0");
            builder.AppendLine("o=-0 0 IN P4" + text);
            builder.AppendLine("s=VoiceChat");
            builder.AppendLine("c=IN IP4 " + text);
            builder.AppendLine("t=0 0");
            List<IVR>.Enumerator enumerator = this._dialog.IVRList.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    IVR ivr = enumerator.get_Current();
                    builder.AppendLine("a=user:" + ivr.Contact.Uri.Raw);
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            builder.AppendLine("m=ivr " + text2 + " sip " + base.Owner.Uri.ToString());
            return builder.ToString();
        }

        internal SipRequest InnerCreateSipRequest(string method, long callId, int cSeq)
        {
            SipcRequest sipcRequest = new SipcRequest(method, base.Owner.Domain);
            sipcRequest.AddHeader(new SipcFromHeader(base.Owner.Sid.ToString()));
            sipcRequest.AddHeader(new SipcCallIdHeader(callId));
            sipcRequest.AddHeader(new SipcCSeqHeader(cSeq, method));
            return new SipRequest(sipcRequest);
        }

        private void Owner_SipRequestReceived(object sender, SipRequestReceivedEventArgs e)
        {
            string method;
            if (((((this._ivrRequest != null) && (e.Request.Message.CallId.CallId == this._ivrRequest.Message.CallId.CallId)) && (e.Request.Message.From.Value == this.Contact.Uri.Raw)) && ((method = e.Request.Message.Method) != null)) && (method == "C"))
            {
                this.DoReceiveCancel(e.Request);
            }
        }

        internal void RegisterRing()
        {
            GlobalTimer.Register(new EventHandler(this.AsyncSendRinging), 100);
        }

        internal void UnRegisterRing()
        {
            if (GlobalTimer.IsHandlerRegistered(new EventHandler(this.AsyncSendRinging)))
            {
                GlobalTimer.Unregister(new EventHandler(this.AsyncSendRinging));
            }
        }

        public Imps.Client.Core.Contact Contact
        {
            get
            {
                return this._contact;
            }
        }

        internal bool IsCanceled
        {
            get
            {
                return this._isCanceled;
            }
            set
            {
                this._isCanceled = value;
            }
        }

        public bool IsClosed
        {
            get
            {
                return this._isClosed;
            }
            set
            {
                this._isClosed = value;
            }
        }

        internal SipRequest IvrRequest
        {
            get
            {
                return this._ivrRequest;
            }
            set
            {
                this._ivrRequest = value;
            }
        }

        public IVRDialog OwnerDialog
        {
            get
            {
                return this._dialog;
            }
        }

        public IVRParticipantStatus Status
        {
            get
            {
                return this._status;
            }
            set
            {
                if ((this._status == IVRParticipantStatus.Inviting) && (this._status != value))
                {
                    this._status = value;
                    this._dialog.RaiseIVRStatusChange(new IVREventArgs(this));
                }
            }
        }
    }
}