private async Task RefreshThemesAsync()
{
Items.ReplaceWith(_themeService.GetThemes());
Custom.ReplaceWith(await _themeService.GetCustomThemesAsync());
var type = Settings.Appearance.RequestedThemeType;
if (ThemeAccentInfo.IsAccent(type))
{
var accent = Settings.Appearance.Accents[type];
if (_defaultAccents[type].Contains(accent))
{
Accents.ReplaceWith(_defaultAccents[type]
.Select(x => ThemeAccentInfo.FromAccent(type, x)));
}
else
{
Accents.ReplaceWith(_defaultAccents[type]
.Take(_defaultAccents[type].Length - 1)
.Union(new[] { accent })
.Select(x => ThemeAccentInfo.FromAccent(type, x)));
}
}
else
{
Accents.Clear();
}
AreCustomThemesAvailable = Custom.Count > 0;
}
private async void LoadAdminedPublicChannels()
{
if (AdminedPublicChannels.Count > 0)
{
return;
}
var response = await ProtoService.SendAsync(new GetCreatedPublicChats());
if (response is TdWindows.Chats chats)
{
var result = new List <Chat>();
foreach (var id in chats.ChatIds)
{
var chat = ProtoService.GetChat(id);
if (chat != null)
{
result.Add(chat);
}
}
AdminedPublicChannels.ReplaceWith(result);
}
else if (response is Error error)
{
Execute.ShowDebugMessage("channels.getAdminedPublicChannels error " + error);
}
}
public SettingsWallPaperViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator)
: base(protoService, cacheService, settingsService, aggregator)
{
Items = new MvxObservableCollection <Wallpaper>();
ProtoService.Send(new GetWallpapers(), result =>
{
if (result is Wallpapers wallpapers)
{
var items = wallpapers.WallpapersValue.ToList();
var predefined = items.FirstOrDefault(x => x.Id == 1000001);
if (predefined != null)
{
items.Remove(predefined);
items.Insert(0, predefined);
}
BeginOnUIThread(() =>
{
Items.ReplaceWith(items);
UpdateView();
});
}
});
LocalCommand = new RelayCommand(LocalExecute);
DoneCommand = new RelayCommand(DoneExecute);
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
var input = await DeviceInformation.FindAllAsync(MediaDevice.GetAudioCaptureSelector());
if (input != null)
{
Input.ReplaceWith(input);
_selectedInput = input.FirstOrDefault(x => x.Id == _voipService.CurrentAudioInput) ?? input.FirstOrDefault(x => x.Id == MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Communications));
RaisePropertyChanged(() => SelectedInput);
}
var output = await DeviceInformation.FindAllAsync(MediaDevice.GetAudioRenderSelector());
if (output != null)
{
Output.ReplaceWith(output);
_selectedOutput = output.FirstOrDefault(x => x.Id == _voipService.CurrentAudioOutput) ?? output.FirstOrDefault(x => x.Id == MediaDevice.GetDefaultAudioRenderId(AudioDeviceRole.Communications));
RaisePropertyChanged(() => SelectedOutput);
}
_inputVolume = _voipService.CurrentVolumeInput;
_outputVolume = _voipService.CurrentVolumeOutput;
RaisePropertyChanged(() => InputVolume);
RaisePropertyChanged(() => OutputVolume);
}
protected async void LoadAdminedPublicChannels()
{
if (AdminedPublicChannels.Count > 0)
{
return;
}
var response = await ProtoService.SendAsync(new GetCreatedPublicChats());
if (response is Telegram.Td.Api.Chats chats)
{
var result = new List <Chat>();
foreach (var id in chats.ChatIds)
{
var chat = ProtoService.GetChat(id);
if (chat != null)
{
result.Add(chat);
}
}
AdminedPublicChannels.ReplaceWith(result);
}
else if (response is Error error)
{
Logs.Logger.Error(Logs.Target.API, "channels.getAdminedPublicChannels error " + error);
}
}
private async Task RefreshThemesAsync()
{
Items.ReplaceWith(await _themeService.GetThemesAsync(false));
Custom.ReplaceWith(await _themeService.GetThemesAsync(true));
AreCustomThemesAvailable = Custom.Count > 0;
}
//The Initialize function is an overridden method, as part of the MvxViewModel class,
//that is automatically run when a MvxViewModel object is instantiated.
public override Task Initialize()
{
SQLObjects = new MvxObservableCollection <SQLExampleObject>();
SQLObjects.ReplaceWith(sql.ReturnList());
return(base.Initialize());
}
public override async Task Initialize()
{
await base.Initialize();
var beers = await _restService.GetBeers();
BeersList.ReplaceWith(beers.Select(b => new BeerItem(b)));
}
private void UpdateSupergroupFullInfo(Chat chat, Supergroup group, SupergroupFullInfo fullInfo)
{
Delegate?.UpdateSupergroupFullInfo(chat, group, fullInfo);
if (fullInfo.LinkedChatId != 0)
{
var linkedChat = CacheService.GetChat(fullInfo.LinkedChatId);
if (linkedChat != null)
{
Items.ReplaceWith(new[] { linkedChat });
}
else
{
LoadSuitableChats();
}
}
else
{
LoadSuitableChats();
}
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
Items.ReplaceWith(CacheService.ChatFilters);
var response = await ProtoService.SendAsync(new GetRecommendedChatFilters());
if (response is RecommendedChatFilters filters)
{
Recommended.ReplaceWith(filters.ChatFilters);
}
Aggregator.Subscribe(this);
}
public void CollectionShouldBeUpdated(params int[] newItems)
{
Setup();
var items = new MvxObservableCollection <int> {
1, 2, 3, 4, 5, 6
};
var sut = new WrappedObservableCollection <int, string>(items, Factory);
items.ReplaceWith(newItems);
Assert.AreEqual(Transform(newItems), sut);
}
public void CollectionShouldBeUpdated(params int[][] newItems)
{
Setup();
var items = new MvxObservableCollection <int[]>(new[] { new[] { 1, 2 }, new[] { 3 }, new[] { 4, 5, 6 } });
var flatItems = GetFlatItems(newItems).ToArray();
var flatCount = flatItems.Length;
var sut = new FlatObservableCollection <int>(items);
items.ReplaceWith(newItems);
Assert.AreEqual(flatCount, sut.Count);
Assert.AreEqual(flatItems, sut);
}
public void ResetEventShouldBeRaised(params int[][] newItems)
{
Setup();
var events = new List <NotifyCollectionChangedEventArgs>();
var items = new MvxObservableCollection <int[]>(new[] { new[] { 1, 2 }, new[] { 3 }, new[] { 4, 5, 6 } });
var sut = new FlatObservableCollection <int>(items);
sut.CollectionChanged += (_, args) => events.Add(args);
items.ReplaceWith(newItems);
Assert.AreEqual(1, events.Count);
Assert.AreEqual(NotifyCollectionChangedAction.Reset, events[0].Action);
}
public SettingsWallPaperViewModel(IMTProtoService protoService, ICacheService cacheService, ITelegramEventAggregator aggregator)
: base(protoService, cacheService, aggregator)
{
Items = new MvxObservableCollection <TLWallPaperBase>();
ProtoService.GetWallpapersAsync(result =>
{
var defa = result.FirstOrDefault(x => x.Id == 1000001);
if (defa != null)
{
result.Remove(defa);
result.Insert(0, defa);
}
Items.ReplaceWith(result);
UpdateView();
});
}
public void ResetEventShouldBeRaised(params int[] newItems)
{
Setup();
var events = new List <NotifyCollectionChangedEventArgs>();
var items = new MvxObservableCollection <int> {
1, 2, 3, 4, 5, 6
};
var sut = new WrappedObservableCollection <int, string>(items, Factory);
sut.CollectionChanged += (_, args) => events.Add(args);
items.ReplaceWith(newItems);
Assert.AreEqual(1, events.Count);
Assert.AreEqual(NotifyCollectionChangedAction.Reset, events[0].Action);
}
private async void LoadAdminedPublicChannels()
{
if (AdminedPublicChannels.Count > 0)
{
return;
}
var response = await ProtoService.GetAdminedPublicChannelsAsync();
if (response.IsSucceeded)
{
AdminedPublicChannels.ReplaceWith(response.Result.Chats.OfType <TLChannel>());
}
else
{
Execute.ShowDebugMessage("channels.getAdminedPublicChannels error " + response.Error);
}
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, NavigationState state)
{
Items.ReplaceWith(CacheService.ChatFilters);
if (Items.Count < 10)
{
var response = await ProtoService.SendAsync(new GetRecommendedChatFilters());
if (response is RecommendedChatFilters filters)
{
Recommended.ReplaceWith(filters.ChatFilters);
}
}
else
{
Recommended.Clear();
}
Aggregator.Subscribe(this);
}
public SettingsWallpapersViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator)
: base(protoService, cacheService, settingsService, aggregator)
{
Items = new MvxObservableCollection <Background>();
ProtoService.Send(new GetBackgrounds(Settings.Appearance.IsDarkTheme()), result =>
{
if (result is Backgrounds wallpapers)
{
var items = wallpapers.BackgroundsValue.Where(x => !(x.Type is BackgroundTypePattern)).ToList();
var id = Settings.Wallpaper.SelectedBackground;
var predefined = items.FirstOrDefault(x => x.Id == 1000001);
if (predefined != null)
{
items.Remove(predefined);
items.Insert(0, predefined);
}
var selected = items.FirstOrDefault(x => x.Id == id);
if (selected != null)
{
items.Remove(selected);
items.Insert(0, selected);
}
else if (id == Constants.WallpaperLocalId)
{
//items.Insert(0, selected = new Background(Constants.WallpaperLocalId, new PhotoSize[0], 0));
}
BeginOnUIThread(() =>
{
SelectedItem = selected;
Items.ReplaceWith(items);
});
}
});
LocalCommand = new RelayCommand(LocalExecute);
}
