Files
Chronos/src/Titano.App/Sections/WelcomeViewModel.cs
T
Claude ec297914db fix(app): offer the usage counts consent only in builds with TitanoAdsEnabled
RF-3: the anonymous usage counts checkbox (Welcome and Settings › General) promised a
daily ping that does not exist; BRIEF §21 puts that consent inside monetization, which
ships disabled until the human flips TitanoAdsEnabled=true. Directory.Build.props now
defines the property (default false) and stamps it into every assembly as metadata;
ProductFeatures.AdsEnabled reads it, and both checkboxes and the Settings search
keyword follow it. The unused Shell.Welcome.Consent sentence is removed from every
culture.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-12 09:30:42 +00:00

235 lines
7.8 KiB
C#

using System.Collections.Specialized;
using System.Windows.Input;
using Titano.App.Infrastructure;
using Titano.App.Server;
using Titano.App.Settings;
using Titano.App.Shell;
using Titano.Core.Diagnostics;
using Titano.Core.Localization;
using Titano.Ui.Mvvm;
namespace Titano.App.Sections;
/// <summary>Where the time-lapses live (first run).</summary>
public enum WelcomeChoice
{
LocalArchive,
AdoptFolder,
Server,
}
/// <summary>
/// First run (BRIEF §12.1, Welcome.html): create a local archive, adopt an existing folder or connect to a server,
/// plus the language and the anonymous-usage consent. Shown once; the archive actions go through
/// <see cref="IArchiveSetup"/>.
/// </summary>
public sealed class WelcomeViewModel : LocalizedViewModel
{
private readonly ShellViewModel _shell;
private WelcomeChoice _choice = WelcomeChoice.LocalArchive;
private string _localRoot;
private string? _adoptFolder;
private bool _isBusy;
public WelcomeViewModel(ShellViewModel shell)
{
_shell = shell;
_localRoot = shell.Services.Settings.LastArchivePath ?? ArchiveLocations.SuggestRoot();
ChooseCommand = new RelayCommand(p =>
{
if (p is WelcomeChoice choice) Choice = choice;
else if (p is string name && Enum.TryParse<WelcomeChoice>(name, out var parsed)) Choice = parsed;
});
ChangeRootCommand = new RelayCommand(ChangeRoot);
ChooseAdoptCommand = new RelayCommand(() => PickAdoptFolder());
ContinueCommand = new AsyncRelayCommand(ContinueAsync, () => !_isBusy);
shell.Services.Server.Discovered.CollectionChanged += OnDiscovered;
if (!shell.Services.Environment.IsCapture) shell.Services.Server.StartDiscovery();
}
public ICommand ChooseCommand { get; }
public ICommand ChangeRootCommand { get; }
public ICommand ChooseAdoptCommand { get; }
public ICommand ContinueCommand { get; }
public WelcomeChoice Choice
{
get => _choice;
set
{
if (!Set(ref _choice, value)) return;
OnPropertyChanged(nameof(IsLocal));
OnPropertyChanged(nameof(IsAdopt));
OnPropertyChanged(nameof(IsServer));
}
}
public bool IsLocal
{
get => _choice == WelcomeChoice.LocalArchive;
set
{
if (value) Choice = WelcomeChoice.LocalArchive;
}
}
public bool IsAdopt
{
get => _choice == WelcomeChoice.AdoptFolder;
set
{
if (value) Choice = WelcomeChoice.AdoptFolder;
}
}
public bool IsServer
{
get => _choice == WelcomeChoice.Server;
set
{
if (value) Choice = WelcomeChoice.Server;
}
}
public string LocalRoot
{
get => _localRoot;
private set
{
if (Set(ref _localRoot, value)) OnPropertyChanged(nameof(LocalDetail));
}
}
/// <summary>"D:\TitanoArchive · 1.8 TB free" (the path left to right in every language).</summary>
public string LocalDetail => ArchiveLocations.FreeSpace(_localRoot) is { } free
? Loc.L("Shell.Welcome.Local.Detail", Formatting.LeftToRight(_localRoot), Formatting.Bytes(free))
: Formatting.LeftToRight(_localRoot);
/// <summary>The chosen folder to adopt; null until picked.</summary>
public string? AdoptDetail => _adoptFolder is { } folder ? Formatting.LeftToRight(folder) : null;
public bool HasAdoptDetail => _adoptFolder is not null;
/// <summary>The first server announced on the LAN (or the saved one).</summary>
public DiscoveredServer? FoundServer =>
_shell.Services.Server.Discovered.FirstOrDefault()
?? (_shell.Services.Settings.ServerUrl is { } saved ? new DiscoveredServer(saved, saved) : null);
/// <summary>"Studio NAS on this network · https://nas.local:8443".</summary>
public string? ServerDetail => FoundServer is { } s
? s.Name == s.Address ? Formatting.LeftToRight(s.Address) : Loc.L("Shell.Welcome.Server.Found", s.Name, Formatting.LeftToRight(s.Address))
: null;
public bool HasServerDetail => ServerDetail is not null;
/// <summary>A server was heard on the LAN (the green dot).</summary>
public bool IsServerDiscovered => _shell.Services.Server.Discovered.Count > 0;
public IReadOnlyList<LanguageOption> Languages => LanguageCatalog.Available;
public LanguageOption SelectedLanguage
{
get => LanguageCatalog.Match(Loc.Culture);
set
{
if (value is null || value == SelectedLanguage) return;
_shell.Services.Settings.Language = value.Code;
UiLanguage.Apply(value.Code);
_shell.Services.SaveSettings();
}
}
/// <summary>The usage counts consent belongs to monetization (BRIEF §21): only builds with it enabled offer it.</summary>
public bool ShowsUsageCounts => ProductFeatures.AdsEnabled;
public bool UsageCounts
{
get => _shell.Services.Settings.AnonymousUsageCounts;
set
{
_shell.Services.Settings.AnonymousUsageCounts = value;
OnPropertyChanged();
}
}
public bool IsBusy
{
get => _isBusy;
private set => Set(ref _isBusy, value);
}
/// <summary>Sample state for screenshots: a server heard on the LAN.</summary>
internal void ShowDiscovered(DiscoveredServer server)
{
if (!_shell.Services.Server.Discovered.Contains(server)) _shell.Services.Server.Discovered.Add(server);
}
public override void Dispose()
{
_shell.Services.Server.Discovered.CollectionChanged -= OnDiscovered;
base.Dispose();
}
private void OnDiscovered(object? sender, NotifyCollectionChangedEventArgs e)
{
OnPropertyChanged(nameof(FoundServer));
OnPropertyChanged(nameof(ServerDetail));
OnPropertyChanged(nameof(HasServerDetail));
OnPropertyChanged(nameof(IsServerDiscovered));
}
private void ChangeRoot()
{
var folder = _shell.Services.Dialogs.PickFolder(Loc.L("Shell.Welcome.Local.PickTitle"), LocalRoot);
if (folder is null) return;
LocalRoot = folder;
Choice = WelcomeChoice.LocalArchive;
}
private bool PickAdoptFolder()
{
var folder = _shell.Services.Dialogs.PickFolder(Loc.L("Library.Adopt.Title"));
if (folder is null) return false;
_adoptFolder = folder;
OnPropertyChanged(nameof(AdoptDetail));
OnPropertyChanged(nameof(HasAdoptDetail));
Choice = WelcomeChoice.AdoptFolder;
return true;
}
private async Task ContinueAsync()
{
IsBusy = true;
try
{
switch (_choice)
{
case WelcomeChoice.LocalArchive:
if (ArchiveLocations.Validate(LocalRoot) is { } problem)
{
_shell.Notify(problem, isError: true);
return;
}
if (!await ArchiveActions.TryAsync(_shell, s => s.CreateAsync(LocalRoot))) return;
break;
case WelcomeChoice.AdoptFolder:
if (_adoptFolder is null && !PickAdoptFolder()) return;
if (!await ArchiveActions.TryAsync(_shell, s => s.AdoptAsync(_adoptFolder!))) return;
break;
case WelcomeChoice.Server:
if (FoundServer is { } server) _shell.Server.Address = server.Address;
break;
}
_shell.Services.SaveSettings();
_shell.CompleteWelcome();
Log.Info("app", $"First run completed: {_choice}");
if (_choice == WelcomeChoice.Server) _shell.Navigate(SectionKey.Server);
else await _shell.Library.RefreshAsync();
}
finally
{
IsBusy = false;
}
}
}