Пример #1
0
 public void Enqueue(T msg)
 {
     lock (m_objLock)
     {
         m_msgQueue.Enqueue(msg);
         GotNewMessageEvent.Set();
     }
 }
Пример #2
0
 public void Clear()
 {
     lock (m_objLock)
     {
         m_msgQueue.Clear();
         GotNewMessageEvent.Reset();
     }
 }
Пример #3
0
        public T WaitNext(int nTimeOutMs)
        {
            if (GotNewMessageEvent.WaitOne(nTimeOutMs) == false)
            {
                return(default(T));
            }

            return(PopNextMessage());
        }
Пример #4
0
 public void Enqueue(T[] msgs)
 {
     lock (m_objLock)
     {
         foreach (T nextt in msgs)
         {
             m_msgQueue.Enqueue(nextt);
         }
         GotNewMessageEvent.Set();
     }
 }
Пример #5
0
        private T[] PopAllMessages()
        {
            List <T> msglist = new List <T>();

            lock (m_objLock)
            {
                while (m_msgQueue.Count > 0)
                {
                    msglist.Add(m_msgQueue.Dequeue());
                }

                if (m_msgQueue.Count <= 0)  /// No more messages
                {
                    GotNewMessageEvent.Reset();
                }
            }
            return(msglist.ToArray());
        }
Пример #6
0
        private T PopNextMessage()
        {
            T msgret = default(T);

            lock (m_objLock)
            {
                if (m_msgQueue.Count > 0)
                {
                    msgret = m_msgQueue.Dequeue();
                }

                if (m_msgQueue.Count > 0)     /// mo Amessages
                {
                    GotNewMessageEvent.Set(); /// signal more people
                }
            }
            return(msgret);
        }
Пример #7
0
        private T PopNextMessage()
        {
            T msgret = default(T);

            lock (m_objLock)
            {
                if (m_msgQueue.Count > 0)
                {
                    msgret = m_msgQueue.Dequeue();
                }

                if (m_msgQueue.Count <= 0)  /// No more messages
                {
                    GotNewMessageEvent.Reset();
                }
            }
            return(msgret);
        }
Пример #8
0
        public void EnqueueSorted(T[] msgs, IComparer <T> comparer)
        {
            lock (m_objLock)
            {
                List <T> listnewsorted = new List <T>();
                T[]      arrayexisting = m_msgQueue.ToArray();
                m_msgQueue.Clear();

                listnewsorted.AddRange(arrayexisting);
                listnewsorted.AddRange(msgs);
                listnewsorted.Sort(comparer);

                foreach (T nextt in listnewsorted)
                {
                    m_msgQueue.Enqueue(nextt);
                }

                GotNewMessageEvent.Set();
            }
        }
Пример #9
0
 public T[] WaitAll(int nTimeOutMs)
 {
     GotNewMessageEvent.WaitOne(nTimeOutMs);
     return(PopAllMessages());
 }
Пример #10
0
        public async void ConnectToLongPollServer(bool useSsl = true, bool needPts = true)
        {
            var token = AuthorizeService.Instance.AccessToken;

            var url =
                $"https://api.vk.com/method/messages.getLongPollServer?v=5.45&use_ssl={useSsl}&need_pts={needPts}&access_token={token}";
            var obj = await GetUrl(url);

            var connectionSettings = JsonConvert.DeserializeObject <LongPollConnectionSettings>(obj["response"].ToString());

            while (connectionSettings.TS != 0)
            {
                LongPoolServerResponse updates;
                do
                {
                    url = $"http://{connectionSettings.Adress}?" +
                          $"act=a_check&key={connectionSettings.Key}" +
                          $"&ts={connectionSettings.TS}&wait=25&mode=2";

                    obj = await GetUrl(url);

                    updates = JsonConvert.DeserializeObject <LongPoolServerResponse>(obj.ToString());
                } while (updates.ErrorCode != 0);

                connectionSettings.TS = updates.Ts;

                foreach (var update in updates.Updates)
                {
                    switch (int.Parse(update[0].ToString()))
                    {
                    case 4:
                        var message = new Message
                        {
                            Id        = int.Parse(update[1].ToString()),
                            Body      = update[6].ToString(),
                            UserId    = int.Parse(update[3].ToString()),
                            UnixTime  = int.Parse(update[4].ToString()),
                            Out       = (int.Parse(update[2].ToString()) & 2) != 0, //+2 - OUTBOX
                            IsNotRead = (int.Parse(update[2].ToString()) & 1) != 0  //+1 - UNREAD
                        };
                        var attachString = update[7].ToString()
                                           .Replace("\"", "")
                                           .Replace("\r\n", "")
                                           .Replace("}", "")
                                           .Replace("{", "")
                                           .Split(',');
                        if (attachString.ToList().Count == 1 && attachString[0] == string.Empty)
                        {
                            GotNewMessageEvent?.Invoke(message);
                            break;
                        }


                        var attachmentIds = attachString
                                            .Where(s => !s.Contains("type")).ToList()
                                            .Select(e => e.Split(':').Last().Trim(' ')).ToList();
                        var types = attachString
                                    .Where(s => s.Contains("type")).ToList()
                                    .Select(e => e.Split(':').Last().Trim(' ')).ToList();

                        if (attachmentIds.Count != types.Count)
                        {
                            GotNewMessageEvent?.Invoke(message);
                            break;
                        }

                        var dict = new Dictionary <string, string>();    //id - type
                        for (int i = 0; i < attachmentIds.Count; i++)
                        {
                            dict.Add(attachmentIds[i], types[i]);
                        }

                        var attachments = await GetFiles(dict);

                        if (attachments.Any(a => a.Document != null && a.Document.Id == -1))
                        {
                            //значит произошла ошибка загрузки документа из-за недостатка прав
                            message = await _messageService.GetMessage(message.Id);

                            GotNewMessageEvent?.Invoke(message);
                            break;
                        }

                        if (attachments != null)
                        {
                            message.Attachments = new ObservableCollection <Attachment>(attachments);
                        }

                        GotNewMessageEvent?.Invoke(message);
                        break;

                    case 7:
                        var userId            = int.Parse(update[1].ToString());
                        var lastReadMessageId = int.Parse(update[2].ToString());
                        MessageStateChangedToReadEvent?.Invoke(lastReadMessageId, userId);
                        break;

                    case 8:
                        UserBecameOnlineOrOfflineEvent?.Invoke(-1 * int.Parse(update[1].ToString()), true);
                        break;

                    case 9:
                        UserBecameOnlineOrOfflineEvent?.Invoke(-1 * int.Parse(update[1].ToString()), false);
                        break;
                    }
                }
            }
        }