ivrdialog.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client.Base;
    using Imps.Client.Utils;
    using Imps.Utils;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Runtime.CompilerServices;

    public class IVRDialog : UserItemBase
    {
        private AsyncBizOperation _bizOperation;
        private bool _hasStart;
        private IVR _inviteContactIVR;
        private bool _isAccepted;
        private bool _IsBeInvite;
        private bool _isCanceled;
        private bool _isClosed;
        private bool _isMultiDialog;
        private bool _isOvertime;
        private List<IVR> _list;

        public event EventHandler Closed;

        public event EventHandler<IVREventArgs> IVRStatusChange;

        public IVRDialog(User owner) : this(owner, null)
        {
        }

        public IVRDialog(User owner, List<Contact> contacts) : base(owner)
        {
            this._list = new List<IVR>();
            if ((contacts != null) && (contacts.get_Count() > 0))
            {
                List<Contact>.Enumerator enumerator = contacts.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        IVR ivr = new IVR(enumerator.get_Current(), base.Owner, this);
                        this._list.Add(ivr);
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                if (this._list.get_Count() > 1)
                {
                    this._isMultiDialog = true;
                }
            }
        }

        public void AcceptInvite()
        {
            if (!this._isAccepted && (this.InviteContactIVR != null))
            {
                this._isAccepted = true;
                this.InviteContactIVR.AsyncSendInviteResponse();
                AsyncBizOperation op = new AsyncBizOperation();
                op.ImpsError += new EventHandler<ImpsErrorEventArgs>(this, (IntPtr) this.op_ImpsError);
                List<IVR>.Enumerator enumerator = this.IVRList.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        IVR ivr = enumerator.get_Current();
                        if (ivr.Contact is Stranger)
                        {
                            base.Owner.ContactList.AsyncAddChatFriend(ivr.Contact.Uri, op);
                        }
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                this.InviteContactIVR.UnRegisterRing();
            }
        }

        private void AsyncStartIVR()
        {
            base.Owner.IVRManager.IVRStartTime.Add(DateTime.Now);
            SipRequest req = base.CreateSipRequest("S", base.Owner.SipConnection.NextCallId(), 1);
            req.Message.Headers.Add(new SipcEventHeader("StartVoiceChat"));
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("voice-chat");
                writer.WriteAttributeString("begin-date", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
                writer.WriteEndElement();
                writer.WriteStartElement("users");
                List<IVR>.Enumerator enumerator = this._list.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        IVR ivr = enumerator.get_Current();
                        if (ivr.Status == IVRParticipantStatus.Accept)
                        {
                            writer.WriteStartElement("user");
                            writer.WriteAttributeString("sid", ivr.Contact.Uri.Sid.ToString());
                            writer.WriteEndElement();
                        }
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.SendSipMessage(req);
        }

        public void CancelIVR()
        {
            try
            {
                if (this.InviteContactIVR != null)
                {
                    this.InviteContactIVR.UnRegisterRing();
                }
                if (!this._isCanceled)
                {
                    this._isCanceled = true;
                    if (!this._isAccepted)
                    {
                        if (this.IsBeInvite)
                        {
                            this.InviteContactIVR.AsyncSendCancel();
                        }
                        else
                        {
                            for (int i = this._list.get_Count() - 1; i >= 0; i--)
                            {
                                if (this._list.get_Item(i).Status == IVRParticipantStatus.Inviting)
                                {
                                    this._list.get_Item(i).AsyncSendCancel();
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteGeneral("会话取消失败！", exception.ToString());
            }
        }

        public void Close()
        {
            this.Close(true);
        }

        public void Close(bool cancel)
        {
            if (!this._isClosed)
            {
                this._isClosed = true;
                if (cancel)
                {
                    this.CancelIVR();
                }
                if (base.Owner.IVRManager.IVRDialogList.Contains(this))
                {
                    base.Owner.IVRManager.IVRDialogList.Remove(this);
                }
                List<IVR>.Enumerator enumerator = this.IVRList.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        enumerator.get_Current().Close();
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                if (this.Closed != null)
                {
                    FuncDispatcher.InvokeEventHandlerInUiThread(this, this.Closed, EventArgs.Empty);
                }
            }
        }

        public bool ContainsContact(Contact contact)
        {
            List<IVR>.Enumerator enumerator = this.IVRList.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    if (enumerator.get_Current().Contact == contact)
                    {
                        return true;
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            return false;
        }

        private void op_ImpsError(object sender, ImpsErrorEventArgs e)
        {
            e.Handled = true;
        }

        public void RaiseIVRStatusChange(IVREventArgs e)
        {
            if (this.IVRStatusChange != null)
            {
                FuncDispatcher.InvokeEventHandlerInUiThread<IVREventArgs>(this, this.IVRStatusChange, e);
            }
        }

        public void SendInvite()
        {
            List<IVR>.Enumerator enumerator = this._list.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    enumerator.get_Current().AsyncSendInvite();
                }
            }
            finally
            {
                enumerator.Dispose();
            }
        }

        public void StartIVR()
        {
            if (!this._hasStart)
            {
                this._hasStart = true;
                for (int i = this._list.get_Count() - 1; i >= 0; i--)
                {
                    if (this._list.get_Item(i).Status == IVRParticipantStatus.Inviting)
                    {
                        this._list.get_Item(i).AsyncSendCancel();
                    }
                }
                this.AsyncStartIVR();
            }
        }

        public AsyncBizOperation BizOperation
        {
            get
            {
                return this._bizOperation;
            }
            set
            {
                this._bizOperation = value;
            }
        }

        public bool HasStart
        {
            get
            {
                return this._hasStart;
            }
            set
            {
                this._hasStart = value;
            }
        }

        public IVR InviteContactIVR
        {
            get
            {
                return this._inviteContactIVR;
            }
            internal set
            {
                this._inviteContactIVR = value;
            }
        }

        public bool IsAccepted
        {
            get
            {
                return this._isAccepted;
            }
            set
            {
                this._isAccepted = value;
            }
        }

        public bool IsBeInvite
        {
            get
            {
                return this._IsBeInvite;
            }
            internal set
            {
                this._IsBeInvite = value;
            }
        }

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

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

        public bool IsMultiDialog
        {
            get
            {
                return this._isMultiDialog;
            }
            internal set
            {
                this._isMultiDialog = value;
            }
        }

        public bool IsOvertime
        {
            get
            {
                return this._isOvertime;
            }
            set
            {
                this._isOvertime = value;
            }
        }

        public List<IVR> IVRList
        {
            get
            {
                return this._list;
            }
        }
    }
}