Beispiel #1
0
        public void ClearRecentStickers()
        {
            IsWorking = true;
            MTProtoService.ClearRecentStickersAsync(
                false,
                result => Execute.BeginOnUIThread(() =>
            {
                IsWorking = false;
                MTProtoService.SetMessageOnTime(2.0, AppResources.Done);

                var allStickers = StateService.GetAllStickers();
                if (allStickers != null)
                {
                    var allStickers29 = allStickers as TLAllStickers29;
                    if (allStickers29 != null)
                    {
                        allStickers29.RecentlyUsed = new TLVector <TLRecentlyUsedSticker>();
                        EmojiControl emojiControl;
                        if (EmojiControl.TryGetInstance(out emojiControl))
                        {
                            emojiControl.ClearRecentStickers();
                        }
                        StateService.SaveAllStickersAsync(allStickers29);
                    }
                }
            }),
                error => Execute.BeginOnUIThread(() =>
            {
                IsWorking = false;
                Execute.ShowDebugMessage("messages.clearRecentStickers error " + error);
            }));
        }
Beispiel #2
0
        public static void LogOutCommon(ITelegramEventAggregator eventAggregator, IMTProtoService mtProtoService, IUpdatesService updateService, ICacheService cacheService, IStateService stateService, IPushService pushService, INavigationService navigationService)
        {
            eventAggregator.Publish(Commands.LogOutCommand);

            SettingsHelper.SetValue(Constants.IsAuthorizedKey, false);
            SettingsHelper.RemoveValue(Constants.CurrentUserKey);
            mtProtoService.ClearQueue();
            updateService.ClearState();
            cacheService.ClearAsync();
            stateService.ResetPasscode();

            stateService.ClearAllStickersAsync();
            stateService.ClearFeaturedStickersAsync();
            stateService.ClearArchivedStickersAsync();

            EmojiControl emojiControl;

            if (EmojiControl.TryGetInstance(out emojiControl))
            {
                emojiControl.ClearStickersOnLogOut();
            }

            cacheService.ClearConfigImportAsync();
            SearchViewModel.DeleteRecentAsync();

            Bootstrapper.UpdateMainTile();

            DialogDetailsViewModel.DeleteInlineBots();
            FileUtils.Delete(new object(), Constants.InlineBotsNotificationFileName);
            FileUtils.Delete(new object(), Constants.WebPagePreviewsFileName);

            var liveLocationService = IoC.Get <ILiveLocationService>();

            liveLocationService.Clear();

            if (navigationService.CurrentSource == navigationService.UriFor <StartupViewModel>().BuildUri() ||
                navigationService.CurrentSource == navigationService.UriFor <SignInViewModel>().BuildUri() ||
                navigationService.CurrentSource == navigationService.UriFor <ConfirmViewModel>().BuildUri() ||
                navigationService.CurrentSource == navigationService.UriFor <SignUpViewModel>().BuildUri())
            {
                return;
            }

            stateService.ClearNavigationStack = true;
            Telegram.Logs.Log.Write("StartupViewModel SettingsViewModel.LogOutCommon");
            navigationService.UriFor <StartupViewModel>().Navigate();
        }
