public SettingsViewModel(
ITranslationsService translationsService,
IFilePickerService filePickerService,
IPackagingService packagingService,
ISettingsService settingsService,
IPlatformService platformService,
IDialogService dialogService,
IOpmlService opmlService)
{
Theme = string.Empty;
Version = packagingService.Version;
(LoadImages, NeedBanners) = (true, true);
(FontSize, NotifyPeriod, MaxArticlesPerFeed) = (0, 0, 0);
LeaveFeedback = new ObservableCommand(packagingService.LeaveFeedback);
LeaveReview = new ObservableCommand(packagingService.LeaveReview);
ImportOpml = new ObservableCommand(async() =>
{
var stream = await filePickerService.PickFileForReadAsync();
await opmlService.ImportOpmlFeedsAsync(stream);
});
ExportOpml = new ObservableCommand(async() =>
{
var stream = await filePickerService.PickFileForWriteAsync();
await opmlService.ExportOpmlFeedsAsync(stream);
});
Reset = new ObservableCommand(async() =>
{
var response = await dialogService.ShowDialogForConfirmation(
translationsService.Resolve("ResetAppNoRestore"),
translationsService.Resolve("Notification"));
if (response)
{
await platformService.ResetApp();
}
});
Load = new ObservableCommand(async() =>
{
await Task.WhenAll(
StartTracking(NotifyPeriod, "NotifyPeriod", platformService.RegisterBackgroundTask),
StartTracking(MaxArticlesPerFeed, "MaxArticlesPerFeed", o => Task.CompletedTask),
StartTracking(NeedBanners, "NeedBanners", o => Task.CompletedTask),
StartTracking(LoadImages, "LoadImages", o => Task.CompletedTask),
StartTracking(FontSize, "FontSize", o => Task.CompletedTask),
StartTracking(Theme, "Theme", platformService.RegisterTheme)
);
});
async Task StartTracking <T>(ObservableProperty <T> property, string key,
Func <T, Task> callback) where T : IConvertible
{
property.Value = await settingsService.GetAsync <T>(key);
property.PropertyChanged += async(o, args) =>
{
var value = property.Value;
await callback.Invoke(value);
await settingsService.SetAsync(key, value);
};
}
}
private async Task DoImport()
{
var stream = await _filePickerService.PickFileForReadAsync();
var success = await _opmlService.ImportOpml(stream);
if (success)
{
await ImportSuccess.Handle(Unit.Default);
}
}
public SettingViewModel(
IFilePickerService filePickerService,
IPackagingService packagingService,
IPlatformService platformService,
ISettingManager settingManager,
IOpmlService opmlService)
{
Version = packagingService.Version;
LeaveFeedback = ReactiveCommand.CreateFromTask(packagingService.LeaveFeedback);
Review = ReactiveCommand.CreateFromTask(packagingService.LeaveReview);
ImportSuccess = new Interaction <Unit, bool>();
Import = ReactiveCommand.CreateFromTask(async() =>
{
var stream = await filePickerService.PickFileForReadAsync();
var success = await opmlService.ImportOpmlFeedsAsync(stream);
if (success)
{
await ImportSuccess.Handle(Unit.Default);
}
});
ExportSuccess = new Interaction <Unit, bool>();
Export = ReactiveCommand.CreateFromTask(async() =>
{
var stream = await filePickerService.PickFileForWriteAsync();
var success = await opmlService.ExportOpmlFeedsAsync(stream);
if (success)
{
await ExportSuccess.Handle(Unit.Default);
}
});
ResetConfirm = new Interaction <Unit, bool>();
Reset = ReactiveCommand.CreateFromTask(async() =>
{
var response = await ResetConfirm.Handle(Unit.Default);
if (response)
{
await platformService.ResetApp();
}
});
Load = ReactiveCommand.CreateFromTask(async() =>
{
var settings = await settingManager.Read();
Track(x => x.Period, (s, x) => s.Period = x, settings.Period, platformService.RegisterBackgroundTask);
Track(x => x.Theme, (s, x) => s.Theme = x, settings.Theme, platformService.RegisterTheme);
Track(x => x.Banners, (s, x) => s.Banners = x, settings.Banners);
Track(x => x.Images, (s, x) => s.Images = x, settings.Images);
Track(x => x.Read, (s, x) => s.Read = x, settings.Read);
Track(x => x.Font, (s, x) => s.Font = x, settings.Font);
Track(x => x.Max, (s, x) => s.Max = x, settings.Max);
void Track <T>(
Expression <Func <SettingViewModel, T> > bind,
Action <Settings, T> assign, T initial,
Func <T, Task> callback = null)
{
var memberExpression = (MemberExpression)bind.Body;
var property = (PropertyInfo)memberExpression.Member;
property.SetValue(this, initial);
this.WhenAnyValue(bind)
.Do(x => assign.Invoke(settings, x))
.Do(async x => await settingManager.Write(settings))
.Where(x => callback != null)
.Subscribe(async x => await callback(x));
}
});
}