Exemplo n.º 1
0
        private async Task <object> ProcessHttpWait(IMTSession session, InnerMessage message)
        {
            var result = await Task.FromResult <object>(null);

            var _req = session.Services.Serialization().Deserialize(message.Content) as MTHttpWait;

            if (_req != null)
            {
                this.max_delay     = _req.MaxDelay;
                this.max_wait      = _req.MaxWait;
                this.wait_after    = _req.WaitAfter;
                message.max_wait   = _req.MaxWait;
                message.max_delay  = _req.MaxDelay;
                message.wait_after = _req.WaitAfter;
            }
            var _ret = new TLInputPeerEmpty
            {
            };

            if (_ret as MTObject != null)
            {
                result = new MTRpcResult
                {
                    ReqMsgId = (long)message.msg_id,
                    Result   = new MTGzipPacked
                    {
                        PackedData = Utils.compress(BitConverter.GetBytes(0x997275b5))
                    }
                };
                //session.AddMessage(result as MTObject, true, true);
            }

            return(result);
        }
Exemplo n.º 2
0
        public void LoadNextSlice()
        {
            if (IsWorking ||
                LazyItems.Count > 0 ||
                IsLastSliceLoaded
#if WP8
                || !_isUpdated
#endif
                )
            {
                return;
            }

            var offset = _offset;
            var limit  = Constants.DialogsSlice;
            //TLUtils.WriteLine(string.Format("{0} messages.getDialogs offset={1} limit={2}", DateTime.Now.ToString("HH:mm:ss.fff", CultureInfo.InvariantCulture), offset, limit), LogSeverity.Error);

            var             offsetDate = 0;
            var             offsetId   = 0;
            TLInputPeerBase offsetPeer = new TLInputPeerEmpty();
            var             lastDialog = GetLastDialog(Items);
            if (lastDialog != null)
            {
                var lastMessage = lastDialog.TopMessage as TLMessageCommon;
                if (lastMessage != null)
                {
                    offsetDate = lastMessage.DateIndex;
                    offsetId   = lastMessage.Index;
                    if (lastMessage.ToId is TLPeerUser)
                    {
                        offsetPeer = !lastMessage.Out.Value
                            ? DialogDetailsViewModel.PeerToInputPeer(new TLPeerUser {
                            Id = lastMessage.FromId
                        })
                            : DialogDetailsViewModel.PeerToInputPeer(lastMessage.ToId);
                    }
                    else
                    {
                        offsetPeer = DialogDetailsViewModel.PeerToInputPeer(lastMessage.ToId);
                    }
                }
            }

            IsWorking = true;
            //TLObject.LogNotify = true;
            //TelegramEventAggregator.LogPublish = true;
            var stopwatch = Stopwatch.StartNew();
            MTProtoService.GetDialogsAsync(stopwatch,
                                           new TLInt(offsetDate),
                                           new TLInt(offsetId),
                                           offsetPeer,
                                           new TLInt(limit),
                                           new TLInt(0),
                                           result =>
            {
                //System.Diagnostics.Debug.WriteLine("messages.getDialogs end sync elapsed=" + stopwatch.Elapsed);

                BeginOnUIThread(() =>
                {
                    //System.Diagnostics.Debug.WriteLine("messages.getDialogs ui elapsed=" + stopwatch.Elapsed);
                    //TelegramEventAggregator.LogPublish = false;
                    //TLObject.LogNotify = false;
                    if (_offset != offset)
                    {
                        return;
                    }
                    _offset += Constants.DialogsSlice;

                    foreach (var dialog in result.Dialogs)
                    {
                        Items.Add(dialog);
                    }

                    ReorderDrafts(Items);

                    IsWorking         = false;
                    IsLastSliceLoaded = result.Dialogs.Count < limit;
                    Status            = LazyItems.Count > 0 || Items.Count > 0 ? string.Empty : Status;
                    //System.Diagnostics.Debug.WriteLine("messages.getDialogs end ui elapsed=" + stopwatch.Elapsed);
                    //TLUtils.WriteLine(string.Format("messages.getDialogs offset={0} limit={1} result={2}", offset, limit, result.Dialogs.Count), LogSeverity.Error);
                });
            },
                                           error => BeginOnUIThread(() =>
            {
                IsWorking = false;
                Status    = string.Empty;
                //TLUtils.WriteLine(string.Format("messages.getDialogs offset={0} limit={1} error={2}", offset, limit, error), LogSeverity.Error);
                Execute.ShowDebugMessage("messages.getDialogs error " + error);
            }));
        }
        private void UpdateDialogsAsync(TLDialog lastDialog)
        {
            if (_lastSliceLoaded)
            {
                return;
            }

            var             offsetDate = 0;
            var             offsetId   = 0;
            TLInputPeerBase offsetPeer = new TLInputPeerEmpty();

            if (lastDialog != null)
            {
                var lastMessage = lastDialog.TopMessage as TLMessageCommon;
                if (lastMessage != null)
                {
                    offsetDate = lastMessage.DateIndex;
                    offsetId   = lastMessage.Index;
                    if (lastMessage.ToId is TLPeerUser)
                    {
                        offsetPeer = !lastMessage.Out.Value
                            ? DialogDetailsViewModel.PeerToInputPeer(new TLPeerUser {
                            Id = lastMessage.FromId
                        })
                            : DialogDetailsViewModel.PeerToInputPeer(lastMessage.ToId);
                    }
                    else
                    {
                        offsetPeer = DialogDetailsViewModel.PeerToInputPeer(lastMessage.ToId);
                    }
                }
            }

            var stopwatch = Stopwatch.StartNew();

            IoC.Get <IMTProtoService>().GetDialogsAsync(stopwatch,
                                                        new TLInt(offsetDate),
                                                        new TLInt(offsetId),
                                                        offsetPeer,
                                                        new TLInt(int.MaxValue),
                                                        new TLInt(0),
                                                        result => Execute.BeginOnUIThread(() =>
            {
                _lastSliceLoaded = true;

                var dialogs        = result.Dialogs;
                var clearedDialogs = new List <TLDialogBase>();
                foreach (var d in dialogs)
                {
                    if (Skip(d))
                    {
                        continue;
                    }

                    clearedDialogs.Add(d);
                }

                foreach (var clearedDialog in clearedDialogs)
                {
                    var d = new DialogItem {
                        Dialog = clearedDialog
                    };

                    DialogsSource.Add(d);
                }

                LoadNextSlice();
            }),
                                                        error => Execute.BeginOnUIThread(() =>
            {
            }));
        }
        public void LoadNextSlice()
        {
            if (LazyItems.Count > 0 || IsLastSliceLoaded || IsWorking)
            {
                return;
            }

            var             offsetDate = 0;
            var             offsetId   = 0;
            TLInputPeerBase offsetPeer = new TLInputPeerEmpty();
            var             lastDialog = Items.OfType <TLDialog>().Last(x => x.TopMessage != null && x.TopMessage.Index > 0);

            if (lastDialog != null)
            {
                var lastMessage = lastDialog.TopMessage as TLMessageCommon;
                if (lastMessage != null)
                {
                    offsetDate = lastMessage.DateIndex;
                    offsetId   = lastMessage.Index;
                    if (lastMessage.ToId is TLPeerUser)
                    {
                        offsetPeer = !lastMessage.Out.Value
                            ? DialogDetailsViewModel.PeerToInputPeer(new TLPeerUser {
                            Id = lastMessage.FromId
                        })
                            : DialogDetailsViewModel.PeerToInputPeer(lastMessage.ToId);
                    }
                    else
                    {
                        offsetPeer = DialogDetailsViewModel.PeerToInputPeer(lastMessage.ToId);
                    }
                }
            }

            IsWorking = true;
            var offset = Items.Count;
            var limit  = 30;

            MTProtoService.GetDialogsAsync(Stopwatch.StartNew(),
                                           new TLInt(offsetDate),
                                           new TLInt(offsetId),
                                           offsetPeer,
                                           new TLInt(limit),
                                           new TLInt(0),
                                           result => Execute.BeginOnUIThread(() =>
            {
                lastDialog = result.Dialogs.LastOrDefault(x => x.TopMessageId != null) as TLDialog;
                if (lastDialog != null)
                {
                    _maxId = lastDialog.TopMessageId.Value;
                }

                var itemsAdded = 0;
                foreach (var dialog in result.Dialogs)
                {
                    if (!SkipDialogForBot(_bot, dialog))
                    {
                        Items.Add(dialog);
                        itemsAdded++;
                    }
                }

                IsWorking         = false;
                IsLastSliceLoaded = result.Dialogs.Count < limit;
                Status            = LazyItems.Count > 0 || Items.Count > 0 ? string.Empty : Status;

                if (itemsAdded < (Constants.DialogsSlice / 2))
                {
                    LoadNextSlice();
                }
            }),
                                           error => Execute.BeginOnUIThread(() =>
            {
                IsWorking = false;
                Status    = string.Empty;
            }));
        }