Beispiel #3
0
        public void AddToFavedStickers(TLMessageBase messageBase)
        {
            if (messageBase == null)
            {
                return;
            }

            var message = messageBase as TLMessage;

            if (message == null || !message.IsSticker())
            {
                return;
            }

            var mediaDocument = message.Media as TLMessageMediaDocument;

            if (mediaDocument == null)
            {
                return;
            }

            var document = mediaDocument.Document as TLDocument22;

            if (document != null)
            {
                var allStickers = StateService.GetAllStickers() as TLAllStickers43;
                if (allStickers != null)
                {
                    var favedStickers = allStickers.FavedStickers;
                    if (favedStickers != null)
                    {
                        var unfave = favedStickers.Documents.FirstOrDefault(x => x.Index == document.Index) != null;

                        MTProtoService.FaveStickerAsync(new TLInputDocument {
                            Id = document.Id, AccessHash = document.AccessHash
                        }, new TLBool(unfave),
                                                        result => Execute.BeginOnUIThread(() =>
                        {
                            if (unfave)
                            {
                                favedStickers.RemoveSticker(document);
                            }
                            else
                            {
                                favedStickers.AddSticker(document);
                            }

                            allStickers.FavedStickers = favedStickers;
                            StateService.SaveAllStickersAsync(allStickers);

                            EmojiControl emojiControl;
                            if (unfave)
                            {
                                MTProtoService.GetFavedStickersAsync(allStickers.FavedStickers.Hash,
                                                                     result2 =>
                                {
                                    var favedStickers2 = result2 as TLFavedStickers;
                                    if (favedStickers2 != null)
                                    {
                                        allStickers.FavedStickers = favedStickers;
                                        StateService.SaveAllStickersAsync(allStickers);

                                        Execute.BeginOnUIThread(() =>
                                        {
                                            if (EmojiControl.TryGetInstance(out emojiControl))
                                            {
                                                emojiControl.ResetFavedStickers();
                                            }
                                        });
                                    }
                                },
                                                                     error2 =>
                                {
                                });
                            }

                            if (EmojiControl.TryGetInstance(out emojiControl))
                            {
                                emojiControl.ResetFavedStickers();
                            }
                        }),
                                                        error =>
                        {
                        });
                    }
                }
            }
        }
Beispiel #4
0
        public void ReorderStickerSets()
        {
            if (_allStickers == null)
            {
                return;
            }
            if (_delayedItems != null && _delayedItems.Count > 0)
            {
                return;
            }

            var oldHash = TLUtils.ToTLInt(_allStickers.Hash);
            var newHash = TLUtils.GetAllStickersHash(Items);

            if (oldHash.Value != newHash)
            {
                var order = new TLVector <TLLong>();
                foreach (var item in Items)
                {
                    order.Add(item.Id);
                }

                Execute.ShowDebugMessage("ReorderStickers");
                IsWorking = true;
                MTProtoService.ReorderStickerSetsAsync(false, order,
                                                       result => BeginOnUIThread(() =>
                {
                    IsWorking       = false;
                    var allStickers = _allStickers as TLAllStickers32;
                    if (allStickers != null)
                    {
                        allStickers.Hash = new TLString(newHash.ToString(CultureInfo.InvariantCulture));
                        allStickers.Sets = new TLVector <TLStickerSetBase>(Items);
                        var sets         = new Dictionary <long, TLVector <TLDocumentBase> >();
                        for (var i = 0; i < allStickers.Documents.Count; i++)
                        {
                            var document22 = allStickers.Documents[i] as TLDocument22;
                            if (document22 != null)
                            {
                                var stickerSetId = document22.StickerSet as TLInputStickerSetId;
                                if (stickerSetId != null)
                                {
                                    TLVector <TLDocumentBase> stickers;
                                    if (sets.TryGetValue(stickerSetId.Id.Value, out stickers))
                                    {
                                        stickers.Add(document22);
                                    }
                                    else
                                    {
                                        sets[stickerSetId.Id.Value] = new TLVector <TLDocumentBase> {
                                            document22
                                        };
                                    }
                                }
                            }
                        }
                        var documents = new TLVector <TLDocumentBase>();
                        for (var i = 0; i < allStickers.Sets.Count; i++)
                        {
                            TLVector <TLDocumentBase> stickers;
                            if (sets.TryGetValue(allStickers.Sets[i].Id.Value, out stickers))
                            {
                                foreach (var sticker in stickers)
                                {
                                    documents.Add(sticker);
                                }
                            }
                        }
                        allStickers.Documents = documents;

                        EmojiControl emojiControl;
                        if (EmojiControl.TryGetInstance(out emojiControl))
                        {
                            emojiControl.ReorderStickerSets();
                        }

                        StateService.SaveAllStickersAsync(allStickers);
                    }
                }),
                                                       error => BeginOnUIThread(() =>
                {
                    IsWorking = false;
                    Execute.ShowDebugMessage("messages.reorderStickerSets error " + error);
                }));
            }
        }