userpresence.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client;
    using Imps.Client.Base;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Common;
    using Imps.Utils;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using System.Text;
    using System.Threading;
    using System.Xml;

    public class UserPresence : Imps.Client.Core.Presence, ICommittable
    {
        private Imps.Client.Core.CrbtCollection _crbtCol;
        private Imps.Client.Core.CrbtToBuddySettings _crbtToBuddySettings;
        private Imps.Client.Core.User _owner;
        private MainPresence _pendingPresence;
        private string _pendingPresenceDesc;
        private int _previousPresencePriority;
        private List<IPresenceSensor> _sensors;
        private bool _sensorTimerEnabled;
        private object _syncObjPresence;
        private Dictionary<string, CrbtToBuddySetting> m_crbt_setting_map;

        public UserPresence(Imps.Client.Core.User owner) : this(owner, MainPresence.Offline, string.Empty)
        {
        }

        public UserPresence(Imps.Client.Core.User owner, MainPresence presence, string moodPhrase) : base(presence, moodPhrase)
        {
            this.m_crbt_setting_map = new Dictionary<string, CrbtToBuddySetting>();
            this._syncObjPresence = new object();
            this._pendingPresence = MainPresence.Unknown;
            this._pendingPresenceDesc = string.Empty;
            this._owner = owner;
            this._sensors = new List<IPresenceSensor>();
            this._crbtCol = new Imps.Client.Core.CrbtCollection();
            this._crbtToBuddySettings = new Imps.Client.Core.CrbtToBuddySettings();
        }

        public void AsyncChangeMainPresence(MainPresence basicPresence, string text)
        {
            this.AsyncChangeMainPresence(basicPresence, text, null);
        }

        public void AsyncChangeMainPresence(MainPresence basicPresence, string text, AsyncBizOperation op)
        {
            this.InnerAsyncChangeMainPresence(basicPresence, text, op, 0);
        }

        public void AsyncChangeMoodPhrase(string text)
        {
            this.AsyncChangeMoodPhrase(text, null);
        }

        public void AsyncChangeMoodPhrase(string text, AsyncBizOperation op)
        {
            this.Owner.PersonalInfo.MoodPhrase.ProposedValue = text;
            this.Owner.PersonalInfo.CommitProposedProperties(op);
        }

        public void AsyncDownloadBuddyCrbt(Imps.Client.Core.Contact buddy, AsyncBizOperation op)
        {
            op.ContextForBiz = buddy;
            ThreadPool.QueueUserWorkItem(new WaitCallback(this.DownloadBuddyCrbt), op);
        }

        public void AsyncSetDefaultCrbtToBuddy(CrbtToBuddy crbt, AsyncBizOperation op)
        {
            op.ContextForBiz = crbt;
            ThreadPool.QueueUserWorkItem(new WaitCallback(this.SetDefaultCrbtToBuddy), op);
        }

        internal override void Clear()
        {
            base.Clear();
            this._previousPresencePriority = 0;
            this.Value = -1;
            this.ResetPendingPresence();
            this.m_crbt_setting_map.Clear();
            this._crbtToBuddySettings.Clear();
            this._crbtCol.Clear();
        }

        public bool CommitChanges(AsyncBizOperation op)
        {
            this.CommitProposedProperties(op);
            return true;
        }

        internal override void CommitProposedProperties(AsyncBizOperation op)
        {
            XmlHelper.WriteXmlContentDelegate writeContentCallback = null;
            EventHandler<SipResponseReceivedEventArgs> handler = null;
            try
            {
                if (this.HasProposedProperty())
                {
                    SipRequest req = this.Owner.CreateSipRequest("S");
                    req.Message.AddHeader(new SipcEventHeader("SetPresence"));
                    StringWriter tw = new StringWriter();
                    if (writeContentCallback == null)
                    {
                        writeContentCallback = delegate (XmlWriter writer, object context) {
                            writer.WriteStartElement("presence");
                            if (base.SmsStatus.HasProposedValue)
                            {
                                writer.WriteStartElement("extended");
                                writer.WriteAttributeString("type", "sms");
                                writer.WriteString(base.SmsStatus.ProposedValue.ToString());
                                writer.WriteEndElement();
                            }
                            if (base.Listening.HasProposedValue)
                            {
                                writer.WriteStartElement("extended");
                                writer.WriteAttributeString("type", "listening");
                                writer.WriteString(base.Listening.ProposedValue);
                                writer.WriteEndElement();
                            }
                            writer.WriteEndElement();
                        };
                    }
                    XmlHelper.CreateXmlWriterForSipRequest(tw, null, writeContentCallback);
                    req.Message.Body = tw.ToString();
                    ErrorHelper.HandleSendRequestErrorAndTimeout(req);
                    if (handler == null)
                    {
                        handler = new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.<CommitProposedProperties>b__f);
                    }
                    req.FinalResponseReceived += handler;
                    this.Owner.SendSipMessage(req);
                }
            }
            catch (Exception exception)
            {
                LogHelper.LogException(exception);
            }
        }

        public void DisposeSensors()
        {
            List<IPresenceSensor>.Enumerator enumerator = this._sensors.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    IPresenceSensor sensor = enumerator.get_Current();
                    if (sensor is IDisposable)
                    {
                        ((IDisposable) sensor).Dispose();
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
        }

        private void DownloadBuddyCrbt(object arg)
        {
            AsyncBizOperation op = (AsyncBizOperation) arg;
            Imps.Client.Core.Contact contextForBiz = (Imps.Client.Core.Contact) op.ContextForBiz;
            string strCrbtToMeCode = ((CrbtToBuddy) contextForBiz.Presence.CrbtToMe).ToneCode;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                string text = string.Format("{0}.", this.Owner.PersonalInfo.Province);
                writer.WriteElementString("method-id", "OrderTone");
                writer.WriteElementString("region", text);
                writer.WriteElementString("id", strCrbtToMeCode);
            });
            string text = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" + tw;
            HttpWebRequest request = null;
            try
            {
                request = ConnectionFactory.CreateHttpWebRequest(this.Owner.Configuration.SystemSetting.ServerUriSetting.UriCrbtCommonAccess, this.Owner, true, true);
                request.ContentType = "text/xml; charset=utf-8";
                using (Stream stream = request.GetRequestStream())
                {
                    using (StreamWriter writer2 = new StreamWriter(stream))
                    {
                        writer2.Write(text);
                    }
                }
                using (HttpWebResponse response = ((HttpWebResponse) request.GetResponse()))
                {
                    string text2 = "-1";
                    using (Stream stream2 = response.GetResponseStream())
                    {
                        using (StreamReader reader = new StreamReader(stream2, Encoding.UTF8))
                        {
                            text2 = reader.ReadToEnd();
                        }
                    }
                    if ("0" == text2)
                    {
                        this.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs("下载成功, 是否设置为默认彩铃?", "", null, 500, contextForBiz.Presence.CrbtToMe), op);
                    }
                    else if ("1" == text2)
                    {
                        this.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs("下载彩铃失败: 彩铃不存在", "", 0x1f6), op);
                    }
                    else if ("2" == text2)
                    {
                        this.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs("下载彩铃失败: 彩铃库已满", "", 0x1f7), op);
                    }
                    else if ("3" == text2)
                    {
                        this.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs("已经下载过此彩铃, 是否设置为默认彩铃?", "", null, 0x1f8, contextForBiz.Presence.CrbtToMe), op);
                    }
                    else if ("5" == text2)
                    {
                        this.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs("您尚未开通彩铃服务", "", null, 0x1fb, contextForBiz.Presence.CrbtToMe), op);
                    }
                    else
                    {
                        this.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs("下载彩铃失败, 请稍候再试", "", 0x1f5), op);
                    }
                }
            }
            catch (Exception exception)
            {
                if (request != null)
                {
                    request.Abort();
                }
                this.Owner.FireImpsErrorInUiThread(new ImpsErrorEventArgs("下载彩铃失败, 请稍候再试", "", 0x1f5), op);
                ClientLogger.WriteGeneral("download crbt", exception.ToString());
            }
        }

        private void EnableTimerTick(bool enabled)
        {
            if (this._sensorTimerEnabled != enabled)
            {
                if (enabled)
                {
                    GlobalTimer.Register(new EventHandler(this.SensorTimer_Tick), 5);
                }
                else
                {
                    GlobalTimer.Unregister(new EventHandler(this.SensorTimer_Tick));
                }
                this._sensorTimerEnabled = enabled;
            }
        }

        public IPresenceSensor IndexOfSensor(string name)
        {
            List<IPresenceSensor>.Enumerator enumerator = this._sensors.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    IPresenceSensor sensor = enumerator.get_Current();
                    if (sensor.Name == name)
                    {
                        return sensor;
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            return null;
        }

        internal void InnerAsyncChangeMainPresence(MainPresence basicPresence, string text, AsyncBizOperation op, int priority)
        {
            this.InnerAsyncChangeMainPresence(basicPresence, text, op, priority, false);
        }

        internal void InnerAsyncChangeMainPresence(MainPresence basicPresence, string text, AsyncBizOperation op, int priority, bool forceChange)
        {
            XmlHelper.WriteXmlContentDelegate writeContentCallback = null;
            EventHandler<SipResponseReceivedEventArgs> handler = null;
            if (text == null)
            {
                text = string.Empty;
            }
            if (basicPresence == MainPresence.Invisible)
            {
                basicPresence = MainPresence.Offline;
            }
            if (!forceChange)
            {
                MainPresence mainPresence = this.MainPresence;
                if (mainPresence == MainPresence.Invisible)
                {
                    mainPresence = MainPresence.Offline;
                }
                if ((mainPresence == basicPresence) && (base.PresenceDesc == text))
                {
                    if (op != null)
                    {
                        op.FireSuccessedInUiThread(EventArgs.Empty);
                    }
                    return;
                }