示例#1
0
        private async Task InitializeSingletons()
        {
            _toxModel.Start();
            await _avatarManager.LoadAvatars();

            ToxErrorViewModel.Instance.ToxErrorOccured += ToxErrorOccuredHandler;
        }
示例#2
0
        public async Task SetAsCurrent()
        {
            var toxInstance = new ExtendedTox(new ToxOptions(true, true), _toxData);

            _toxModel.SetCurrent(toxInstance);
            await _toxModel.SaveDataAsync();

            _toxModel.Start();
            await _avatarManager.LoadAvatars();
        }
示例#3
0
        private IDisposable BindAvatars(
            IAvatarManager avatarManager,
            IObservable <Range> visibleRangeChanges)
        {
            var prevRange = new Range(0, 0);

            return(visibleRangeChanges
                   .SelectMany(range =>
            {
                var releases = avatarManager.ReleaseAvatars(_items, prevRange, range);
                var loads = avatarManager.LoadAvatars(_items, prevRange, range);

                return releases.Concat(loads);
            })
                   .SubscribeOn(TaskPoolScheduler.Default)
                   .ObserveOn(RxApp.MainThreadScheduler)
                   .Subscribe(action => action()));
        }
        private IDisposable InitMessageLoading(
            Target target,
            IMessageManager messageManager,
            IAvatarManager avatarManager)
        {
            var messageLoading = messageManager.LoadPrevMessages(target)
                                 .Select(models => new {
                Action = new Action(() =>
                {
                    _items.InsertRange(models, 0);
                }),
                Models = models
            });

            var avatarLoading = messageLoading
                                .SelectMany(item =>
            {
                var action = item.Action;
                var models = item.Models;

                var messageLoadAction = Observable.Return(action);

                var avatarPreloadAction = avatarManager.PreloadAvatars(models)
                                          .Select((avatar, i) => new Action(() =>
                {
                    var messageModel    = models[i];
                    messageModel.Avatar = avatar;
                }));

                var avatarLoadAction = avatarManager.LoadAvatars(models)
                                       .Select((avatar, i) => new Action(() =>
                {
                    var messageModel    = models[i];
                    messageModel.Avatar = avatar;
                }));

                return(messageLoadAction
                       .Concat(avatarPreloadAction)
                       .Concat(avatarLoadAction));
            });

            return(SubscribeToActions(avatarLoading));
        }
示例#5
0
        private IDisposable BindAvatarLoading(
            IObservable <VisibleRangeNotifiedArgs> visibleRangeChanges,
            IAvatarManager avatarManager)
        {
            var prevRange = new Range(0, 0);

            return(visibleRangeChanges
                   .ObserveOn(TaskPoolScheduler.Default)
                   .SubscribeOn(RxApp.MainThreadScheduler)
                   .Subscribe(args =>
            {
                var range = args.Range;

                avatarManager.ReleaseAvatars(_items, prevRange, range)
                .DisposeWith(_serviceDisposable);

                avatarManager.LoadAvatars(_items, prevRange, range)
                .DisposeWith(_serviceDisposable);

                prevRange = range;
            }));
        }
        private IDisposable BindVisibleRangeChanges(
            Target target,
            IMessageManager messageManager,
            IAvatarManager avatarManager)
        {
            var prevRange           = default(Range);
            var visibleRangeChanges = Model.WhenAnyValue(m => m.VisibleRange)
                                      .Select(range => new
            {
                PrevRange = prevRange,
                Range     = range
            })
                                      .Do(item => prevRange = item.Range)
                                      .Do(Console.WriteLine);

            var messageLoading = visibleRangeChanges
                                 .SelectMany(item =>
            {
                if (item.Range.Length > 0)
                {
                    if (item.Range.Index == 0 &&
                        item.Range.Index != item.PrevRange.Index)
                    {
                        var items        = _items.Items.OfType <MessageModel>().ToList();
                        var firstMessage = items.FirstOrDefault();
                        return(messageManager.LoadPrevMessages(target, firstMessage?.Message)
                               .Select(models => new {
                            Action = new Action(() =>
                            {
                                _items.InsertRange(models, 0);
                            }),
                            Models = models
                        }));
                    }

                    if (item.Range.Index + item.Range.Length == _items.Count &&
                        item.Range.LastIndex != item.PrevRange.LastIndex)
                    {
                        var items       = _items.Items.OfType <MessageModel>().ToList();
                        var lastMessage = items.LastOrDefault();
                        return(messageManager.LoadNextMessages(target, lastMessage?.Message)
                               .Select(models => new {
                            Action = new Action(() =>
                            {
                                _items.AddRange(models);
                            }),
                            Models = models
                        }));
                    }
                }

                return(Observable.Empty <IList <MessageModel> >()
                       .Select(models => new
                {
                    Action = new Action(() => { }),
                    Models = models
                }));
            });

            var avatarLoading = messageLoading
                                .SelectMany(item =>
            {
                var action = item.Action;
                var models = item.Models;

                var messageLoadAction = Observable.Return(action);

                var avatarPreloadAction = avatarManager.PreloadAvatars(models)
                                          .Select((avatar, i) => new Action(() =>
                {
                    var messageModel    = models[i];
                    messageModel.Avatar = avatar;
                }));

                var avatarLoadAction = avatarManager.LoadAvatars(models)
                                       .Select((avatar, i) => new Action(() =>
                {
                    var messageModel    = models[i];
                    messageModel.Avatar = avatar;
                }));

                return(messageLoadAction
                       .Concat(avatarPreloadAction)
                       .Concat(avatarLoadAction));
            });

            return(SubscribeToActions(avatarLoading));
        }