dialog.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client;
    using Imps.Client.Base;
    using Imps.Client.Core.P2P.FileTransportor;
    using Imps.Client.Core.P2P.ICE;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Common;
    using Imps.Utils;
    using Imps.Utils.TagParser;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using System.Runtime.CompilerServices;
    using System.Text;
    using System.Threading;
    using System.Xml;

    public class Dialog : UserItemBase
    {
        private bool _allowMultiparty;
        private bool _closeByBye;
        private MessageContentType _contentType;
        private Imps.Client.Core.Conversation _conv;
        private int _cSeq;
        private bool _enableSaveHistory;
        private List<string> _hasAddCharFrients;
        private bool _hasAddRecentBuddys;
        private bool _hasSetEnableSaveMessage;
        private bool _isBeInvite;
        private bool _isClosed;
        private bool _isMulitiConversation;
        private int _lastReceiveCesq;
        private Imps.Client.Core.MessageType _messateType;
        private MessageManager _msgManager;
        private int _nextTagId;
        private bool _otherSupportNudge;
        private ParticipantCollection _participants;
        private ManualResetEvent _receiveRequestEvent;
        private ShareContentCollection _shareContents;
        private DialogStatus _status;
        private List<Message> _temporaryMessages;
        private string _to;
        private bool _waitingClose;
        private int _waitingMessageResponseCount;
        private readonly object recvSyncRoot;

        public event EventHandler<ParticipantEventArgs> AddParticipant;

        public event EventHandler<ShareContentEventArgs> AddShareContent;

        public event EventHandler Closed;

        public event EventHandler<EnableSaveMessageEventArgs> EnableSaveHistoryByContact;

        public event EventHandler EnableSaveHistoryChange;

        public event EventHandler<MessageEventArgs> MessageRecieved;

        public event EventHandler<ParticipantEventArgs> ParticipantPersonalInfoChange;

        public event EventHandler<ParticipantEventArgs> ParticipantPresenceChanged;

        public event EventHandler<ParticipantEventArgs> ParticipantStateChange;

        public event EventHandler<ParticipantEventArgs> ReceiveNudgeRequest;

        public event EventHandler<ParticipantEventArgs> RemoveParticipant;

        public event EventHandler<ShareContentEventArgs> RemoveShareContent;

        public event EventHandler<MessageSendFailedEventArgs> SendMessageFailed;

        public event EventHandler<DialogStatusChangeEventArgs> StatusChange;

        public Dialog(Imps.Client.Core.Conversation conv) : base(conv.Owner)
        {
            this._messateType = Imps.Client.Core.MessageType.IM;
            this._to = "";
            this._cSeq = 1;
            this._nextTagId = 1;
            this._enableSaveHistory = true;
            this._receiveRequestEvent = new ManualResetEvent(true);
            this.recvSyncRoot = new object();
            this._conv = conv;
            this._shareContents = new ShareContentCollection(this);
            this._participants = new ParticipantCollection(this);
            this._msgManager = new MessageManager(this);
            base.Owner.SipRequestReceived += new EventHandler<SipRequestReceivedEventArgs>(this, (IntPtr) this.Owner_SipRequestReceived);
            base.Owner.SipNotifyReceived += new EventHandler<SipRequestReceivedEventArgs>(this, (IntPtr) this.Owner_SipNotifyReceived);
        }

        public void AcceptEnableSaveHistory()
        {
            this.AsyncSendAcceptOrRefuseSaveHistory("SaveHistory");
        }

        protected void AddChatFriends()
        {
            int num = 0;
            using (IEnumerator<ConversationParticipant> enumerator = this.Participants.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    ConversationParticipant participant = enumerator.get_Current();
                    if (participant.Contact is Stranger)
                    {
                        if (num >= 20)
                        {
                            return;
                        }
                        if (this._hasAddCharFrients == null)
                        {
                            this._hasAddCharFrients = new List<string>();
                        }
                        if (!this._hasAddCharFrients.Contains(participant.Contact.Uri.Raw))
                        {
                            num++;
                            this._hasAddCharFrients.Add(participant.Contact.Uri.Raw);
                            base.Owner.ContactList.AsyncAddChatFriend(participant.Contact.Uri, this.BizOperation);
                        }
                    }
                }
            }
        }

        internal void AsyncCCToSms(Imps.Client.Core.Contact contact, string content)
        {
            XmlHelper.WriteXmlContentDelegate writeContentCallback = null;
            try
            {
                SipRequest req = this.InnerCreateSipRequest("S", base.Owner.SipConnection.NextCallId(), this.NextCSeq);
                req.Message.AddHeader(new SipcEventHeader("CCToSms"));
                StringWriter tw = new StringWriter();
                if (writeContentCallback == null)
                {
                    writeContentCallback = delegate (XmlWriter writer, object context) {
                        writer.WriteStartElement("from");
                        writer.WriteAttributeString("sid", contact.Uri.Sid.ToString());
                        if (!string.IsNullOrEmpty(contact.PersonalInfo.MobileNo) && (contact.Uri.MobileNo != "0"))
                        {
                            writer.WriteAttributeString("mobile-no", contact.PersonalInfo.MobileNo);
                        }
                        writer.WriteAttributeString("nickname", contact.DisplayName);
                        writer.WriteEndElement();
                        writer.WriteStartElement("msg");
                        writer.WriteAttributeString("is-cat-sms", (this.Owner.Configuration.UserSetting.LongSmsSetting == LongSMSSetting.Enable) ? "1" : "0");
                        writer.WriteString(content);
                        writer.WriteEndElement();
                    };
                }
                XmlHelper.CreateXmlWriterForSipMessage(tw, null, writeContentCallback, "args");
                req.Message.Body = tw.ToString();
                tw.Dispose();
                ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                base.Owner.SendSipMessage(req);
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
            }
        }

        private void AsyncEnableOrDisableSaveHistory(string method)
        {
            this.HasSetEnableSaveMessage = true;
            SipRequest req = this.InnerCreateSipRequest("O", this.CallId, this.NextCSeq);
            req.Message.AddHeader(new SipcRequireHeader(method));
            req.Message.AddHeader(new SipcToHeader(this.To));
            req.Context = method;
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.<AsyncEnableOrDisableSaveHistory>b__10);
            req.SendMessageFailed += new EventHandler<FailedEventArgs>(this, (IntPtr) this.<AsyncEnableOrDisableSaveHistory>b__11);
            req.WaitResponseTimeout += delegate {
                this.HasSetEnableSaveMessage = false;
            };
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.SendSipMessage(req);
        }

        public void AsyncInviteParticipants(List<Imps.Client.Core.Contact> contacts)
        {
            EventHandler<SipResponseReceivedEventArgs> handler = null;
            if (!this.IsMulitiConversation)
            {
                this.AsyncUpgradeConversation(contacts);
            }
            else
            {
                List<Imps.Client.Core.Contact>.Enumerator enumerator = contacts.GetEnumerator();
                try
                {
                    XmlHelper.WriteXmlContentDelegate writeContentCallback = null;
                    while (enumerator.MoveNext())
                    {
                        Imps.Client.Core.Contact contact = enumerator.get_Current();
                        SipRequest req = this.InnerCreateSipRequest("S", this.CallId, this.NextCSeq);
                        req.Message.AddHeader(new SipcToHeader(this.To));
                        req.Message.AddHeader(new SipcEventHeader("AddParticipant"));
                        StringWriter tw = new StringWriter();
                        if (writeContentCallback == null)
                        {
                            writeContentCallback = delegate (XmlWriter writer, object context) {
                                writer.WriteStartElement("temporary-group");
                                writer.WriteAttributeString("uri", this.To);
                                writer.WriteStartElement("participant");
                                writer.WriteAttributeString("uri", contact.Uri.Raw);
                                writer.WriteEndElement();
                                writer.WriteEndElement();
                            };
                        }
                        XmlHelper.CreateXmlWriterForSipRequest(tw, null, writeContentCallback);
                        req.Message.Body = tw.ToString();
                        if (handler == null)
                        {
                            handler = new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.<AsyncInviteParticipants>b__4);
                        }
                        req.FinalResponseReceived += handler;
                        ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                        base.SendSipMessage(req);
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
            }
        }

        internal void AsyncKeepAlive()
        {
            this.AsyncSendUserState("keep-alive");
        }

        private void AsyncReferUpgradeConversation(List<Imps.Client.Core.Contact> contacts)
        {
            SipRequest req = this.InnerCreateSipRequest("IN", this.CallId, this.NextCSeq);
            req.Message.AddHeader(new SipcToHeader(this.To));
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipMessage(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("participants");
                List<Imps.Client.Core.Contact>.Enumerator enumerator = contacts.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        Imps.Client.Core.Contact contact = enumerator.get_Current();
                        writer.WriteStartElement("participant");
                        writer.WriteAttributeString("uri", contact.Uri.Raw);
                        writer.WriteEndElement();
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                writer.WriteEndElement();
            }, "upgrade-session");
            if (<>9__CachedAnonymousMethodDelegateb == null)
            {
                <>9__CachedAnonymousMethodDelegateb = new EventHandler<SipResponseReceivedEventArgs>(null, (IntPtr) <AsyncReferUpgradeConversation>b__a);
            }
            req.FinalResponseReceived += <>9__CachedAnonymousMethodDelegateb;
            req.Message.Body = tw.ToString();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.SendSipMessage(req);
        }

        private void AsyncSendAcceptOrRefuseSaveHistory(string method)
        {
            SipRequest req = this.InnerCreateSipRequest("O", this.CallId, this.NextCSeq);
            req.Message.AddHeader(new SipcToHeader(this.To));
            req.Message.AddHeader(new SipcSupportedHeader(method));
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.SendSipMessage(req);
        }

        private void AsyncSendBye()
        {
            SipRequest req = this.InnerCreateSipRequest("B", this.CallId, this.NextCSeq);
            req.Message.AddHeader(new SipcToHeader(this.To));
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            base.SendSipMessage(req);
        }

        private void AsyncSendCancel()
        {
        }

        public virtual Message AsyncSendIm(string content)
        {
            Message msg = this.GetSendMessage(content);
            this.InnerSendIm(msg);
            return msg;
        }

        public void AsyncSendInvite()
        {
            this.Status = DialogStatus.Inviting;
            SipRequest msg = this.InnerCreateSipRequest("I", this.CallId, (this._cSeq != 1) ? this.NextCSeq : this._cSeq);
            msg.Message.AddHeader(new SipcToHeader(this.To));
            msg.Message.AddHeader(new SipcSupportedHeader("text/html-fragment"));
            msg.Message.AddHeader(new SipcSupportedHeader("multiparty"));
            msg.Message.AddHeader(new SipcSupportedHeader("nudge"));
            msg.Message.Body = this.GetInviteSDP();
            msg.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.invite_req_FinalResponseReceived);
            msg.SendMessageFailed += new EventHandler<FailedEventArgs>(this, (IntPtr) this.<AsyncSendInvite>b__0);
            msg.WaitResponseTimeout += delegate {
                this.Status = DialogStatus.None;
            };