示例#1
0
        public LastSeenViewModel(ICacheService cacheService, ICommonErrorHandler errorHandler, IStateService stateService, INavigationService navigationService, IMTProtoService mtProtoService, ITelegramEventAggregator eventAggregator)
            : base(cacheService, errorHandler, stateService, navigationService, mtProtoService, eventAggregator)
        {
            EventAggregator.Subscribe(this);

            _rules = StateService.PrivacyRules;
            StateService.PrivacyRules = null;

            MainRules = new List <TLPrivacyRuleBase>
            {
                new TLPrivacyValueAllowAll {
                    Label = AppResources.Everybody.ToLowerInvariant()
                },
                new TLPrivacyValueAllowContacts {
                    Label = AppResources.MyContacts.ToLowerInvariant()
                },
                new TLPrivacyValueDisallowAll {
                    Label = AppResources.Nobody.ToLowerInvariant()
                }
            };

            _selectedMainRule   = GetSelectedMainRule(MainRules, _rules, MainRules[0], MainRules[2]);
            _selectedAllowUsers = GetSelectedRule <TLPrivacyValueAllowUsers>(_rules) ?? new TLPrivacyValueAllowUsers {
                Users = new TLVector <TLInt>()
            };
            _selectedDisallowUsers = GetSelectedRule <TLPrivacyValueDisallowUsers>(_rules) ?? new TLPrivacyValueDisallowUsers {
                Users = new TLVector <TLInt>()
            };
            SwitchUsersVisibility(true);
            PropertyChanged += OnPropertyChanged;
        }
示例#2
0
        protected override void OnActivate()
        {
            BeginOnThreadPool(() =>
            {
                if (StateService.UsersRule != null)
                {
                    var allowUsersRule = StateService.UsersRule as TLPrivacyValueAllowUsers;
                    if (allowUsersRule != null)
                    {
                        _selectedAllowUsers = allowUsersRule;

                        CleanupUsers(_selectedAllowUsers, _selectedDisallowUsers);
                    }
                    var disallowUsersRule = StateService.UsersRule as TLPrivacyValueDisallowUsers;
                    if (disallowUsersRule != null)
                    {
                        _selectedDisallowUsers = disallowUsersRule;

                        CleanupUsers(_selectedDisallowUsers, _selectedAllowUsers);
                    }
                    StateService.UsersRule = null;
                }

                UpdateSubtitles();
            });

            base.OnActivate();
        }
示例#3
0
        public void Handle(TLUpdatePrivacy privacy)
        {
            _rules = new TLPrivacyRules {
                Rules = privacy.Rules
            };

            SelectedMainRule    = GetSelectedMainRule(MainRules, _rules, MainRules[0], MainRules[2]);
            _selectedAllowUsers = GetSelectedRule <TLPrivacyValueAllowUsers>(_rules) ?? new TLPrivacyValueAllowUsers {
                Users = new TLVector <TLInt>()
            };
            _selectedDisallowUsers = GetSelectedRule <TLPrivacyValueDisallowUsers>(_rules) ?? new TLPrivacyValueDisallowUsers {
                Users = new TLVector <TLInt>()
            };
            SwitchUsersVisibility(false);

            UpdateSubtitles();
        }
        private void UpdatePrivacy(TLAccountPrivacyRules rules)
        {
            var          badge   = string.Empty;
            PrivacyValue?primary = null;
            TLPrivacyValueDisallowUsers disallowed = null;
            TLPrivacyValueAllowUsers    allowed    = null;

            foreach (TLPrivacyRuleBase current in rules.Rules)
            {
                if (current is TLPrivacyValueAllowAll)
                {
                    primary = PrivacyValue.AllowAll;
                    badge   = Strings.Android.LastSeenEverybody;
                }
                else if (current is TLPrivacyValueAllowContacts)
                {
                    primary = PrivacyValue.AllowContacts;
                    badge   = Strings.Android.LastSeenContacts;
                }
                else if (current is TLPrivacyValueDisallowAll)
                {
                    primary = PrivacyValue.DisallowAll;
                    badge   = Strings.Android.LastSeenNobody;
                }
                else if (current is TLPrivacyValueDisallowUsers disallowUsers)
                {
                    disallowed = disallowUsers;
                }
                else if (current is TLPrivacyValueAllowUsers allowUsers)
                {
                    allowed = allowUsers;
                }
            }

            if (primary == null)
            {
                primary = PrivacyValue.DisallowAll;
                badge   = Strings.Android.LastSeenNobody;
            }

            var list = new List <string>();

            if (disallowed != null)
            {
                list.Add("-" + disallowed.Users.Count);
            }
            if (allowed != null)
            {
                list.Add("+" + allowed.Users.Count);
            }

            if (list.Count > 0)
            {
                badge = string.Format("{0} ({1})", badge, string.Join(", ", list));
            }

            BeginOnUIThread(() =>
            {
                Badge = badge;

                SelectedItem = primary ?? PrivacyValue.DisallowAll;
                Allowed      = allowed ?? new TLPrivacyValueAllowUsers {
                    Users = new TLVector <int>()
                };
                Disallowed = disallowed ?? new TLPrivacyValueDisallowUsers {
                    Users = new TLVector <int>()
                };
            });
        }