merge: Titano Uploader (queue, watch folders, tray, resumable uploads)

This commit is contained in:
Claude committed 2026-10-02 10:40:07 +00:00
commit 96bc2cafbe
52 files changed
+6384 -1

No files matched your search

+37
View File
@@ -54,6 +54,43 @@
<data name="Tooltips.Shell.CollapseRail" xml:space="preserve"><value>Collapse navigation to icons</value></data>
<data name="Tooltips.Shell.ExpandRail" xml:space="preserve"><value>Show navigation names</value></data>
<data name="Tooltips.Shell.StopJob" xml:space="preserve"><value>Stop the current job · it can be resumed later</value></data>
<data name="Tooltips.Uploader.AddWatchFolder" xml:space="preserve"><value>Add a folder to watch</value></data>
<data name="Tooltips.Uploader.Browse" xml:space="preserve"><value>Pick files, a folder or a card</value></data>
<data name="Tooltips.Uploader.BrowseFiles" xml:space="preserve"><value>Pick one or more photos</value></data>
<data name="Tooltips.Uploader.BrowseFolder" xml:space="preserve"><value>Pick a folder or a card; every photo inside is added</value></data>
<data name="Tooltips.Uploader.CancelTrust" xml:space="preserve"><value>Do not connect to this server</value></data>
<data name="Tooltips.Uploader.ChooseSequence" xml:space="preserve"><value>Choose the sequence</value></data>
<data name="Tooltips.Uploader.CloseSettings" xml:space="preserve"><value>Close settings</value></data>
<data name="Tooltips.Uploader.ConfirmDelete" xml:space="preserve"><value>Delete each source file once the server has verified it</value></data>
<data name="Tooltips.Uploader.DeleteSource" xml:space="preserve"><value>Delete the local file only after the server has confirmed its hash; asks before turning on</value></data>
<data name="Tooltips.Uploader.DiscoveredServer" xml:space="preserve"><value>Titano Server found on this network · click to use it</value></data>
<data name="Tooltips.Uploader.Fingerprint" xml:space="preserve"><value>SHA-256 fingerprint of the server certificate</value></data>
<data name="Tooltips.Uploader.KeepFiles" xml:space="preserve"><value>Leave source files where they are</value></data>
<data name="Tooltips.Uploader.Limit" xml:space="preserve"><value>Bandwidth limit in MB/s; 0 means no limit</value></data>
<data name="Tooltips.Uploader.MinimizeToTray" xml:space="preserve"><value>Closing the window keeps the uploader running in the tray</value></data>
<data name="Tooltips.Uploader.NewTitle" xml:space="preserve"><value>Title of the new sequence; leave empty to let the server name it</value></data>
<data name="Tooltips.Uploader.Password" xml:space="preserve"><value>Your password; only a sign-in token is kept, encrypted for your Windows account</value></data>
<data name="Tooltips.Uploader.Pause" xml:space="preserve"><value>Pause; the queue survives a restart</value></data>
<data name="Tooltips.Uploader.Quota" xml:space="preserve"><value>Space left in your quota on the server</value></data>
<data name="Tooltips.Uploader.RemoveWatchFolder" xml:space="preserve"><value>Stop watching this folder; files already uploaded stay on the server</value></data>
<data name="Tooltips.Uploader.Resume" xml:space="preserve"><value>Resume uploading</value></data>
<data name="Tooltips.Uploader.Retry" xml:space="preserve"><value>Try again</value></data>
<data name="Tooltips.Uploader.RetryItem" xml:space="preserve"><value>Try this file again now</value></data>
<data name="Tooltips.Uploader.ServerAddress" xml:space="preserve"><value>Address of the Titano Server, such as https://nas.local:8443</value></data>
<data name="Tooltips.Uploader.Settings" xml:space="preserve"><value>Server, sign in, bandwidth, startup, tray</value></data>
<data name="Tooltips.Uploader.SignIn" xml:space="preserve"><value>Check the server certificate and sign in</value></data>
<data name="Tooltips.Uploader.SignOut" xml:space="preserve"><value>Sign out and forget the saved token</value></data>
<data name="Tooltips.Uploader.StartWithWindows" xml:space="preserve"><value>Run when you sign in to Windows</value></data>
<data name="Tooltips.Uploader.Stop" xml:space="preserve"><value>Stop and clear the queue; uploaded files stay on the server</value></data>
<data name="Tooltips.Uploader.TargetNew" xml:space="preserve"><value>Create one new sequence with a title you type</value></data>
<data name="Tooltips.Uploader.TargetSequence" xml:space="preserve"><value>Add every file to one existing sequence</value></data>
<data name="Tooltips.Uploader.TargetSessions" xml:space="preserve"><value>The server splits the files into sessions and creates the sequences</value></data>
<data name="Tooltips.Uploader.Trust" xml:space="preserve"><value>Remember this certificate; trust it only if the fingerprint matches the one on the server</value></data>
<data name="Tooltips.Uploader.User" xml:space="preserve"><value>Your user name on the Titano Server</value></data>
<data name="Tooltips.Uploader.WatchFolder" xml:space="preserve"><value>Checked every {0}; a file is uploaded once it has stopped growing · click to change or remove</value></data>
<data name="Tooltips.Uploader.WatchFolderMissing" xml:space="preserve"><value>The folder cannot be reached; it is checked again every {0} · click to change or remove</value></data>
<data name="Tooltips.Uploader.WatchFolderNetwork" xml:space="preserve"><value>Network share; polled every {0} because change notifications are unreliable on SMB · click to change or remove</value></data>
<data name="Tooltips.Uploader.WatchInterval" xml:space="preserve"><value>Check the folder at this interval</value></data>
<data name="Tooltips.Window.Close" xml:space="preserve"><value>Close</value></data>
<data name="Tooltips.Window.Maximize" xml:space="preserve"><value>Maximize</value></data>
<data name="Tooltips.Window.Minimize" xml:space="preserve"><value>Minimize</value></data>
+107
View File
@@ -0,0 +1,107 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader>
<resheader name="version"><value>2.0</value></resheader>
<resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Uploader.Action.AddFolder" xml:space="preserve"><value>Add folder</value></data>
<data name="Uploader.Action.Close" xml:space="preserve"><value>Close</value></data>
<data name="Uploader.Action.Pause" xml:space="preserve"><value>Pause</value></data>
<data name="Uploader.Action.Resume" xml:space="preserve"><value>Resume</value></data>
<data name="Uploader.Action.Retry" xml:space="preserve"><value>Retry</value></data>
<data name="Uploader.Action.Stop" xml:space="preserve"><value>Stop</value></data>
<data name="Uploader.App.Title" xml:space="preserve"><value>Titano Uploader</value><comment>invariant</comment></data>
<data name="Uploader.Browse.AllFiles" xml:space="preserve"><value>All files</value></data>
<data name="Uploader.Browse.Button" xml:space="preserve"><value>Browse…</value></data>
<data name="Uploader.Browse.Files" xml:space="preserve"><value>Files…</value></data>
<data name="Uploader.Browse.FilesTitle" xml:space="preserve"><value>Add photos</value></data>
<data name="Uploader.Browse.Folder" xml:space="preserve"><value>Folder or card…</value></data>
<data name="Uploader.Browse.FolderTitle" xml:space="preserve"><value>Folder or card</value></data>
<data name="Uploader.Browse.Photos" xml:space="preserve"><value>Photos</value></data>
<data name="Uploader.Browse.WatchTitle" xml:space="preserve"><value>Watch a folder</value></data>
<data name="Uploader.Connect.AddressPlaceholder" xml:space="preserve"><value>https://nas.local:8443</value><comment>invariant</comment></data>
<data name="Uploader.Connect.Error.BadCredentials" xml:space="preserve"><value>Wrong user name or password.</value><comment>long</comment></data>
<data name="Uploader.Connect.Error.Failed" xml:space="preserve"><value>The server reported an error.</value><comment>long</comment></data>
<data name="Uploader.Connect.Error.InvalidAddress" xml:space="preserve"><value>Enter an address such as https://nas.local:8443.</value><comment>long</comment></data>
<data name="Uploader.Connect.Error.NotTitano" xml:space="preserve"><value>This address is not a Titano Server.</value><comment>long</comment></data>
<data name="Uploader.Connect.Error.Unreachable" xml:space="preserve"><value>The server did not answer.</value><comment>long</comment></data>
<data name="Uploader.Connect.Error.Untrusted" xml:space="preserve"><value>The server certificate was not trusted.</value><comment>long</comment></data>
<data name="Uploader.Connect.Found" xml:space="preserve"><value>Found</value></data>
<data name="Uploader.Connect.Password" xml:space="preserve"><value>Password</value></data>
<data name="Uploader.Connect.Server" xml:space="preserve"><value>Server</value></data>
<data name="Uploader.Connect.SignIn" xml:space="preserve"><value>Sign in</value></data>
<data name="Uploader.Connect.Title" xml:space="preserve"><value>Connect to server</value></data>
<data name="Uploader.Connect.User" xml:space="preserve"><value>User</value></data>
<data name="Uploader.Delete.Accept" xml:space="preserve"><value>Delete after upload</value></data>
<data name="Uploader.Delete.Keep" xml:space="preserve"><value>Keep files</value></data>
<data name="Uploader.Delete.Message" xml:space="preserve"><value>Each file is deleted from this PC only after the server has verified its hash.</value><comment>long</comment></data>
<data name="Uploader.Delete.Title" xml:space="preserve"><value>Delete source files?</value></data>
<data name="Uploader.Drop.Message" xml:space="preserve"><value>Drop photos, folders or a card here</value><comment>long</comment></data>
<data name="Uploader.Failure.FileChanged" xml:space="preserve"><value>The file changed while it was read.</value><comment>long</comment></data>
<data name="Uploader.Failure.FileMissing" xml:space="preserve"><value>The file is no longer there.</value><comment>long</comment></data>
<data name="Uploader.Failure.FileUnreadable" xml:space="preserve"><value>The file could not be read.</value><comment>long</comment></data>
<data name="Uploader.Failure.ServerRejected" xml:space="preserve"><value>The server refused the file: {0}</value><comment>long</comment></data>
<data name="Uploader.Failure.Unexpected" xml:space="preserve"><value>The upload failed; the log has the details.</value><comment>long</comment></data>
<data name="Uploader.Header.NotConnected" xml:space="preserve"><value>Not connected</value></data>
<data name="Uploader.Header.Quota" xml:space="preserve"><value>{0} free of {1}</value></data>
<data name="Uploader.Limit.Label" xml:space="preserve"><value>Limit</value></data>
<data name="Uploader.Limit.Unit" xml:space="preserve"><value>MB/s</value><comment>invariant</comment></data>
<data name="Uploader.Options.DeleteSource" xml:space="preserve"><value>Delete after upload</value></data>
<data name="Uploader.Options.MinimizeToTray" xml:space="preserve"><value>Minimise to tray</value></data>
<data name="Uploader.Options.StartWithWindows" xml:space="preserve"><value>Start with Windows</value></data>
<data name="Uploader.Progress.Failed" xml:space="preserve"><value>{0:N0} failed</value></data>
<data name="Uploader.Progress.Retries.one" xml:space="preserve"><value>{0:N0} retry</value></data>
<data name="Uploader.Progress.Retries.other" xml:space="preserve"><value>{0:N0} retries</value></data>
<data name="Uploader.Progress.Sent" xml:space="preserve"><value>{0:N0} of {1:N0} sent</value></data>
<data name="Uploader.Progress.Verified" xml:space="preserve"><value>{0:N0} verified by the server</value></data>
<data name="Uploader.Queue.Done" xml:space="preserve"><value>Done</value></data>
<data name="Uploader.Queue.Empty" xml:space="preserve"><value>Nothing queued</value></data>
<data name="Uploader.Queue.Files.one" xml:space="preserve"><value>{0:N0} file</value></data>
<data name="Uploader.Queue.Files.other" xml:space="preserve"><value>{0:N0} files</value></data>
<data name="Uploader.Queue.Label" xml:space="preserve"><value>Queue</value></data>
<data name="Uploader.Queue.Left" xml:space="preserve"><value>{0} left</value></data>
<data name="Uploader.Queue.Paused" xml:space="preserve"><value>Paused</value></data>
<data name="Uploader.Queue.Waiting" xml:space="preserve"><value>Waiting for server</value></data>
<data name="Uploader.Settings.Bandwidth" xml:space="preserve"><value>Bandwidth</value></data>
<data name="Uploader.Settings.Files" xml:space="preserve"><value>Files</value></data>
<data name="Uploader.Settings.Server" xml:space="preserve"><value>Server</value></data>
<data name="Uploader.Settings.SignOut" xml:space="preserve"><value>Sign out</value></data>
<data name="Uploader.Settings.Startup" xml:space="preserve"><value>Startup</value></data>
<data name="Uploader.Settings.Title" xml:space="preserve"><value>Settings</value></data>
<data name="Uploader.Settings.User" xml:space="preserve"><value>User</value></data>
<data name="Uploader.State.Failed" xml:space="preserve"><value>Failed</value></data>
<data name="Uploader.State.Hashing" xml:space="preserve"><value>Hashing</value></data>
<data name="Uploader.State.Queued" xml:space="preserve"><value>Queued</value></data>
<data name="Uploader.State.Skipped" xml:space="preserve"><value>On server</value></data>
<data name="Uploader.State.Uploading" xml:space="preserve"><value>Uploading</value></data>
<data name="Uploader.State.Verified" xml:space="preserve"><value>Verified</value></data>
<data name="Uploader.Status.Connected" xml:space="preserve"><value>Connected</value></data>
<data name="Uploader.Status.Offline" xml:space="preserve"><value>Offline</value></data>
<data name="Uploader.Status.SignedOut" xml:space="preserve"><value>Signed out</value></data>
<data name="Uploader.Status.SigningIn" xml:space="preserve"><value>Signing in</value></data>
<data name="Uploader.Target.Label" xml:space="preserve"><value>Target</value></data>
<data name="Uploader.Target.New" xml:space="preserve"><value>New</value></data>
<data name="Uploader.Target.Sequence" xml:space="preserve"><value>Sequence</value></data>
<data name="Uploader.Target.Sessions" xml:space="preserve"><value>Group into sessions</value></data>
<data name="Uploader.Target.TitlePlaceholder" xml:space="preserve"><value>Title</value></data>
<data name="Uploader.Toast.Added.one" xml:space="preserve"><value>{0:N0} file added</value></data>
<data name="Uploader.Toast.Added.other" xml:space="preserve"><value>{0:N0} files added</value></data>
<data name="Uploader.Toast.CertificateChanged" xml:space="preserve"><value>The server certificate changed.</value><comment>long</comment></data>
<data name="Uploader.Toast.ChooseSequence" xml:space="preserve"><value>Choose a sequence first.</value></data>
<data name="Uploader.Toast.NothingFound" xml:space="preserve"><value>No new photos were found there.</value><comment>long</comment></data>
<data name="Uploader.Toast.SignedOut" xml:space="preserve"><value>The server ended the session.</value><comment>long</comment></data>
<data name="Uploader.Tray.Done.Message.one" xml:space="preserve"><value>{0:N0} file verified by the server</value><comment>long</comment></data>
<data name="Uploader.Tray.Done.Message.other" xml:space="preserve"><value>{0:N0} files verified by the server</value><comment>long</comment></data>
<data name="Uploader.Tray.Done.Title" xml:space="preserve"><value>Upload complete</value></data>
<data name="Uploader.Tray.Exit" xml:space="preserve"><value>Exit</value></data>
<data name="Uploader.Tray.Show" xml:space="preserve"><value>Show</value></data>
<data name="Uploader.Trust.Accept" xml:space="preserve"><value>Trust</value></data>
<data name="Uploader.Trust.Cancel" xml:space="preserve"><value>Cancel</value></data>
<data name="Uploader.Trust.Message" xml:space="preserve"><value>Compare this fingerprint with the one shown on the server.</value><comment>long</comment></data>
<data name="Uploader.Trust.Title" xml:space="preserve"><value>Trust this server?</value></data>
<data name="Uploader.Unit.PerSecond" xml:space="preserve"><value>{0}/s</value></data>
<data name="Uploader.Watch.Chip" xml:space="preserve"><value>{0} · every {1}</value></data>
<data name="Uploader.Watch.Every" xml:space="preserve"><value>Every {0}</value></data>
<data name="Uploader.Watch.Label" xml:space="preserve"><value>Watch folders</value></data>
<data name="Uploader.Watch.Remove" xml:space="preserve"><value>Remove</value></data>
</root>
+37
View File
@@ -54,6 +54,43 @@
<data name="Tooltips.Shell.CollapseRail" xml:space="preserve"><value>Riduci la navigazione alle icone</value></data>
<data name="Tooltips.Shell.ExpandRail" xml:space="preserve"><value>Mostra i nomi della navigazione</value></data>
<data name="Tooltips.Shell.StopJob" xml:space="preserve"><value>Ferma l'attività in corso · potrai riprenderla</value></data>
<data name="Tooltips.Uploader.AddWatchFolder" xml:space="preserve"><value>Aggiungi una cartella da controllare</value></data>
<data name="Tooltips.Uploader.Browse" xml:space="preserve"><value>Scegli file, una cartella o una scheda</value></data>
<data name="Tooltips.Uploader.BrowseFiles" xml:space="preserve"><value>Scegli una o più foto</value></data>
<data name="Tooltips.Uploader.BrowseFolder" xml:space="preserve"><value>Scegli una cartella o una scheda; vengono aggiunte tutte le foto contenute</value></data>
<data name="Tooltips.Uploader.CancelTrust" xml:space="preserve"><value>Non connetterti a questo server</value></data>
<data name="Tooltips.Uploader.ChooseSequence" xml:space="preserve"><value>Scegli la sequenza</value></data>
<data name="Tooltips.Uploader.CloseSettings" xml:space="preserve"><value>Chiudi le impostazioni</value></data>
<data name="Tooltips.Uploader.ConfirmDelete" xml:space="preserve"><value>Elimina ogni file originale dopo la verifica del server</value></data>
<data name="Tooltips.Uploader.DeleteSource" xml:space="preserve"><value>Elimina il file locale solo dopo che il server ne ha confermato l'hash; chiede conferma prima di attivarsi</value></data>
<data name="Tooltips.Uploader.DiscoveredServer" xml:space="preserve"><value>Titano Server trovato in questa rete · fai clic per usarlo</value></data>
<data name="Tooltips.Uploader.Fingerprint" xml:space="preserve"><value>Impronta SHA-256 del certificato del server</value></data>
<data name="Tooltips.Uploader.KeepFiles" xml:space="preserve"><value>Lascia i file originali dove sono</value></data>
<data name="Tooltips.Uploader.Limit" xml:space="preserve"><value>Limite di banda in MB/s; 0 significa nessun limite</value></data>
<data name="Tooltips.Uploader.MinimizeToTray" xml:space="preserve"><value>Chiudendo la finestra l'uploader resta attivo nell'area di notifica</value></data>
<data name="Tooltips.Uploader.NewTitle" xml:space="preserve"><value>Titolo della nuova sequenza; lascialo vuoto per farlo scegliere al server</value></data>
<data name="Tooltips.Uploader.Password" xml:space="preserve"><value>La tua password; viene conservato solo un token di accesso, cifrato per il tuo account Windows</value></data>
<data name="Tooltips.Uploader.Pause" xml:space="preserve"><value>Metti in pausa; la coda sopravvive a un riavvio</value></data>
<data name="Tooltips.Uploader.Quota" xml:space="preserve"><value>Spazio rimasto nella tua quota sul server</value></data>
<data name="Tooltips.Uploader.RemoveWatchFolder" xml:space="preserve"><value>Smetti di controllare questa cartella; i file già inviati restano sul server</value></data>
<data name="Tooltips.Uploader.Resume" xml:space="preserve"><value>Riprendi l'invio</value></data>
<data name="Tooltips.Uploader.Retry" xml:space="preserve"><value>Riprova</value></data>
<data name="Tooltips.Uploader.RetryItem" xml:space="preserve"><value>Riprova subito questo file</value></data>
<data name="Tooltips.Uploader.ServerAddress" xml:space="preserve"><value>Indirizzo del Titano Server, ad esempio https://nas.local:8443</value></data>
<data name="Tooltips.Uploader.Settings" xml:space="preserve"><value>Server, accesso, banda, avvio, area di notifica</value></data>
<data name="Tooltips.Uploader.SignIn" xml:space="preserve"><value>Controlla il certificato del server e accedi</value></data>
<data name="Tooltips.Uploader.SignOut" xml:space="preserve"><value>Esci e dimentica il token salvato</value></data>
<data name="Tooltips.Uploader.StartWithWindows" xml:space="preserve"><value>Avvia quando accedi a Windows</value></data>
<data name="Tooltips.Uploader.Stop" xml:space="preserve"><value>Ferma e svuota la coda; i file inviati restano sul server</value></data>
<data name="Tooltips.Uploader.TargetNew" xml:space="preserve"><value>Crea una nuova sequenza con il titolo che scrivi</value></data>
<data name="Tooltips.Uploader.TargetSequence" xml:space="preserve"><value>Aggiungi tutti i file a una sequenza esistente</value></data>
<data name="Tooltips.Uploader.TargetSessions" xml:space="preserve"><value>Il server divide i file in sessioni e crea le sequenze</value></data>
<data name="Tooltips.Uploader.Trust" xml:space="preserve"><value>Ricorda questo certificato; accettalo solo se l'impronta coincide con quella sul server</value></data>
<data name="Tooltips.Uploader.User" xml:space="preserve"><value>Il tuo nome utente sul Titano Server</value></data>
<data name="Tooltips.Uploader.WatchFolder" xml:space="preserve"><value>Controllata ogni {0}; un file viene inviato quando smette di crescere · fai clic per modificare o rimuovere</value></data>
<data name="Tooltips.Uploader.WatchFolderMissing" xml:space="preserve"><value>La cartella non è raggiungibile; viene ricontrollata ogni {0} · fai clic per modificare o rimuovere</value></data>
<data name="Tooltips.Uploader.WatchFolderNetwork" xml:space="preserve"><value>Condivisione di rete; controllata ogni {0} perché le notifiche di modifica non sono affidabili su SMB · fai clic per modificare o rimuovere</value></data>
<data name="Tooltips.Uploader.WatchInterval" xml:space="preserve"><value>Controlla la cartella con questo intervallo</value></data>
<data name="Tooltips.Window.Close" xml:space="preserve"><value>Chiudi</value></data>
<data name="Tooltips.Window.Maximize" xml:space="preserve"><value>Ingrandisci</value></data>
<data name="Tooltips.Window.Minimize" xml:space="preserve"><value>Riduci a icona</value></data>
+104
View File
@@ -0,0 +1,104 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader>
<resheader name="version"><value>2.0</value></resheader>
<resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Uploader.Action.AddFolder" xml:space="preserve"><value>Aggiungi cartella</value></data>
<data name="Uploader.Action.Close" xml:space="preserve"><value>Chiudi</value></data>
<data name="Uploader.Action.Pause" xml:space="preserve"><value>Pausa</value></data>
<data name="Uploader.Action.Resume" xml:space="preserve"><value>Riprendi</value></data>
<data name="Uploader.Action.Retry" xml:space="preserve"><value>Riprova</value></data>
<data name="Uploader.Action.Stop" xml:space="preserve"><value>Ferma</value></data>
<data name="Uploader.Browse.AllFiles" xml:space="preserve"><value>Tutti i file</value></data>
<data name="Uploader.Browse.Button" xml:space="preserve"><value>Sfoglia…</value></data>
<data name="Uploader.Browse.Files" xml:space="preserve"><value>File…</value></data>
<data name="Uploader.Browse.FilesTitle" xml:space="preserve"><value>Aggiungi foto</value></data>
<data name="Uploader.Browse.Folder" xml:space="preserve"><value>Cartella o scheda…</value></data>
<data name="Uploader.Browse.FolderTitle" xml:space="preserve"><value>Cartella o scheda</value></data>
<data name="Uploader.Browse.Photos" xml:space="preserve"><value>Foto</value></data>
<data name="Uploader.Browse.WatchTitle" xml:space="preserve"><value>Controlla una cartella</value></data>
<data name="Uploader.Connect.Error.BadCredentials" xml:space="preserve"><value>Nome utente o password errati.</value></data>
<data name="Uploader.Connect.Error.Failed" xml:space="preserve"><value>Il server ha segnalato un errore.</value></data>
<data name="Uploader.Connect.Error.InvalidAddress" xml:space="preserve"><value>Inserisci un indirizzo come https://nas.local:8443.</value></data>
<data name="Uploader.Connect.Error.NotTitano" xml:space="preserve"><value>Questo indirizzo non è un Titano Server.</value></data>
<data name="Uploader.Connect.Error.Unreachable" xml:space="preserve"><value>Il server non ha risposto.</value></data>
<data name="Uploader.Connect.Error.Untrusted" xml:space="preserve"><value>Il certificato del server non è stato accettato.</value></data>
<data name="Uploader.Connect.Found" xml:space="preserve"><value>Trovati</value></data>
<data name="Uploader.Connect.Password" xml:space="preserve"><value>Password</value></data>
<data name="Uploader.Connect.Server" xml:space="preserve"><value>Server</value></data>
<data name="Uploader.Connect.SignIn" xml:space="preserve"><value>Accedi</value></data>
<data name="Uploader.Connect.Title" xml:space="preserve"><value>Connetti al server</value></data>
<data name="Uploader.Connect.User" xml:space="preserve"><value>Utente</value></data>
<data name="Uploader.Delete.Accept" xml:space="preserve"><value>Elimina dopo l'invio</value></data>
<data name="Uploader.Delete.Keep" xml:space="preserve"><value>Mantieni i file</value></data>
<data name="Uploader.Delete.Message" xml:space="preserve"><value>Ogni file viene eliminato da questo PC solo dopo che il server ne ha verificato l'hash.</value></data>
<data name="Uploader.Delete.Title" xml:space="preserve"><value>Eliminare i file originali?</value></data>
<data name="Uploader.Drop.Message" xml:space="preserve"><value>Trascina qui foto, cartelle o una scheda</value></data>
<data name="Uploader.Failure.FileChanged" xml:space="preserve"><value>Il file è cambiato durante la lettura.</value></data>
<data name="Uploader.Failure.FileMissing" xml:space="preserve"><value>Il file non c'è più.</value></data>
<data name="Uploader.Failure.FileUnreadable" xml:space="preserve"><value>Impossibile leggere il file.</value></data>
<data name="Uploader.Failure.ServerRejected" xml:space="preserve"><value>Il server ha rifiutato il file: {0}</value></data>
<data name="Uploader.Failure.Unexpected" xml:space="preserve"><value>Invio non riuscito; i dettagli sono nel log.</value></data>
<data name="Uploader.Header.NotConnected" xml:space="preserve"><value>Non connesso</value></data>
<data name="Uploader.Header.Quota" xml:space="preserve"><value>{0} liberi su {1}</value></data>
<data name="Uploader.Limit.Label" xml:space="preserve"><value>Limite</value></data>
<data name="Uploader.Options.DeleteSource" xml:space="preserve"><value>Elimina dopo l'invio</value></data>
<data name="Uploader.Options.MinimizeToTray" xml:space="preserve"><value>Riduci nell'area notifiche</value></data>
<data name="Uploader.Options.StartWithWindows" xml:space="preserve"><value>Avvia con Windows</value></data>
<data name="Uploader.Progress.Failed" xml:space="preserve"><value>{0:N0} non riusciti</value></data>
<data name="Uploader.Progress.Retries.one" xml:space="preserve"><value>{0:N0} nuovo tentativo</value></data>
<data name="Uploader.Progress.Retries.other" xml:space="preserve"><value>{0:N0} nuovi tentativi</value></data>
<data name="Uploader.Progress.Sent" xml:space="preserve"><value>{0:N0} di {1:N0} inviati</value></data>
<data name="Uploader.Progress.Verified" xml:space="preserve"><value>{0:N0} verificati dal server</value></data>
<data name="Uploader.Queue.Done" xml:space="preserve"><value>Completato</value></data>
<data name="Uploader.Queue.Empty" xml:space="preserve"><value>Coda vuota</value></data>
<data name="Uploader.Queue.Files.one" xml:space="preserve"><value>{0:N0} file</value></data>
<data name="Uploader.Queue.Files.other" xml:space="preserve"><value>{0:N0} file</value></data>
<data name="Uploader.Queue.Label" xml:space="preserve"><value>Coda</value></data>
<data name="Uploader.Queue.Left" xml:space="preserve"><value>mancano {0}</value></data>
<data name="Uploader.Queue.Paused" xml:space="preserve"><value>In pausa</value></data>
<data name="Uploader.Queue.Waiting" xml:space="preserve"><value>In attesa del server</value></data>
<data name="Uploader.Settings.Bandwidth" xml:space="preserve"><value>Banda</value></data>
<data name="Uploader.Settings.Files" xml:space="preserve"><value>File</value></data>
<data name="Uploader.Settings.Server" xml:space="preserve"><value>Server</value></data>
<data name="Uploader.Settings.SignOut" xml:space="preserve"><value>Esci</value></data>
<data name="Uploader.Settings.Startup" xml:space="preserve"><value>Avvio</value></data>
<data name="Uploader.Settings.Title" xml:space="preserve"><value>Impostazioni</value></data>
<data name="Uploader.Settings.User" xml:space="preserve"><value>Utente</value></data>
<data name="Uploader.State.Failed" xml:space="preserve"><value>Non riuscito</value></data>
<data name="Uploader.State.Hashing" xml:space="preserve"><value>Calcolo hash</value></data>
<data name="Uploader.State.Queued" xml:space="preserve"><value>In coda</value></data>
<data name="Uploader.State.Skipped" xml:space="preserve"><value>Già sul server</value></data>
<data name="Uploader.State.Uploading" xml:space="preserve"><value>Invio</value></data>
<data name="Uploader.State.Verified" xml:space="preserve"><value>Verificato</value></data>
<data name="Uploader.Status.Connected" xml:space="preserve"><value>Connesso</value></data>
<data name="Uploader.Status.Offline" xml:space="preserve"><value>Non in linea</value></data>
<data name="Uploader.Status.SignedOut" xml:space="preserve"><value>Disconnesso</value></data>
<data name="Uploader.Status.SigningIn" xml:space="preserve"><value>Accesso in corso</value></data>
<data name="Uploader.Target.Label" xml:space="preserve"><value>Destinazione</value></data>
<data name="Uploader.Target.New" xml:space="preserve"><value>Nuova</value></data>
<data name="Uploader.Target.Sequence" xml:space="preserve"><value>Sequenza</value></data>
<data name="Uploader.Target.Sessions" xml:space="preserve"><value>Raggruppa in sessioni</value></data>
<data name="Uploader.Target.TitlePlaceholder" xml:space="preserve"><value>Titolo</value></data>
<data name="Uploader.Toast.Added.one" xml:space="preserve"><value>{0:N0} file aggiunto</value></data>
<data name="Uploader.Toast.Added.other" xml:space="preserve"><value>{0:N0} file aggiunti</value></data>
<data name="Uploader.Toast.CertificateChanged" xml:space="preserve"><value>Il certificato del server è cambiato.</value></data>
<data name="Uploader.Toast.ChooseSequence" xml:space="preserve"><value>Scegli prima una sequenza.</value></data>
<data name="Uploader.Toast.NothingFound" xml:space="preserve"><value>Nessuna nuova foto trovata.</value></data>
<data name="Uploader.Toast.SignedOut" xml:space="preserve"><value>Il server ha chiuso la sessione.</value></data>
<data name="Uploader.Tray.Done.Message.one" xml:space="preserve"><value>{0:N0} file verificato dal server</value></data>
<data name="Uploader.Tray.Done.Message.other" xml:space="preserve"><value>{0:N0} file verificati dal server</value></data>
<data name="Uploader.Tray.Done.Title" xml:space="preserve"><value>Invio completato</value></data>
<data name="Uploader.Tray.Exit" xml:space="preserve"><value>Esci</value></data>
<data name="Uploader.Tray.Show" xml:space="preserve"><value>Mostra</value></data>
<data name="Uploader.Trust.Accept" xml:space="preserve"><value>Accetta</value></data>
<data name="Uploader.Trust.Cancel" xml:space="preserve"><value>Annulla</value></data>
<data name="Uploader.Trust.Message" xml:space="preserve"><value>Confronta questa impronta con quella mostrata sul server.</value></data>
<data name="Uploader.Trust.Title" xml:space="preserve"><value>Accettare questo server?</value></data>
<data name="Uploader.Unit.PerSecond" xml:space="preserve"><value>{0}/s</value></data>
<data name="Uploader.Watch.Chip" xml:space="preserve"><value>{0} · ogni {1}</value></data>
<data name="Uploader.Watch.Every" xml:space="preserve"><value>Ogni {0}</value></data>
<data name="Uploader.Watch.Label" xml:space="preserve"><value>Cartelle controllate</value></data>
<data name="Uploader.Watch.Remove" xml:space="preserve"><value>Rimuovi</value></data>
</root>
+2 -1
View File
@@ -1,4 +1,5 @@
<Application x:Class="Titano.Uploader.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
ShutdownMode="OnExplicitShutdown">
</Application>
+338
View File
@@ -1,7 +1,345 @@
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Windows;
using System.Windows.Threading;
using Titano.Core.Diagnostics;
using Titano.Core.Localization;
using Titano.Ui.Mvvm;
using Titano.Ui.Theming;
using Titano.Uploader.DesignTime;
using Titano.Uploader.Infrastructure;
using Titano.Uploader.Interop;
using Titano.Uploader.Server;
using Titano.Uploader.Shell;
using Titano.Uploader.Uploads;
using Titano.Uploader.Watching;
namespace Titano.Uploader;
/// <summary>
/// Titano Uploader (BRIEF §15): one instance per session, logging, language and theme, the persisted queue, the
/// server session, watch folders and the tray icon. <c>--capture &lt;dir&gt;</c> renders screenshots and exits.
/// </summary>
public partial class App : Application
{
private const int TrayShow = 1;
private const int TrayPause = 2;
private const int TrayExit = 3;
private readonly CoalescingWriter _writer = new();
private FileLogSink? _log;
private SingleInstance? _instance;
private UploaderEnvironment? _environment;
private UploaderSettings? _settings;
private UploadQueue? _queue;
private ProcessedFileMemory? _memory;
private ServerSession? _session;
private UploadEngine? _engine;
private WatchFolderService? _watch;
private DiscoveryListener? _discovery;
private MainViewModel? _vm;
private Shell.MainWindow? _window;
private TrayIcon? _tray;
private DispatcherTimer? _persist;
private bool _queueDirty;
private bool _exiting;
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var command = CommandLine.Parse(e.Args);
_environment = UploaderEnvironment.Detect();
_log = new FileLogSink(_environment.LogDirectory, "uploader");
Log.SetSink(_log);
Log.Info("app", $"Titano Uploader {typeof(App).Assembly.GetName().Version} starting; data at {_environment.DataDirectory}");
HookUnhandledExceptions();
if (command.CaptureDirectory is { } captureDirectory)
{
RunCapture(captureDirectory);
return;
}
_instance = SingleInstance.TryAcquire();
if (_instance is null)
{
SingleInstance.HandOver([.. command.Paths.Select(Absolute).OfType<string>()]);
Log.Info("app", "Another uploader runs in this session; arguments handed over");
Shutdown();
return;
}
_settings = UploaderSettings.Load(_environment.SettingsPath);
ApplyLanguage(_settings.Language);
ThemeManager.Initialize(this, _settings.Theme);
BuildServices(_environment, _settings);
_instance.Listen(args => Dispatcher.BeginInvoke(() => OnHandOver(args)));
_session!.Start();
_engine!.Start();
_vm!.Start();
_vm.StartWatching();
UpdateTray();
UpdateDiscovery();
if (command.Paths.Count > 0) _ = _vm.EnqueueAsync(command.Paths);
if (command.StartInTray && _settings.MinimizeToTray) return;
if (command.StartInTray) _window!.WindowState = WindowState.Minimized;
_window!.Show();
}
protected override void OnExit(ExitEventArgs e)
{
_persist?.Stop();
_vm?.Dispose();
// Cancels transfers; interrupted items are written as queued and resume from the server's chunks.
_engine?.Dispose();
if (_queue is not null && _environment is not null)
{
Persist();
_writer.Flush(TimeSpan.FromSeconds(10));
}
if (_window is not null && _settings is not null) _window.SavePlacement();
SaveSettings();
_watch?.Dispose();
_discovery?.Dispose();
_session?.Dispose();
_tray?.Dispose();
_instance?.Dispose();
Log.Info("app", "Titano Uploader exiting");
_log?.Dispose();
base.OnExit(e);
}
private void BuildServices(UploaderEnvironment environment, UploaderSettings settings)
{
_queue = new UploadQueue();
QueueStore.Load(environment.QueuePath, _queue);
_memory = ProcessedFileMemory.Load(environment.WatchMemoryPath);
_session = new ServerSession(settings, SaveSettings);
_engine = new UploadEngine(_queue, _session, () => settings.DeleteAfterUpload);
_watch = new WatchFolderService(_memory, _queue.ContainsPath);
var startup = new RunKeyStartupRegistration();
startup.Refresh();
var dialogs = new UploaderDialogs();
_vm = new MainViewModel(new UploaderServices(settings, SaveSettings, _session, _queue, _engine, startup, dialogs, _watch, _memory, environment.LogDirectory));
_window = new Shell.MainWindow(_vm, settings);
dialogs.Owner = _window;
MainWindow = _window;
AsyncRelayCommand.Failed += _vm.ReportError;
_engine.ItemConfirmed += (_, item) =>
{
if (item.WatchRoot is { } root) _memory.Add(root, item.Path, item.Size, item.ModifiedUtc);
};
_watch.FilesReady += _vm.OnWatchFilesReady;
_watch.AvailabilityChanged += _vm.OnWatchAvailabilityChanged;
_queue.Changed += (_, _) => _queueDirty = true;
_vm.UploadsCompleted += OnUploadsCompleted;
_vm.PropertyChanged += OnViewModelChanged;
_window.Closing += OnWindowClosing;
_window.Closed += (_, _) => ExitApplication();
_window.StateChanged += OnWindowStateChanged;
_persist = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromSeconds(2) };
_persist.Tick += (_, _) => Persist();
_persist.Start();
}
/// <summary>Switches the UI language (BRIEF §16); an unknown code falls back to the OS language.</summary>
private static void ApplyLanguage(string? code)
{
CultureInfo requested;
try
{
requested = code is null ? CultureInfo.CurrentUICulture : CultureInfo.GetCultureInfo(code);
}
catch (CultureNotFoundException)
{
requested = CultureInfo.CurrentUICulture;
}
var culture = Languages.BestMatch(requested);
CultureInfo.DefaultThreadCurrentUICulture = culture;
CultureInfo.CurrentUICulture = culture;
Loc.SetCulture(culture);
}
/// <summary>Writes the queue and the watch memory when they changed (every 2 s and at exit).</summary>
private void Persist()
{
if (_queue is null || _memory is null || _environment is null) return;
if (_queueDirty)
{
_queueDirty = false;
_writer.Write(_environment.QueuePath, QueueStore.Serialize(_queue));
}
if (_memory.IsDirty) _writer.Write(_environment.WatchMemoryPath, _memory.Serialize());
}
private void SaveSettings()
{
if (_settings is null || _environment is null) return;
try
{
_settings.Save(_environment.SettingsPath);
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
Log.Warning("app", "Settings not saved", ex);
}
}
private void OnHandOver(IReadOnlyList<string> paths)
{
ShowWindow();
if (paths.Count > 0) _ = _vm!.EnqueueAsync(paths);
}
private void OnViewModelChanged(object? sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case nameof(MainViewModel.MinimizeToTray):
UpdateTray();
break;
case nameof(MainViewModel.IsConnectVisible):
UpdateDiscovery();
break;
case nameof(MainViewModel.TrayText):
_tray?.SetToolTip(_vm!.TrayText);
break;
}
}
/// <summary>The tray icon exists while "Minimise to tray" is on.</summary>
private void UpdateTray()
{
if (_settings!.MinimizeToTray && _tray is null)
{
_tray = new TrayIcon(_vm!.TrayText, TrayMenu, OnTrayCommand, ShowWindow);
}
else if (!_settings.MinimizeToTray && _tray is not null)
{
_tray.Dispose();
_tray = null;
if (_window is { IsVisible: false }) ShowWindow();
}
}
private IReadOnlyList<TrayMenuItem> TrayMenu() =>
[
new(TrayShow, Loc.L("Uploader.Tray.Show")),
new(TrayPause, _vm!.PauseLabel),
new(0, null),
new(TrayExit, Loc.L("Uploader.Tray.Exit")),
];
private void OnTrayCommand(int id)
{
switch (id)
{
case TrayShow:
ShowWindow();
break;
case TrayPause:
_vm!.TogglePause();
break;
case TrayExit:
ExitApplication();
break;
}
}
/// <summary>Listens for server beacons only while the sign-in form is shown.</summary>
private void UpdateDiscovery()
{
if (_vm!.IsConnectVisible)
{
if (_discovery is not null) return;
_discovery = new DiscoveryListener();
_discovery.Found += _vm.Connect.AddDiscovered;
_discovery.Start();
}
else if (_discovery is not null)
{
_discovery.Dispose();
_discovery = null;
}
}
private void OnUploadsCompleted(int count)
{
if (_window is { IsVisible: true, WindowState: not WindowState.Minimized }) return;
_tray?.ShowBalloon(Loc.L("Uploader.Tray.Done.Title"), Loc.Plural("Uploader.Tray.Done.Message", count));
}
/// <summary>Closing keeps the uploader running in the tray when "Minimise to tray" is on.</summary>
private void OnWindowClosing(object? sender, CancelEventArgs e)
{
if (_exiting || !_settings!.MinimizeToTray) return;
e.Cancel = true;
_window!.SavePlacement();
_window.Hide();
}
private void OnWindowStateChanged(object? sender, EventArgs e)
{
if (_window is { WindowState: WindowState.Minimized } && _settings!.MinimizeToTray) _window.Hide();
}
private void ShowWindow()
{
if (_window is null) return;
_window.Show();
if (_window.WindowState == WindowState.Minimized) _window.WindowState = WindowState.Normal;
_window.Activate();
}
private void ExitApplication()
{
if (_exiting) return;
_exiting = true;
Shutdown();
}
private void RunCapture(string directory)
{
ApplyLanguage(null);
ThemeManager.Initialize(this, AppTheme.Dark);
var sample = new SampleData();
var vm = sample.CreateViewModel();
var window = new Shell.MainWindow(vm, sample.Settings);
MainWindow = window;
ScreenCapture.Run(window, vm, sample, directory);
}
private void HookUnhandledExceptions()
{
DispatcherUnhandledException += (_, e) =>
{
Log.Error("app", "Unhandled UI exception", e.Exception);
if (_vm is null) return;
_vm.ReportError(e.Exception);
e.Handled = true;
};
AppDomain.CurrentDomain.UnhandledException += (_, e) => Log.Error("app", "Unhandled exception", e.ExceptionObject as Exception);
TaskScheduler.UnobservedTaskException += (_, e) =>
{
Log.Error("app", "Unobserved task exception", e.Exception);
e.SetObserved();
};
}
/// <summary>Paths handed to the running instance must not depend on this process's working directory.</summary>
private static string? Absolute(string path)
{
try
{
return Path.GetFullPath(path);
}
catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
{
return null;
}
}
}
@@ -0,0 +1,171 @@
using System.ComponentModel;
using System.Globalization;
using System.Runtime.CompilerServices;
using Titano.Protocol;
using Titano.Uploader.Infrastructure;
using Titano.Uploader.Server;
using Titano.Uploader.Shell;
using Titano.Uploader.Uploads;
using Titano.Uploader.Watching;
namespace Titano.Uploader.DesignTime;
/// <summary>
/// Sample content for <c>--capture</c> screenshots ONLY: a fake signed-in session, a running queue of 4,812 files
/// and two watch folders. Nothing here touches the network, the registry or the user's data files.
/// </summary>
public sealed class SampleData
{
private const int FileCount = 4_812;
private const long FileSize = 20_000_000;
private readonly SampleSession _session = new();
private readonly UploadQueue _queue = new();
private MainViewModel? _vm;
public UploaderSettings Settings { get; } = new()
{
ServerUrl = "https://nas.local:8443/",
Username = "alberto",
BandwidthLimit = 50,
MinimizeToTray = true,
WatchFolders =
[
new UploaderSettings.WatchFolderSettings { Path = @"D:\Cam\Roof", IntervalSeconds = 60 },
new UploaderSettings.WatchFolderSettings { Path = @"\\garage-pi\cam", IntervalSeconds = 300 },
],
};
/// <summary>A view model over in-memory sample services; settings changes are discarded.</summary>
public MainViewModel CreateViewModel()
{
var memory = new ProcessedFileMemory();
_session.BandwidthLimit = Settings.BandwidthLimit;
_vm = new MainViewModel(new UploaderServices(
Settings, () => { }, _session, _queue, new SampleEngine(_queue), new SampleStartup(), new UploaderDialogs(),
new WatchFolderService(memory, _queue.ContainsPath), memory, string.Empty));
foreach (var w in _vm.WatchFolders) w.IsAvailable = true;
return _vm;
}
/// <summary>First run: no server yet, one server found on the LAN.</summary>
public void ShowConnect()
{
_session.SetState(ConnectionState.NotConfigured);
_vm!.Connect.Address = string.Empty;
_vm.Connect.Username = string.Empty;
_vm.Connect.Discovered.Clear();
_vm.Connect.Discovered.Add(new DiscoveredServer("Studio NAS", "https://192.168.1.20:8443"));
}
/// <summary>Signed in, a card being uploaded at 38 MB/s.</summary>
public void ShowQueue()
{
_session.SetState(ConnectionState.Connected);
if (_queue.Items.Count == 0) FillQueue();
_vm!.Sequences.Clear();
_vm.Sequences.Add(new SequenceOption(Guid.Empty, "Harbour sunset"));
_vm.SelectedSequence = _vm.Sequences[0];
_vm.RefreshQueue();
}
private void FillQueue()
{
var batch = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
var start = new DateTime(2026, 9, 28, 15, 22, 0);
_queue.Add(batch, Enumerable.Range(0, FileCount).Select(i =>
{
var shot = start.AddSeconds(i * 5);
var name = shot.ToString("yyyy-MM-dd_HH-mm-ss", CultureInfo.InvariantCulture) + "_" + (i + 1).ToString("0000", CultureInfo.InvariantCulture) + ".CR2";
return new QueueEntry(@"E:\DCIM\100CANON\" + name, FileSize, shot.ToUniversalTime(), shot, "1a2b3c4d-20260928-152200", null);
}));
for (var i = 0; i < 2_201; i++) _queue.Items[i].State = i % 200 == 7 ? UploadItemState.Skipped : UploadItemState.Verified;
_queue.Items[1_640].Retries = 1;
_queue.Items[2_201].State = UploadItemState.Uploading;
_queue.Items[2_201].BytesSent = FileSize * 46 / 100;
_queue.Items[2_202].State = UploadItemState.Hashing;
_queue.Fail(_queue.Items[2_203], UploadFailure.FileUnreadable, null, DateTime.UtcNow);
}
private sealed class SampleSession : IServerSession
{
private ConnectionState _state = ConnectionState.Connected;
public event PropertyChangedEventHandler? PropertyChanged;
public event EventHandler<ServerProblem>? SessionEnded
{
add { }
remove { }
}
public ConnectionState State => _state;
public string? Address => "https://nas.local:8443/";
public string? Username => "alberto";
public long QuotaBytes => 5_000_000_000_000;
public long UsedBytes => 3_100_000_000_000;
public int BandwidthLimit { get; set; }
public void SetState(ConnectionState state)
{
_state = state;
Raise(nameof(State));
}
public Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct) =>
Task.FromResult<(SignInResult, string?)>((SignInResult.Failed, null));
public void Trust(string fingerprint)
{
}
public Task SignOutAsync() => Task.CompletedTask;
public Task RefreshAsync() => Task.CompletedTask;
public Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct) => Task.FromResult<IReadOnlyList<SequenceDto>>([]);
private void Raise([CallerMemberName] string? name = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}
private sealed class SampleEngine(UploadQueue queue) : IUploadEngine
{
public event PropertyChangedEventHandler? PropertyChanged
{
add { }
remove { }
}
public event EventHandler? Drained
{
add { }
remove { }
}
public EngineStatus Status => queue.IsPaused ? EngineStatus.Paused : EngineStatus.Running;
public double BytesPerSecond => 38_000_000;
public void Pump()
{
}
public void Pause() => queue.IsPaused = true;
public void Resume() => queue.IsPaused = false;
public void StopAndClear()
{
}
public void Retry(UploadItem item)
{
}
}
private sealed class SampleStartup : IStartupRegistration
{
public bool IsEnabled { get; private set; } = true;
public void SetEnabled(bool enabled) => IsEnabled = enabled;
}
}
@@ -0,0 +1,62 @@
using System.IO;
using Titano.Core.Diagnostics;
using Titano.Core.IO;
namespace Titano.Uploader.Infrastructure;
/// <summary>
/// Writes state files off the UI thread with <see cref="AtomicFile"/>. Only the newest content of each file is kept
/// while a write is in progress, so a slow disk never writes an older snapshot after a newer one.
/// </summary>
public sealed class CoalescingWriter
{
private readonly Lock _gate = new();
private readonly Dictionary<string, byte[]> _pending = new(StringComparer.OrdinalIgnoreCase);
private Task _worker = Task.CompletedTask;
private bool _running;
public void Write(string path, byte[] content)
{
lock (_gate)
{
_pending[path] = content;
if (_running) return;
_running = true;
_worker = Task.Run(Drain);
}
}
/// <summary>Waits for pending writes (at exit).</summary>
public void Flush(TimeSpan timeout)
{
Task worker;
lock (_gate) worker = _worker;
if (!worker.Wait(timeout)) Log.Warning("persist", "State files still being written at exit");
}
private void Drain()
{
while (true)
{
KeyValuePair<string, byte[]> next;
lock (_gate)
{
if (_pending.Count == 0)
{
_running = false;
return;
}
next = _pending.First();
_pending.Remove(next.Key);
}
try
{
AtomicFile.WriteAllBytes(next.Key, next.Value);
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
Log.Warning("persist", $"{next.Key} not written", ex);
}
}
}
}
@@ -0,0 +1,27 @@
namespace Titano.Uploader.Infrastructure;
/// <summary>
/// <c>Titano.Uploader.exe [--tray] [--capture &lt;dir&gt;] [files or folders…]</c>: paths are enqueued, <c>--tray</c>
/// starts hidden (used by the Run key), <c>--capture</c> renders screenshots and exits.
/// </summary>
public sealed record CommandLine(IReadOnlyList<string> Paths, bool StartInTray, string? CaptureDirectory)
{
public const string TrayOption = "--tray";
public const string CaptureOption = "--capture";
public static CommandLine Parse(IReadOnlyList<string> args)
{
var paths = new List<string>();
var tray = false;
string? capture = null;
for (var i = 0; i < args.Count; i++)
{
var a = args[i];
if (a.Equals(TrayOption, StringComparison.OrdinalIgnoreCase)) tray = true;
else if (a.Equals(CaptureOption, StringComparison.OrdinalIgnoreCase))
capture = i + 1 < args.Count && !args[i + 1].StartsWith("--", StringComparison.Ordinal) ? args[++i] : "screenshots";
else if (!a.StartsWith("--", StringComparison.Ordinal) && a.Length > 0) paths.Add(a);
}
return new CommandLine(paths, tray, capture);
}
}
@@ -0,0 +1,98 @@
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Text;
using Titano.Core.Diagnostics;
namespace Titano.Uploader.Infrastructure;
/// <summary>
/// One uploader per Windows session: a named mutex marks the running instance, and a second launch hands its
/// file arguments over a named pipe (current user only) before exiting.
/// </summary>
public sealed class SingleInstance : IDisposable
{
private const string MutexName = @"Local\Titano.Uploader";
private const string Header = "TITANO-UPLOADER/1";
private const int MaxMessageBytes = 1 << 20;
private readonly Mutex _mutex;
private readonly CancellationTokenSource _stop = new();
private SingleInstance(Mutex mutex) => _mutex = mutex;
private static string PipeName => $"Titano.Uploader.{Process.GetCurrentProcess().SessionId}.{Environment.UserName}";
/// <summary>The instance guard, or null when another uploader already runs in this session.</summary>
public static SingleInstance? TryAcquire()
{
var mutex = new Mutex(initiallyOwned: true, MutexName, out var createdNew);
if (createdNew) return new SingleInstance(mutex);
mutex.Dispose();
return null;
}
/// <summary>Sends <paramref name="args"/> (absolute paths; empty = just show the window) to the running instance.</summary>
public static void HandOver(IReadOnlyList<string> args)
{
try
{
using var pipe = new NamedPipeClientStream(".", PipeName, PipeDirection.Out, PipeOptions.CurrentUserOnly);
pipe.Connect(3000);
pipe.Write(Encode(args));
pipe.Flush();
}
catch (Exception ex) when (ex is IOException or TimeoutException or UnauthorizedAccessException)
{
Log.Warning("instance", "Could not reach the running uploader", ex);
}
}
/// <summary>Receives messages from later launches; <paramref name="received"/> runs on a pool thread.</summary>
public void Listen(Action<IReadOnlyList<string>> received) => _ = ListenAsync(received, _stop.Token);
public void Dispose()
{
_stop.Cancel();
_mutex.ReleaseMutex();
_mutex.Dispose();
_stop.Dispose();
}
/// <summary>UTF-8: a header line, then one argument per line (paths cannot contain line breaks).</summary>
public static byte[] Encode(IReadOnlyList<string> args) =>
Encoding.UTF8.GetBytes(Header + "\n" + string.Join("\n", args.Where(a => !a.Contains('\n', StringComparison.Ordinal))));
/// <summary>Arguments of a message, or null when it is not one of ours.</summary>
public static IReadOnlyList<string>? Decode(ReadOnlySpan<byte> message)
{
if (message.Length > MaxMessageBytes) return null;
var lines = Encoding.UTF8.GetString(message).Split('\n');
if (lines[0] != Header) return null;
return [.. lines.Skip(1).Where(l => l.Length > 0)];
}
private static async Task ListenAsync(Action<IReadOnlyList<string>> received, CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
try
{
await using var pipe = new NamedPipeServerStream(PipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte,
PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly);
await pipe.WaitForConnectionAsync(ct).ConfigureAwait(false);
using var buffer = new MemoryStream();
await pipe.CopyToAsync(buffer, ct).ConfigureAwait(false);
if (Decode(buffer.GetBuffer().AsSpan(0, (int)buffer.Length)) is { } args) received(args);
}
catch (OperationCanceledException)
{
return;
}
catch (IOException ex)
{
Log.Warning("instance", "Hand-over pipe failed; listening again", ex);
}
}
}
}
@@ -0,0 +1,61 @@
using System.Security;
using Microsoft.Win32;
using Titano.Core.Diagnostics;
namespace Titano.Uploader.Infrastructure;
/// <summary>"Start with Windows".</summary>
public interface IStartupRegistration
{
bool IsEnabled { get; }
void SetEnabled(bool enabled);
}
/// <summary>
/// <c>HKCU\Software\Microsoft\Windows\CurrentVersion\Run</c> value that starts the uploader in the tray at sign-in.
/// The registry stays the source of truth because Task Manager can turn it off.
/// </summary>
public sealed class RunKeyStartupRegistration : IStartupRegistration
{
private const string RunKey = @"Software\Microsoft\Windows\CurrentVersion\Run";
private const string ValueName = "Titano Uploader";
public bool IsEnabled
{
get
{
try
{
using var key = Registry.CurrentUser.OpenSubKey(RunKey);
return key?.GetValue(ValueName) is string { Length: > 0 };
}
catch (SecurityException)
{
return false;
}
}
}
private static string Command => $"\"{Environment.ProcessPath}\" {CommandLine.TrayOption}";
public void SetEnabled(bool enabled)
{
try
{
using var key = Registry.CurrentUser.CreateSubKey(RunKey, writable: true);
if (enabled) key.SetValue(ValueName, Command, RegistryValueKind.String);
else key.DeleteValue(ValueName, throwOnMissingValue: false);
}
catch (Exception ex) when (ex is SecurityException or UnauthorizedAccessException)
{
Log.Warning("startup", "Run key not updated", ex);
}
}
/// <summary>Points an existing entry at the current executable (after an update moved it).</summary>
public void Refresh()
{
if (IsEnabled) SetEnabled(true);
}
}
@@ -0,0 +1,98 @@
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
namespace Titano.Uploader.Infrastructure;
/// <summary>
/// Encrypts the sign-in token for the current Windows user with DPAPI (<c>CryptProtectData</c>, no machine scope),
/// so <c>uploader.json</c> copied to another account or PC cannot be used.
/// </summary>
public static partial class TokenProtector
{
private const int CryptProtectUiForbidden = 0x1;
// Ties the blob to this program; other DPAPI consumers of the same user cannot unwrap it by accident.
private static readonly byte[] Entropy = "Titano.Uploader.Token.v1"u8.ToArray();
/// <summary>Base64 DPAPI blob of <paramref name="token"/>.</summary>
public static string Protect(string token)
{
var plain = Encoding.UTF8.GetBytes(token);
try
{
return Convert.ToBase64String(Transform(plain, protect: true));
}
finally
{
CryptographicOperations.ZeroMemory(plain);
}
}
/// <summary>The token, or null when the blob is corrupt or belongs to another user.</summary>
public static string? Unprotect(string protectedToken)
{
byte[] blob;
try
{
blob = Convert.FromBase64String(protectedToken);
}
catch (FormatException)
{
return null;
}
try
{
var plain = Transform(blob, protect: false);
var token = Encoding.UTF8.GetString(plain);
CryptographicOperations.ZeroMemory(plain);
return token;
}
catch (CryptographicException)
{
return null;
}
}
private static unsafe byte[] Transform(byte[] input, bool protect)
{
fixed (byte* inPtr = input)
fixed (byte* entropyPtr = Entropy)
{
var source = new DataBlob { Size = input.Length, Data = (IntPtr)inPtr };
var entropy = new DataBlob { Size = Entropy.Length, Data = (IntPtr)entropyPtr };
var ok = protect
? CryptProtectData(source, null, entropy, IntPtr.Zero, IntPtr.Zero, CryptProtectUiForbidden, out var output)
: CryptUnprotectData(source, IntPtr.Zero, entropy, IntPtr.Zero, IntPtr.Zero, CryptProtectUiForbidden, out output);
if (!ok) throw new CryptographicException(Marshal.GetLastPInvokeError());
try
{
var result = new byte[output.Size];
Marshal.Copy(output.Data, result, 0, output.Size);
return result;
}
finally
{
LocalFree(output.Data);
}
}
}
[StructLayout(LayoutKind.Sequential)]
private struct DataBlob
{
public int Size;
public IntPtr Data;
}
[LibraryImport("crypt32.dll", SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool CryptProtectData(in DataBlob dataIn, string? description, in DataBlob entropy, IntPtr reserved, IntPtr prompt, int flags, out DataBlob dataOut);
[LibraryImport("crypt32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool CryptUnprotectData(in DataBlob dataIn, IntPtr description, in DataBlob entropy, IntPtr reserved, IntPtr prompt, int flags, out DataBlob dataOut);
[LibraryImport("kernel32.dll")]
private static partial IntPtr LocalFree(IntPtr memory);
}
@@ -0,0 +1,37 @@
using System.IO;
namespace Titano.Uploader.Infrastructure;
/// <summary>
/// Where the uploader keeps its files: <c>%LOCALAPPDATA%\Titano</c> (shared with the client), or <c>.\data</c> next
/// to the executable when <c>portable.txt</c> exists — the same rule as the desktop client.
/// </summary>
public sealed class UploaderEnvironment
{
private UploaderEnvironment(string dataDirectory)
{
DataDirectory = dataDirectory;
Directory.CreateDirectory(DataDirectory);
Directory.CreateDirectory(LogDirectory);
}
public string DataDirectory { get; }
public string LogDirectory => Path.Combine(DataDirectory, "logs");
/// <summary>Settings, DPAPI-protected token and trusted certificate fingerprints.</summary>
public string SettingsPath => Path.Combine(DataDirectory, "uploader.json");
/// <summary>The persisted upload queue.</summary>
public string QueuePath => Path.Combine(DataDirectory, "uploader-queue.json");
/// <summary>Files of watch folders the server already confirmed.</summary>
public string WatchMemoryPath => Path.Combine(DataDirectory, "uploader-watch.json");
public static UploaderEnvironment Detect()
{
var exeDir = AppContext.BaseDirectory;
if (File.Exists(Path.Combine(exeDir, "portable.txt"))) return new UploaderEnvironment(Path.Combine(exeDir, "data"));
var local = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
return new UploaderEnvironment(Path.Combine(local, "Titano"));
}
}
@@ -0,0 +1,77 @@
using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;
using Titano.Core.Diagnostics;
using Titano.Core.IO;
using Titano.Ui.Theming;
using Titano.Uploader.Uploads;
namespace Titano.Uploader.Infrastructure;
/// <summary>
/// <c>uploader.json</c>. The bearer token is stored only DPAPI-protected for the current Windows user
/// (<see cref="TokenProtector"/>); "Start with Windows" lives in the registry, which stays the source of truth.
/// </summary>
public sealed class UploaderSettings
{
public string? ServerUrl { get; set; }
public string? Username { get; set; }
/// <summary>Base64 of the DPAPI (CurrentUser) blob of the bearer token.</summary>
public string? ProtectedToken { get; set; }
/// <summary>SHA-256 fingerprints (XX:XX:…) of self-signed certificates the user trusted (TOFU).</summary>
public List<string> TrustedFingerprints { get; set; } = [];
/// <summary>Upload limit in MB/s (decimal megabytes); 0 = unlimited.</summary>
public int BandwidthLimit { get; set; }
public bool MinimizeToTray { get; set; } = true;
public bool DeleteAfterUpload { get; set; }
public UploadTargetMode Target { get; set; } = UploadTargetMode.Sessions;
public Guid? TargetSequenceId { get; set; }
public string? NewSequenceTitle { get; set; }
public List<WatchFolderSettings> WatchFolders { get; set; } = [];
public string? Language { get; set; }
public AppTheme Theme { get; set; } = AppTheme.Dark;
public WindowPlacement? Window { get; set; }
public sealed class WatchFolderSettings
{
public string Path { get; set; } = string.Empty;
public int IntervalSeconds { get; set; } = 60;
}
public sealed class WindowPlacement
{
public double Left { get; set; }
public double Top { get; set; }
public double Width { get; set; }
public double Height { get; set; }
}
public static UploaderSettings Load(string path)
{
try
{
if (File.Exists(path))
return JsonSerializer.Deserialize(File.ReadAllBytes(path), UploaderSettingsJson.Default.UploaderSettings) ?? new UploaderSettings();
}
catch (JsonException ex)
{
// A corrupt settings file must never block startup; defaults apply.
Log.Warning("settings", "uploader.json unreadable; using defaults", ex);
}
catch (IOException ex)
{
Log.Warning("settings", "uploader.json unreadable; using defaults", ex);
}
return new UploaderSettings();
}
public void Save(string path) => AtomicFile.WriteAllBytes(path, JsonSerializer.SerializeToUtf8Bytes(this, UploaderSettingsJson.Default.UploaderSettings));
}
[JsonSourceGenerationOptions(WriteIndented = true, PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, UseStringEnumConverter = true)]
[JsonSerializable(typeof(UploaderSettings))]
internal sealed partial class UploaderSettingsJson : JsonSerializerContext;
+187
View File
@@ -0,0 +1,187 @@
using System.Runtime.InteropServices;
namespace Titano.Uploader.Interop;
/// <summary>A filter of the Open dialog: display name and patterns such as <c>*.jpg;*.cr2</c>.</summary>
public readonly record struct FileFilter(string Name, string Patterns);
/// <summary>
/// The shell's Open dialog through <c>IFileOpenDialog</c> COM (no WinForms): several files at once, or one folder
/// (which also picks a card root such as <c>E:\</c>).
/// </summary>
public static class FileDialogs
{
private const uint FosPickFolders = 0x20;
private const uint FosForceFileSystem = 0x40;
private const uint FosAllowMultiSelect = 0x200;
private const uint FosPathMustExist = 0x800;
private const uint FosFileMustExist = 0x1000;
private const uint SigdnFileSysPath = 0x80058000;
private const int ErrorCancelled = unchecked((int)0x800704C7);
/// <summary>Selected files; empty when cancelled.</summary>
public static IReadOnlyList<string> PickFiles(IntPtr owner, string title, IReadOnlyList<FileFilter> filters) =>
Show(owner, title, FosAllowMultiSelect | FosFileMustExist, filters);
/// <summary>Selected folder; null when cancelled.</summary>
public static string? PickFolder(IntPtr owner, string title) => Show(owner, title, FosPickFolders, []).FirstOrDefault();
private static List<string> Show(IntPtr owner, string title, uint options, IReadOnlyList<FileFilter> filters)
{
var dialog = (IFileOpenDialog)new FileOpenDialogClass();
try
{
dialog.GetOptions(out var current);
dialog.SetOptions(current | options | FosForceFileSystem | FosPathMustExist);
dialog.SetTitle(title);
if (filters.Count > 0)
{
var specs = filters.Select(f => new FilterSpec { Name = f.Name, Spec = f.Patterns }).ToArray();
dialog.SetFileTypes((uint)specs.Length, specs);
dialog.SetFileTypeIndex(1);
}
var hr = dialog.Show(owner);
if (hr == ErrorCancelled) return [];
Marshal.ThrowExceptionForHR(hr);
dialog.GetResults(out var items);
try
{
items.GetCount(out var count);
var paths = new List<string>((int)count);
for (uint i = 0; i < count; i++)
{
items.GetItemAt(i, out var item);
try
{
item.GetDisplayName(SigdnFileSysPath, out var path);
paths.Add(path);
}
finally
{
Marshal.ReleaseComObject(item);
}
}
return paths;
}
finally
{
Marshal.ReleaseComObject(items);
}
}
finally
{
Marshal.ReleaseComObject(dialog);
}
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
private struct FilterSpec
{
[MarshalAs(UnmanagedType.LPWStr)]
public string Name;
[MarshalAs(UnmanagedType.LPWStr)]
public string Spec;
}
[ComImport]
[Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7")]
private class FileOpenDialogClass;
// Classic COM interop does not inherit vtables: IModalWindow and IFileDialog members are repeated in order.
[ComImport]
[Guid("d57c7288-d4ad-4768-be02-9d969532d960")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
private interface IFileOpenDialog
{
[PreserveSig]
int Show(IntPtr owner);
void SetFileTypes(uint count, [In, MarshalAs(UnmanagedType.LPArray)] FilterSpec[] filters);
void SetFileTypeIndex(uint index);
void GetFileTypeIndex(out uint index);
void Advise(IntPtr events, out uint cookie);
void Unadvise(uint cookie);
void SetOptions(uint options);
void GetOptions(out uint options);
void SetDefaultFolder(IShellItem item);
void SetFolder(IShellItem item);
void GetFolder(out IShellItem item);
void GetCurrentSelection(out IShellItem item);
void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string name);
void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string name);
void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string title);
void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string text);
void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string label);
void GetResult(out IShellItem item);
void AddPlace(IShellItem item, int placement);
void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string extension);
void Close(int hr);
void SetClientGuid(ref Guid guid);
void ClearClientData();
void SetFilter(IntPtr filter);
void GetResults(out IShellItemArray items);
void GetSelectedItems(out IShellItemArray items);
}
[ComImport]
[Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
private interface IShellItem
{
void BindToHandler(IntPtr bindContext, ref Guid handler, ref Guid iid, out IntPtr result);
void GetParent(out IShellItem parent);
void GetDisplayName(uint form, [MarshalAs(UnmanagedType.LPWStr)] out string name);
void GetAttributes(uint mask, out uint attributes);
void Compare(IShellItem other, uint hint, out int order);
}
[ComImport]
[Guid("b63ea76d-1f85-456f-a19c-48159efa858b")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
private interface IShellItemArray
{
void BindToHandler(IntPtr bindContext, ref Guid handler, ref Guid iid, out IntPtr result);
void GetPropertyStore(int flags, ref Guid iid, out IntPtr store);
void GetPropertyDescriptionList(IntPtr keyType, ref Guid iid, out IntPtr list);
void GetAttributes(int flags, uint mask, out uint attributes);
void GetCount(out uint count);
void GetItemAt(uint index, out IShellItem item);
void EnumItems(out IntPtr items);
}
}
+251
View File
@@ -0,0 +1,251 @@
using System.Runtime.InteropServices;
using System.Windows.Interop;
using Titano.Core.Diagnostics;
namespace Titano.Uploader.Interop;
/// <summary>One entry of the tray menu; an id of 0 is a separator.</summary>
public readonly record struct TrayMenuItem(int Id, string? Text);
/// <summary>
/// Notification-area icon through <c>Shell_NotifyIconW</c>: the program icon from the executable's resources, a tooltip,
/// a native context menu and balloons. A hidden window receives the callbacks and re-adds the icon after Explorer restarts.
/// </summary>
public sealed unsafe partial class TrayIcon : IDisposable
{
private const uint NimAdd = 0;
private const uint NimModify = 1;
private const uint NimDelete = 2;
private const uint NifMessage = 0x1;
private const uint NifIcon = 0x2;
private const uint NifTip = 0x4;
private const uint NifInfo = 0x10;
private const uint NiifUser = 0x4;
private const int CallbackMessage = 0x8000 + 1; // WM_APP + 1
private const int WmContextMenu = 0x007B;
private const int WmLButtonUp = 0x0202;
private const int WmLButtonDblClk = 0x0203;
private const int WmRButtonUp = 0x0205;
private const int NinBalloonUserClick = 0x0405;
private const uint MfString = 0x0;
private const uint MfSeparator = 0x800;
private const uint TpmRightButton = 0x2;
private const uint TpmNoNotify = 0x80;
private const uint TpmReturnCmd = 0x100;
private readonly HwndSource _window;
private readonly IntPtr _icon;
private readonly bool _ownsIcon;
private readonly uint _taskbarCreated;
private readonly Func<IReadOnlyList<TrayMenuItem>> _menu;
private readonly Action<int> _command;
private readonly Action _show;
private string _toolTip;
private bool _added;
/// <param name="toolTip">Hover text (up to 127 characters).</param>
/// <param name="menu">Builds the context menu when it opens.</param>
/// <param name="command">Runs a chosen menu id.</param>
/// <param name="show">Left click or balloon click.</param>
public TrayIcon(string toolTip, Func<IReadOnlyList<TrayMenuItem>> menu, Action<int> command, Action show)
{
_toolTip = toolTip;
_menu = menu;
_command = command;
_show = show;
// A hidden top-level window: message-only windows miss the TaskbarCreated broadcast.
_window = new HwndSource(new HwndSourceParameters("TitanoUploaderTray") { Width = 0, Height = 0, WindowStyle = 0 });
_window.AddHook(WndProc);
_taskbarCreated = RegisterWindowMessageW("TaskbarCreated");
(_icon, _ownsIcon) = LoadProgramIcon();
Add();
}
public void SetToolTip(string text)
{
_toolTip = text;
var data = NewData(NifTip);
Copy(_toolTip, data.Tip, 128);
Notify(NimModify, &data);
}
/// <summary>Shows a balloon (a toast on Windows 10/11) with the program icon.</summary>
public void ShowBalloon(string title, string text)
{
var data = NewData(NifInfo);
Copy(title, data.InfoTitle, 64);
Copy(text, data.Info, 256);
data.InfoFlags = NiifUser;
Notify(NimModify, &data);
}
public void Dispose()
{
if (_added)
{
var data = NewData(0);
Notify(NimDelete, &data);
_added = false;
}
if (_ownsIcon) DestroyIcon(_icon);
_window.Dispose();
}
private void Add()
{
var data = NewData(NifMessage | NifIcon | NifTip);
data.CallbackMessage = CallbackMessage;
data.Icon = _icon;
Copy(_toolTip, data.Tip, 128);
_added = Notify(NimAdd, &data);
}
private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
if (msg == CallbackMessage)
{
switch ((int)(lParam.ToInt64() & 0xFFFF))
{
case WmLButtonUp or WmLButtonDblClk or NinBalloonUserClick:
_show();
break;
case WmRButtonUp or WmContextMenu:
ShowMenu();
break;
}
handled = true;
}
else if (_taskbarCreated != 0 && msg == (int)_taskbarCreated)
{
Add();
}
return IntPtr.Zero;
}
private void ShowMenu()
{
var menu = CreatePopupMenu();
if (menu == IntPtr.Zero) return;
try
{
foreach (var item in _menu())
{
if (item.Id == 0 || item.Text is null) AppendMenuW(menu, MfSeparator, 0, null);
else AppendMenuW(menu, MfString, (nuint)item.Id, item.Text);
}
GetCursorPos(out var point);
// Without foreground the menu would not close when the user clicks elsewhere.
SetForegroundWindow(_window.Handle);
var chosen = TrackPopupMenuEx(menu, TpmReturnCmd | TpmRightButton | TpmNoNotify, point.X, point.Y, _window.Handle, IntPtr.Zero);
PostMessageW(_window.Handle, 0, IntPtr.Zero, IntPtr.Zero);
if (chosen != 0) _command(chosen);
}
finally
{
DestroyMenu(menu);
}
}
private NotifyIconData NewData(uint flags) => new()
{
Size = (uint)sizeof(NotifyIconData),
Window = _window.Handle,
Id = 1,
Flags = flags,
};
private static bool Notify(uint message, NotifyIconData* data)
{
if (Shell_NotifyIconW(message, data)) return true;
Log.Info("tray", $"Shell_NotifyIcon({message}) failed");
return false;
}
private static void Copy(string text, char* destination, int capacity)
{
var length = Math.Min(text.Length, capacity - 1);
text.AsSpan(0, length).CopyTo(new Span<char>(destination, capacity));
destination[length] = '\0';
}
/// <summary>The generated titano-uploader icon embedded in the executable; the stock icon if it cannot be read.</summary>
private static (IntPtr Icon, bool Owned) LoadProgramIcon()
{
if (Environment.ProcessPath is { } exe)
{
IntPtr small;
if (ExtractIconExW(exe, 0, null, &small, 1) > 0 && small != IntPtr.Zero) return (small, true);
}
return (LoadIconW(IntPtr.Zero, 32512), false); // IDI_APPLICATION
}
[StructLayout(LayoutKind.Sequential)]
private struct NotifyIconData
{
public uint Size;
public IntPtr Window;
public uint Id;
public uint Flags;
public uint CallbackMessage;
public IntPtr Icon;
public fixed char Tip[128];
public uint State;
public uint StateMask;
public fixed char Info[256];
public uint TimeoutOrVersion;
public fixed char InfoTitle[64];
public uint InfoFlags;
public Guid Item;
public IntPtr BalloonIcon;
}
[StructLayout(LayoutKind.Sequential)]
private struct Point
{
public int X;
public int Y;
}
[LibraryImport("shell32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool Shell_NotifyIconW(uint message, NotifyIconData* data);
[LibraryImport("shell32.dll", StringMarshalling = StringMarshalling.Utf16)]
private static partial uint ExtractIconExW(string file, int index, IntPtr* large, IntPtr* small, uint count);
[LibraryImport("user32.dll")]
private static partial IntPtr LoadIconW(IntPtr instance, nint name);
[LibraryImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool DestroyIcon(IntPtr icon);
[LibraryImport("user32.dll", StringMarshalling = StringMarshalling.Utf16)]
private static partial uint RegisterWindowMessageW(string name);
[LibraryImport("user32.dll")]
private static partial IntPtr CreatePopupMenu();
[LibraryImport("user32.dll", StringMarshalling = StringMarshalling.Utf16)]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool AppendMenuW(IntPtr menu, uint flags, nuint id, string? text);
[LibraryImport("user32.dll")]
private static partial int TrackPopupMenuEx(IntPtr menu, uint flags, int x, int y, IntPtr window, IntPtr parameters);
[LibraryImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool DestroyMenu(IntPtr menu);
[LibraryImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool GetCursorPos(out Point point);
[LibraryImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool SetForegroundWindow(IntPtr window);
[LibraryImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static partial bool PostMessageW(IntPtr window, int message, IntPtr wParam, IntPtr lParam);
}
@@ -0,0 +1,74 @@
using System.Net;
using System.Net.Sockets;
using Titano.Core.Diagnostics;
using Titano.Protocol;
namespace Titano.Uploader.Server;
/// <summary>A Titano Server announced on the LAN.</summary>
public sealed record DiscoveredServer(string Name, string Address);
/// <summary>
/// Listens for the server's UDP beacon (<see cref="DiscoveryBeacon.Port"/>) while the connect form is open and reports
/// each server once. Beacons are unauthenticated: they only fill the address field, never trust a certificate.
/// </summary>
public sealed class DiscoveryListener : IDisposable
{
private readonly HashSet<string> _seen = new(StringComparer.OrdinalIgnoreCase);
private CancellationTokenSource? _cts;
/// <summary>Raised on the thread that called <see cref="Start"/>.</summary>
public event Action<DiscoveredServer>? Found;
public void Start()
{
if (_cts is not null) return;
_cts = new CancellationTokenSource();
var context = SynchronizationContext.Current;
_ = Task.Run(() => ListenAsync(context, _cts.Token));
}
public void Dispose()
{
_cts?.Cancel();
_cts?.Dispose();
_cts = null;
}
/// <summary>The address the client should use for <paramref name="beacon"/> sent from <paramref name="sender"/>.</summary>
private static string AddressOf(DiscoveryBeacon beacon, IPAddress sender)
{
var host = sender.AddressFamily == AddressFamily.InterNetworkV6 ? "[" + sender + "]" : sender.ToString();
return beacon.HttpsPort > 0 ? $"https://{host}:{beacon.HttpsPort}" : $"http://{host}:{beacon.HttpPort}";
}
private async Task ListenAsync(SynchronizationContext? context, CancellationToken ct)
{
try
{
using var udp = new UdpClient();
// The desktop client may listen on the same port.
udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
udp.Client.Bind(new IPEndPoint(IPAddress.Any, DiscoveryBeacon.Port));
while (!ct.IsCancellationRequested)
{
var datagram = await udp.ReceiveAsync(ct).ConfigureAwait(false);
if (DiscoveryBeacon.TryParse(datagram.Buffer) is not { } beacon) continue;
var server = new DiscoveredServer(beacon.Name, AddressOf(beacon, datagram.RemoteEndPoint.Address));
lock (_seen)
{
if (!_seen.Add(server.Address)) continue;
}
if (context is null) Found?.Invoke(server);
else context.Post(_ => Found?.Invoke(server), null);
}
}
catch (OperationCanceledException)
{
}
catch (SocketException ex)
{
Log.Info("discovery", "LAN discovery unavailable: " + ex.Message);
}
}
}
@@ -0,0 +1,21 @@
namespace Titano.Uploader.Server;
/// <summary>Server addresses as typed in the sign-in form.</summary>
public static class ServerAddress
{
/// <summary>
/// Accepts "nas.local:8443" (https assumed) or a full http(s) URL; the result is the API base, ending with "/".
/// </summary>
public static bool TryParse(string? text, out Uri uri)
{
uri = null!;
if (string.IsNullOrWhiteSpace(text)) return false;
var trimmed = text.Trim();
if (!trimmed.Contains("://", StringComparison.Ordinal)) trimmed = "https://" + trimmed;
if (!Uri.TryCreate(trimmed, UriKind.Absolute, out var parsed) || parsed.Scheme is not ("https" or "http") || parsed.Host.Length == 0) return false;
var builder = new UriBuilder(parsed) { Query = string.Empty, Fragment = string.Empty };
if (!builder.Path.EndsWith('/')) builder.Path += "/";
uri = builder.Uri;
return true;
}
}
+460
View File
@@ -0,0 +1,460 @@
using System.ComponentModel;
using System.Net;
using System.Net.Http;
using System.Runtime.CompilerServices;
using System.Text.Json;
using Titano.Core.Diagnostics;
using Titano.Protocol;
using Titano.Protocol.Client;
using Titano.Uploader.Infrastructure;
using Titano.Uploader.Uploads;
namespace Titano.Uploader.Server;
/// <summary>Connection shown in the header.</summary>
public enum ConnectionState
{
/// <summary>First run: no server chosen yet.</summary>
NotConfigured,
SigningIn,
Connected,
/// <summary>Signed in, but the server cannot be reached; probed every 30 s.</summary>
Offline,
/// <summary>A server is known but there is no valid token.</summary>
SignedOut,
}
/// <summary>Outcome of the sign-in form.</summary>
public enum SignInResult
{
Success,
InvalidAddress,
Unreachable,
NotTitano,
/// <summary>The certificate is self-signed and unknown: ask the user to trust its fingerprint.</summary>
Untrusted,
BadCredentials,
Failed,
}
/// <summary>The server connection as the window sees it.</summary>
public interface IServerSession : INotifyPropertyChanged
{
ConnectionState State { get; }
/// <summary>Server address as the user typed or discovered it.</summary>
string? Address { get; }
string? Username { get; }
/// <summary>Quota in bytes; 0 = unlimited.</summary>
long QuotaBytes { get; }
long UsedBytes { get; }
/// <summary>Upload limit in MB/s; 0 = unlimited.</summary>
int BandwidthLimit { get; set; }
/// <summary>Raised when the server ended the session (token rejected or certificate changed).</summary>
event EventHandler<ServerProblem>? SessionEnded;
/// <summary>Signs in; <see cref="SignInResult.Untrusted"/> comes with the fingerprint to show.</summary>
Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct);
/// <summary>Remembers a certificate fingerprint the user confirmed (trust on first use).</summary>
void Trust(string fingerprint);
Task SignOutAsync();
/// <summary>Refreshes the account (quota) when connected.</summary>
Task RefreshAsync();
Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct);
}
/// <summary>
/// Owns the <see cref="TitanoClient"/>: sign-in with trust-on-first-use, token restore from DPAPI, offline probing,
/// and the upload transport. Runs on the UI thread.
/// </summary>
public sealed class ServerSession : IServerSession, IUploadTransport, IDisposable
{
private static readonly TimeSpan ProbeInterval = TimeSpan.FromSeconds(30);
private readonly UploaderSettings _settings;
private readonly Action _saveSettings;
private TitanoClient? _client;
private ConnectionState _state;
private string? _username;
private long _quotaBytes;
private long _usedBytes;
private int _bandwidthLimit;
private CancellationTokenSource? _probe;
public ServerSession(UploaderSettings settings, Action saveSettings)
{
_settings = settings;
_saveSettings = saveSettings;
_username = settings.Username;
_bandwidthLimit = Math.Max(0, settings.BandwidthLimit);
_state = settings.ServerUrl is null ? ConnectionState.NotConfigured : ConnectionState.SignedOut;
}
public event PropertyChangedEventHandler? PropertyChanged;
public event EventHandler? ReadyChanged;
public event EventHandler<ServerProblem>? SessionEnded;
public ConnectionState State
{
get => _state;
private set
{
if (_state == value) return;
var wasReady = IsReady;
_state = value;
OnPropertyChanged();
if (wasReady != IsReady) ReadyChanged?.Invoke(this, EventArgs.Empty);
}
}
public bool IsReady => _state == ConnectionState.Connected && _client is not null;
public string? Address => _settings.ServerUrl;
public string? Username
{
get => _username;
private set => Set(ref _username, value);
}
public long QuotaBytes
{
get => _quotaBytes;
private set => Set(ref _quotaBytes, value);
}
public long UsedBytes
{
get => _usedBytes;
private set => Set(ref _usedBytes, value);
}
public int BandwidthLimit
{
get => _bandwidthLimit;
set
{
if (!Set(ref _bandwidthLimit, Math.Max(0, value))) return;
ApplyBandwidth();
}
}
/// <summary>Restores the saved session, if any, in the background.</summary>
public void Start()
{
if (_settings.ServerUrl is null || _settings.ProtectedToken is null) return;
var token = TokenProtector.Unprotect(_settings.ProtectedToken);
if (token is null || !ServerAddress.TryParse(_settings.ServerUrl, out var uri))
{
Log.Warning("session", "Saved token cannot be used; sign in again");
State = ConnectionState.SignedOut;
return;
}
UseClient(CreateClient(uri));
_client!.Token = token;
State = ConnectionState.SigningIn;
_ = RefreshAsync();
}
public async Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct)
{
if (!ServerAddress.TryParse(address, out var uri)) return (SignInResult.InvalidAddress, null);
StopProbing();
var previous = State;
State = ConnectionState.SigningIn;
var client = CreateClient(uri);
try
{
await client.GetInfoAsync(ct);
var login = await client.LoginAsync(username, password, ct);
if (login.Token is null) throw new TitanoApiException(HttpStatusCode.Unauthorized, new ApiError("no_token", "No token issued"));
_settings.ServerUrl = uri.ToString();
_settings.Username = login.User.Username;
_settings.ProtectedToken = TokenProtector.Protect(login.Token);
_saveSettings();
UseClient(client);
OnPropertyChanged(nameof(Address));
Username = login.User.Username;
SetQuota(login.User);
State = ConnectionState.Connected;
Log.Info("session", $"Signed in to {uri} as {login.User.Username}");
return (SignInResult.Success, null);
}
catch (Exception ex)
{
client.Dispose();
State = previous == ConnectionState.SigningIn ? ConnectionState.NotConfigured : previous;
var result = Classify(ex, ct);
if (result == SignInResult.Failed) Log.Warning("session", $"Sign-in to {uri} failed", ex);
return (result, (ex as UntrustedCertificateException)?.Fingerprint);
}
}
public void Trust(string fingerprint)
{
if (_settings.TrustedFingerprints.Contains(fingerprint, StringComparer.OrdinalIgnoreCase)) return;
_settings.TrustedFingerprints.Add(fingerprint);
_saveSettings();
Log.Info("session", $"Trusted certificate {fingerprint}");
}
public async Task SignOutAsync()
{
StopProbing();
if (_client is { Token: not null } client)
{
try
{
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
await client.LogoutAsync(timeout.Token);
}
catch (Exception ex) when (ex is HttpRequestException or TitanoApiException or OperationCanceledException or UntrustedCertificateException)
{
// The token is forgotten locally either way.
Log.Info("session", "Logout not confirmed by the server: " + ex.Message);
}
}
ForgetToken();
}
public async Task RefreshAsync()
{
if (_client is not { } client) return;
try
{
var me = await client.MeAsync();
Username = me.Username;
SetQuota(me);
State = ConnectionState.Connected;
StopProbing();
}
catch (Exception ex) when (IsServerProblem(ex, CancellationToken.None, out var problem))
{
OnServerProblem(problem, ex);
}
catch (TitanoApiException ex)
{
Log.Warning("session", "Account refresh failed", ex);
}
}
public async Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct)
{
if (!IsReady) return [];
var all = new List<SequenceDto>();
string? cursor = null;
try
{
// Five pages of 200 cover any realistic choice list.
for (var page = 0; page < 5; page++)
{
var result = await _client!.ListSequencesAsync(cursor: cursor, ct: ct);
all.AddRange(result.Items);
cursor = result.NextCursor;
if (cursor is null) break;
}
}
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
{
OnServerProblem(problem, ex);
}
catch (TitanoApiException ex)
{
Log.Warning("session", "Sequence list unavailable", ex);
}
return all;
}
// ---------------- IUploadTransport ----------------
public async Task<(UploadOutcome Outcome, Guid? FrameId)> UploadAsync(UploadItem item, Guid? sequenceId, string sha256, IProgress<UploadProgress> progress, CancellationToken ct)
{
var client = _client ?? throw new ServerUnavailableException(ServerProblem.SignedOut);
try
{
var result = await client.UploadFileAsync(item.Path, sequenceId, item.CapturedAt, item.SessionKey, sha256, progress, ct);
// The client reports an existing file as index −1 (or no frame at all).
return result is null || result.Index < 0 ? (UploadOutcome.AlreadyOnServer, result?.FrameId) : (UploadOutcome.Verified, result.FrameId);
}
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
{
OnServerProblem(problem, ex);
throw new ServerUnavailableException(problem, ex);
}
}
public async Task<Guid> CreateSequenceAsync(string? title, CancellationToken ct)
{
var client = _client ?? throw new ServerUnavailableException(ServerProblem.SignedOut);
try
{
var created = await client.CreateSequenceAsync(new CreateSequenceRequest(string.IsNullOrWhiteSpace(title) ? null : title.Trim(), null), ct);
Log.Info("session", $"Created sequence {created.Id} \"{created.DisplayTitle}\"");
return created.Id;
}
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
{
OnServerProblem(problem, ex);
throw new ServerUnavailableException(problem, ex);
}
}
public void Dispose()
{
StopProbing();
_client?.Dispose();
}
// ---------------- Plumbing ----------------
private TitanoClient CreateClient(Uri uri)
{
// A fresh pinning per client: the protocol's last-rejected fingerprint must not outlive a trust decision.
var client = new TitanoClient(uri, new CertificatePinning(_settings.TrustedFingerprints), $"Titano Uploader ({Environment.MachineName})");
client.Bandwidth.BytesPerSecond = _bandwidthLimit * 1_000_000L;
return client;
}
private void UseClient(TitanoClient client)
{
if (ReferenceEquals(_client, client)) return;
_client?.Dispose();
_client = client;
}
private void ApplyBandwidth()
{
if (_client is not null) _client.Bandwidth.BytesPerSecond = _bandwidthLimit * 1_000_000L;
}
private void SetQuota(UserDto user)
{
QuotaBytes = user.QuotaBytes;
UsedBytes = user.UsedBytes;
}
private void ForgetToken()
{
if (_client is not null) _client.Token = null;
_settings.ProtectedToken = null;
_saveSettings();
QuotaBytes = 0;
UsedBytes = 0;
State = _settings.ServerUrl is null ? ConnectionState.NotConfigured : ConnectionState.SignedOut;
}
private bool IsServerProblem(Exception ex, CancellationToken ct, out ServerProblem problem)
{
problem = ServerProblem.Unreachable;
switch (ex)
{
case TitanoApiException { Status: HttpStatusCode.Unauthorized }:
problem = ServerProblem.SignedOut;
return true;
case TitanoApiException api:
return api.IsTransient;
case UntrustedCertificateException untrusted:
// The pinning remembers its last rejection; once trusted, a later network error can still carry it.
if (!_settings.TrustedFingerprints.Contains(untrusted.Fingerprint, StringComparer.OrdinalIgnoreCase))
problem = ServerProblem.CertificateChanged;
return true;
case HttpRequestException:
return true;
case OperationCanceledException when !ct.IsCancellationRequested:
return true; // request timeout
default:
return false;
}
}
private void OnServerProblem(ServerProblem problem, Exception ex)
{
switch (problem)
{
case ServerProblem.SignedOut:
Log.Warning("session", "The server rejected the token; signing out");
StopProbing();
ForgetToken();
SessionEnded?.Invoke(this, problem);
break;
case ServerProblem.CertificateChanged:
// Never upload to a server whose certificate changed: the user must sign in and confirm it again.
Log.Warning("session", "The server certificate changed; sign in again to review it", ex);
StopProbing();
ForgetToken();
SessionEnded?.Invoke(this, problem);
break;
default:
if (State != ConnectionState.Offline) Log.Warning("session", "Server unreachable; retrying every 30 s", ex);
State = ConnectionState.Offline;
StartProbing();
break;
}
}
private void StartProbing()
{
if (_probe is not null) return;
_probe = new CancellationTokenSource();
_ = ProbeAsync(_probe.Token);
}
private void StopProbing()
{
_probe?.Cancel();
_probe?.Dispose();
_probe = null;
}
private async Task ProbeAsync(CancellationToken ct)
{
try
{
while (!ct.IsCancellationRequested && State == ConnectionState.Offline)
{
await Task.Delay(ProbeInterval, ct);
await RefreshAsync();
}
}
catch (OperationCanceledException)
{
}
}
private static SignInResult Classify(Exception ex, CancellationToken ct) => ex switch
{
UntrustedCertificateException => SignInResult.Untrusted,
TitanoApiException { Status: HttpStatusCode.Unauthorized or HttpStatusCode.Forbidden } => SignInResult.BadCredentials,
TitanoApiException { Status: HttpStatusCode.NotFound } => SignInResult.NotTitano,
TitanoApiException api when api.IsTransient => SignInResult.Unreachable,
JsonException or NotSupportedException => SignInResult.NotTitano,
HttpRequestException => SignInResult.Unreachable,
OperationCanceledException when !ct.IsCancellationRequested => SignInResult.Unreachable,
_ => SignInResult.Failed,
};
private bool Set<T>(ref T field, T value, [CallerMemberName] string? name = null)
{
if (EqualityComparer<T>.Default.Equals(field, value)) return false;
field = value;
OnPropertyChanged(name);
return true;
}
private void OnPropertyChanged([CallerMemberName] string? name = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}
@@ -0,0 +1,22 @@
<ui:TitanoWindow x:Class="Titano.Uploader.Shell.ConfirmDialog"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:ui="clr-namespace:Titano.Ui.Controls;assembly=Titano.Ui"
xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui"
Title="{l:Loc Uploader.App.Title}"
IsDialog="True" ResizeMode="NoResize" SizeToContent="Height" Width="440"
WindowStartupLocation="CenterOwner" ShowInTaskbar="False">
<!-- DESIGN §4 dialog: two buttons, safe action left and default, the action on the right. -->
<StackPanel Margin="24,18,24,20">
<TextBlock Text="{Binding Heading}" Style="{StaticResource Text.Title}" TextWrapping="Wrap" TextTrimming="None" />
<TextBlock Text="{Binding Message}" Margin="0,8,0,0" Foreground="{DynamicResource Brush.TextMuted}" TextWrapping="Wrap" />
<Border Style="{StaticResource Border.Card}" Margin="0,16,0,0" Padding="12,10" ToolTip="{Binding DetailToolTip}"
Visibility="{Binding Detail, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
<TextBlock Text="{Binding Detail}" FontFamily="{StaticResource Font.Mono}" FontSize="{StaticResource Size.Secondary}" TextWrapping="Wrap" LineHeight="18" />
</Border>
<StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,24,0,0">
<Button Content="{Binding SafeText}" ToolTip="{Binding SafeToolTip}" IsDefault="True" IsCancel="True" MinWidth="96" Click="OnSafe" />
<Button x:Name="Action" Content="{Binding ActionText}" ToolTip="{Binding ActionToolTip}" MinWidth="96" Margin="8,0,0,0" Click="OnAction" />
</StackPanel>
</StackPanel>
</ui:TitanoWindow>
@@ -0,0 +1,47 @@
using System.Windows;
using Titano.Ui.Controls;
namespace Titano.Uploader.Shell;
/// <summary>Texts of a <see cref="ConfirmDialog"/>.</summary>
public sealed record ConfirmRequest
{
public required string Heading { get; init; }
public required string Message { get; init; }
/// <summary>Monospaced detail (certificate fingerprint); null hides it.</summary>
public string? Detail { get; init; }
public string? DetailToolTip { get; init; }
public required string SafeText { get; init; }
public required string SafeToolTip { get; init; }
public required string ActionText { get; init; }
public required string ActionToolTip { get; init; }
/// <summary>Warning-outlined action (never a primary) for data-destroying choices.</summary>
public bool IsDestructive { get; init; }
}
/// <summary>Modal confirmation used for trusting a certificate and for destructive options (BRIEF §12.1).</summary>
public sealed partial class ConfirmDialog : TitanoWindow
{
private ConfirmDialog(ConfirmRequest request)
{
DataContext = request;
InitializeComponent();
Action.SetResourceReference(StyleProperty, request.IsDestructive ? "Button.Destructive" : "Button.Primary");
}
/// <summary>True when the user chose the action.</summary>
public static bool Ask(Window? owner, ConfirmRequest request)
{
var dialog = new ConfirmDialog(request);
if (owner is { IsVisible: true }) dialog.Owner = owner;
else dialog.WindowStartupLocation = WindowStartupLocation.CenterScreen;
return dialog.ShowDialog() == true;
}
private void OnSafe(object sender, RoutedEventArgs e) => DialogResult = false;
private void OnAction(object sender, RoutedEventArgs e) => DialogResult = true;
}
@@ -0,0 +1,101 @@
using System.Collections.ObjectModel;
using System.Windows.Input;
using Titano.Core.Localization;
using Titano.Ui.Mvvm;
using Titano.Uploader.Server;
namespace Titano.Uploader.Shell;
/// <summary>
/// First-run and signed-out form: server address (with servers found on the LAN), user, password. A self-signed
/// certificate is shown to the user once (trust on first use) before the password is sent.
/// </summary>
public sealed class ConnectViewModel : ObservableObject
{
private readonly IServerSession _session;
private readonly IUploaderDialogs _dialogs;
private string _address;
private string _username;
private string? _errorText;
public ConnectViewModel(IServerSession session, IUploaderDialogs dialogs, string? address, string? username)
{
_session = session;
_dialogs = dialogs;
_address = Display(address);
_username = username ?? string.Empty;
SignInCommand = new AsyncRelayCommand(SignInAsync);
UseServerCommand = new RelayCommand(p =>
{
if (p is DiscoveredServer s) Address = s.Address;
});
}
/// <summary>Servers that announced themselves on this network.</summary>
public ObservableCollection<DiscoveredServer> Discovered { get; } = [];
public ICommand SignInCommand { get; }
public ICommand UseServerCommand { get; }
public string Address
{
get => _address;
set => Set(ref _address, value);
}
public string Username
{
get => _username;
set => Set(ref _username, value);
}
/// <summary>Set from the view's PasswordBox; never stored.</summary>
public string Password { private get; set; } = string.Empty;
/// <summary>One sentence saying what went wrong; the retry action sits next to it.</summary>
public string? ErrorText
{
get => _errorText;
private set => Set(ref _errorText, value);
}
/// <summary>Shows the server address without the trailing slash of the stored base URL.</summary>
public static string Display(string? address) => address?.TrimEnd('/') ?? string.Empty;
public void AddDiscovered(DiscoveredServer server)
{
if (Discovered.Any(d => d.Address == server.Address)) return;
Discovered.Add(server);
if (Address.Length == 0 && Discovered.Count == 1) Address = server.Address;
}
private async Task SignInAsync()
{
if (_session.State is not (ConnectionState.NotConfigured or ConnectionState.SignedOut)) return;
ErrorText = null;
var (result, fingerprint) = await _session.SignInAsync(Address, Username.Trim(), Password, CancellationToken.None);
if (result == SignInResult.Untrusted && fingerprint is not null)
{
if (!_dialogs.ConfirmTrust(Display(Address), fingerprint))
{
ErrorText = Loc.L("Uploader.Connect.Error.Untrusted");
return;
}
_session.Trust(fingerprint);
(result, _) = await _session.SignInAsync(Address, Username.Trim(), Password, CancellationToken.None);
}
ErrorText = result switch
{
SignInResult.Success => null,
SignInResult.InvalidAddress => Loc.L("Uploader.Connect.Error.InvalidAddress"),
SignInResult.Unreachable => Loc.L("Uploader.Connect.Error.Unreachable"),
SignInResult.NotTitano => Loc.L("Uploader.Connect.Error.NotTitano"),
SignInResult.BadCredentials => Loc.L("Uploader.Connect.Error.BadCredentials"),
SignInResult.Untrusted => Loc.L("Uploader.Connect.Error.Untrusted"),
_ => Loc.L("Uploader.Connect.Error.Failed"),
};
if (result != SignInResult.Success) return;
Address = Display(_session.Address);
Password = string.Empty;
}
}
+88
View File
@@ -0,0 +1,88 @@
using System.Globalization;
using System.Windows;
using System.Windows.Data;
using Titano.Core.Localization;
using Titano.Ui.Controls;
using Titano.Uploader.Text;
using Titano.Uploader.Uploads;
namespace Titano.Uploader.Shell;
/// <summary><see cref="UploadItemState"/> → status glyph kind (DESIGN §4: colour always paired with a glyph and a word).</summary>
public sealed class UploadStateKindConverter : IValueConverter
{
public static UploadStateKindConverter Instance { get; } = new();
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) => value switch
{
UploadItemState.Hashing => StatusKind.Analysing,
UploadItemState.Uploading => StatusKind.Running,
UploadItemState.Verified => StatusKind.Done,
UploadItemState.Skipped => StatusKind.Synced,
UploadItemState.Failed => StatusKind.Failed,
_ => StatusKind.Queued,
};
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
}
/// <summary><see cref="UploadItemState"/> → its localized word.</summary>
public sealed class UploadStateTextConverter : IValueConverter
{
public static UploadStateTextConverter Instance { get; } = new();
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) => value switch
{
UploadItemState.Hashing => Loc.L("Uploader.State.Hashing"),
UploadItemState.Uploading => Loc.L("Uploader.State.Uploading"),
UploadItemState.Verified => Loc.L("Uploader.State.Verified"),
UploadItemState.Skipped => Loc.L("Uploader.State.Skipped"),
UploadItemState.Failed => Loc.L("Uploader.State.Failed"),
_ => Loc.L("Uploader.State.Queued"),
};
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
}
/// <summary>(<see cref="UploadFailure"/>, detail) → one sentence for the tooltip of a failed item; null otherwise.</summary>
public sealed class FailureTextConverter : IMultiValueConverter
{
public static FailureTextConverter Instance { get; } = new();
public object? Convert(object?[] values, Type targetType, object? parameter, CultureInfo culture) =>
values is [UploadFailure failure, var detail, ..] ? Describe(failure, detail as string) : null;
public object[] ConvertBack(object? value, Type[] targetTypes, object? parameter, CultureInfo culture) => throw new NotSupportedException();
private static string? Describe(UploadFailure failure, string? detail) => failure switch
{
UploadFailure.FileMissing => Loc.L("Uploader.Failure.FileMissing"),
UploadFailure.FileUnreadable => Loc.L("Uploader.Failure.FileUnreadable"),
UploadFailure.FileChanged => Loc.L("Uploader.Failure.FileChanged"),
UploadFailure.ServerRejected => Loc.L("Uploader.Failure.ServerRejected", detail ?? string.Empty),
UploadFailure.Unexpected => Loc.L("Uploader.Failure.Unexpected"),
_ => null,
};
}
/// <summary>Visible only for <see cref="UploadItemState.Failed"/>; hidden (keeping its space) otherwise so rows stay aligned.</summary>
public sealed class FailedToVisibleConverter : IValueConverter
{
public static FailedToVisibleConverter Instance { get; } = new();
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) =>
value is UploadItemState.Failed ? Visibility.Visible : Visibility.Hidden;
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
}
/// <summary>Byte count → "25.4 MB".</summary>
public sealed class SizeConverter : IValueConverter
{
public static SizeConverter Instance { get; } = new();
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) =>
value is long bytes ? UploaderText.Bytes(bytes, Loc.Culture) : string.Empty;
public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
}
+554
View File
@@ -0,0 +1,554 @@
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Windows.Input;
using System.Windows.Threading;
using Titano.Core.Diagnostics;
using Titano.Core.Localization;
using Titano.Ui.Controls;
using Titano.Ui.Mvvm;
using Titano.Uploader.Infrastructure;
using Titano.Uploader.Server;
using Titano.Uploader.Sources;
using Titano.Uploader.Text;
using Titano.Uploader.Uploads;
using Titano.Uploader.Watching;
namespace Titano.Uploader.Shell;
/// <summary>A sequence offered as upload target.</summary>
public sealed record SequenceOption(Guid Id, string Title);
/// <summary>Everything the window works with; the capture mode passes design-time implementations.</summary>
public sealed record UploaderServices(
UploaderSettings Settings,
Action SaveSettings,
IServerSession Session,
UploadQueue Queue,
IUploadEngine Engine,
IStartupRegistration Startup,
IUploaderDialogs Dialogs,
WatchFolderService Watch,
ProcessedFileMemory Memory,
string LogDirectory);
/// <summary>State of the uploader window (BRIEF §15, mockup Uploader.html).</summary>
public sealed class MainViewModel : LocalizedViewModel
{
private readonly UploaderServices _s;
private readonly DispatcherTimer _refresh;
private UploadTargetMode _target;
private SequenceOption? _selectedSequence;
private bool _loadingSequences;
private string _newTitle;
private bool _isSettingsOpen;
private bool _startWithWindows;
private string _queueText = string.Empty;
private string _progressText = string.Empty;
private string? _currentFileText;
private double _progress;
private UploadItem? _currentItem;
public MainViewModel(UploaderServices services)
{
_s = services;
_target = services.Settings.Target;
_newTitle = services.Settings.NewSequenceTitle ?? string.Empty;
_startWithWindows = services.Startup.IsEnabled;
Connect = new ConnectViewModel(services.Session, services.Dialogs, services.Settings.ServerUrl, services.Settings.Username);
foreach (var w in services.Settings.WatchFolders) WatchFolders.Add(NewWatchFolder(w.Path, w.IntervalSeconds));
OpenSettingsCommand = new RelayCommand(() => IsSettingsOpen = true);
CloseSettingsCommand = new RelayCommand(() => IsSettingsOpen = false);
SignOutCommand = new AsyncRelayCommand(SignOutAsync);
BrowseFilesCommand = new AsyncRelayCommand(() => EnqueueAsync(_s.Dialogs.PickFiles()));
BrowseFolderCommand = new AsyncRelayCommand(() => _s.Dialogs.PickFolder() is { } folder ? EnqueueAsync([folder]) : Task.CompletedTask);
RefreshSequencesCommand = new AsyncRelayCommand(LoadSequencesAsync);
PauseCommand = new RelayCommand(TogglePause, () => HasItems);
StopCommand = new RelayCommand(() => _s.Engine.StopAndClear(), () => HasItems);
RetryItemCommand = new RelayCommand(p =>
{
if (p is UploadItem item) _s.Engine.Retry(item);
});
AddWatchFolderCommand = new RelayCommand(AddWatchFolder);
ToggleDeleteAfterUploadCommand = new RelayCommand(ToggleDeleteAfterUpload);
_s.Session.PropertyChanged += OnSessionChanged;
_s.Session.SessionEnded += OnSessionEnded;
_s.Engine.PropertyChanged += (_, _) => RefreshQueue();
_s.Engine.Drained += OnDrained;
_s.Queue.Items.CollectionChanged += (_, _) =>
{
OnPropertyChanged(nameof(HasItems));
CommandManager.InvalidateRequerySuggested();
};
_refresh = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromMilliseconds(500) };
_refresh.Tick += (_, _) => RefreshQueue();
RefreshQueue();
}
/// <summary>Raised when the queue finished while work was done, with the number of files the server confirmed.</summary>
public event Action<int>? UploadsCompleted;
public ConnectViewModel Connect { get; }
/// <summary>In-window notifications; the window forwards them to its <see cref="ToastHost"/>.</summary>
public ObservableCollection<Toast> PendingToasts { get; } = [];
public ICommand OpenSettingsCommand { get; }
public ICommand CloseSettingsCommand { get; }
public ICommand SignOutCommand { get; }
public ICommand BrowseFilesCommand { get; }
public ICommand BrowseFolderCommand { get; }
public ICommand RefreshSequencesCommand { get; }
public ICommand PauseCommand { get; }
public ICommand StopCommand { get; }
public ICommand RetryItemCommand { get; }
public ICommand AddWatchFolderCommand { get; }
public ICommand ToggleDeleteAfterUploadCommand { get; }
// ---------------- Header ----------------
public string ServerText => _s.Session.State == ConnectionState.NotConfigured
? Loc.L("Uploader.Header.NotConnected")
: ConnectViewModel.Display(_s.Session.Address);
public string? UserText => _s.Session.State is ConnectionState.Connected or ConnectionState.Offline or ConnectionState.SigningIn ? _s.Session.Username : null;
public StatusKind ConnectionKind => _s.Session.State switch
{
ConnectionState.Connected => StatusKind.Online,
ConnectionState.SigningIn => StatusKind.Running,
_ => StatusKind.Offline,
};
/// <summary>Null on first run, when the server line already says "Not connected".</summary>
public string? ConnectionText => _s.Session.State switch
{
ConnectionState.Connected => Loc.L("Uploader.Status.Connected"),
ConnectionState.SigningIn => Loc.L("Uploader.Status.SigningIn"),
ConnectionState.Offline => Loc.L("Uploader.Status.Offline"),
ConnectionState.SignedOut => Loc.L("Uploader.Status.SignedOut"),
_ => null,
};
/// <summary>"1.9 TB free of 5 TB"; null without a quota.</summary>
public string? QuotaText => _s.Session.State == ConnectionState.Connected && _s.Session.QuotaBytes > 0
? Loc.L("Uploader.Header.Quota", UploaderText.Bytes(Math.Max(0, _s.Session.QuotaBytes - _s.Session.UsedBytes), Loc.Culture), UploaderText.Bytes(_s.Session.QuotaBytes, Loc.Culture))
: null;
/// <summary>The sign-in form replaces the queue on first run and after signing out.</summary>
public bool IsConnectVisible => _s.Session.State is ConnectionState.NotConfigured or ConnectionState.SignedOut;
public bool IsSettingsOpen
{
get => _isSettingsOpen;
set => Set(ref _isSettingsOpen, value);
}
// ---------------- Target ----------------
public bool IsSessionsTarget
{
get => _target == UploadTargetMode.Sessions;
set => SetTarget(value, UploadTargetMode.Sessions);
}
public bool IsSequenceTarget
{
get => _target == UploadTargetMode.Sequence;
set => SetTarget(value, UploadTargetMode.Sequence);
}
public bool IsNewTarget
{
get => _target == UploadTargetMode.NewSequence;
set => SetTarget(value, UploadTargetMode.NewSequence);
}
public ObservableCollection<SequenceOption> Sequences { get; } = [];
public SequenceOption? SelectedSequence
{
get => _selectedSequence;
set
{
if (_loadingSequences || !Set(ref _selectedSequence, value)) return;
_s.Settings.TargetSequenceId = value?.Id;
_s.SaveSettings();
}
}
public string NewTitle
{
get => _newTitle;
set
{
if (!Set(ref _newTitle, value)) return;
_s.Settings.NewSequenceTitle = value;
_s.SaveSettings();
}
}
// ---------------- Queue ----------------
public ObservableCollection<UploadItem> Items => _s.Queue.Items;
public bool HasItems => _s.Queue.Items.Count > 0;
/// <summary>"4,812 files · 96.2 GB · 38 MB/s · 41 min left".</summary>
public string QueueText
{
get => _queueText;
private set => Set(ref _queueText, value);
}
/// <summary>"2,214 of 4,812 sent · 2,201 verified by the server · 0 retries".</summary>
public string ProgressText
{
get => _progressText;
private set => Set(ref _progressText, value);
}
public string? CurrentFileText
{
get => _currentFileText;
private set => Set(ref _currentFileText, value);
}
public double Progress
{
get => _progress;
private set => Set(ref _progress, value);
}
/// <summary>The item being uploaded; the list keeps it in view.</summary>
public UploadItem? CurrentItem
{
get => _currentItem;
private set => Set(ref _currentItem, value);
}
public bool IsPaused => _s.Queue.IsPaused;
public string PauseToolTip => Loc.L(IsPaused ? "Tooltips.Uploader.Resume" : "Tooltips.Uploader.Pause");
/// <summary>Accessible name of the pause/resume button (also the tray menu entry).</summary>
public string PauseLabel => Loc.L(IsPaused ? "Uploader.Action.Resume" : "Uploader.Action.Pause");
/// <summary>Upload limit in MB/s as typed; 0 = unlimited. Text that is not a whole number reverts.</summary>
public string BandwidthLimitText
{
get => _s.Session.BandwidthLimit.ToString(Loc.Culture);
set
{
if (int.TryParse(value, NumberStyles.Integer, Loc.Culture, out var limit))
{
limit = Math.Clamp(limit, 0, 100_000);
if (limit != _s.Session.BandwidthLimit)
{
_s.Session.BandwidthLimit = limit;
_s.Settings.BandwidthLimit = limit;
_s.SaveSettings();
}
}
OnPropertyChanged();
}
}
/// <summary>Tray hover text.</summary>
public string TrayText => Loc.L("Uploader.App.Title") + (HasItems ? " · " + QueueText : string.Empty);
// ---------------- Watch folders ----------------
public ObservableCollection<WatchFolderViewModel> WatchFolders { get; } = [];
// ---------------- Options ----------------
/// <summary>Turned on only through <see cref="ToggleDeleteAfterUploadCommand"/>, which asks first.</summary>
public bool DeleteAfterUpload => _s.Settings.DeleteAfterUpload;
public bool StartWithWindows
{
get => _startWithWindows;
set
{
_s.Startup.SetEnabled(value);
// Read back: the registry may refuse the change.
_startWithWindows = _s.Startup.IsEnabled;
OnPropertyChanged();
}
}
public bool MinimizeToTray
{
get => _s.Settings.MinimizeToTray;
set
{
if (_s.Settings.MinimizeToTray == value) return;
_s.Settings.MinimizeToTray = value;
_s.SaveSettings();
OnPropertyChanged();
}
}
// ---------------- Actions ----------------
/// <summary>Starts the periodic refresh and, when signed in, loads the sequence list.</summary>
public void Start()
{
_refresh.Start();
if (_s.Session.State == ConnectionState.Connected) _ = LoadSequencesAsync();
}
/// <summary>Starts watching every configured folder.</summary>
public void StartWatching()
{
foreach (var w in WatchFolders) _s.Watch.Watch(w.Path, TimeSpan.FromSeconds(w.IntervalSeconds));
}
/// <summary>Adds the photos under <paramref name="paths"/> (files, folders, card roots) to the queue.</summary>
public async Task EnqueueAsync(IReadOnlyList<string> paths)
{
if (paths.Count == 0) return;
if (_target == UploadTargetMode.Sequence && SelectedSequence is null)
{
ShowToast(Loc.L("Uploader.Toast.ChooseSequence"));
return;
}
var found = await Task.Run(() => PhotoScanner.Scan(paths));
var fresh = found.Where(f => !_s.Queue.ContainsPath(f.Path)).ToList();
if (fresh.Count == 0)
{
ShowToast(Loc.L("Uploader.Toast.NothingFound"));
return;
}
var batch = new UploadBatch
{
Id = Guid.CreateVersion7(),
Mode = _target,
SequenceId = _target == UploadTargetMode.Sequence ? SelectedSequence?.Id : null,
Title = _target == UploadTargetMode.NewSequence ? NewTitle.Trim() : null,
};
var entries = _target == UploadTargetMode.Sessions
? SessionEntries(fresh, null, null, out _)
: [.. fresh.OrderBy(f => f.CapturedAt).Select(f => new QueueEntry(f.Path, f.Size, f.ModifiedUtc, f.CapturedAt, null, null))];
var added = Add(batch, entries);
Log.Info("queue", $"{added} file(s) added from {paths.Count} path(s), target {_target}");
ShowToast(Loc.Plural("Uploader.Toast.Added", added));
}
/// <summary>Queues stable new photos of a watch folder; they join the folder's last session when close in time.</summary>
public void OnWatchFilesReady(string root, IReadOnlyList<SourceFile> files)
{
var fresh = files.Where(f => !_s.Queue.ContainsPath(f.Path)).ToList();
if (fresh.Count == 0) return;
var entries = SessionEntries(fresh, root, _s.Memory.GetSession(root), out var last);
Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions }, entries);
_s.Memory.SetSession(root, last);
}
public void OnWatchAvailabilityChanged(string root, bool available)
{
var folder = WatchFolders.FirstOrDefault(w => string.Equals(w.Path, root, StringComparison.OrdinalIgnoreCase));
if (folder is not null) folder.IsAvailable = available;
}
/// <summary>Errors are one sentence plus one action (BRIEF §0.2 rule 6).</summary>
public void ReportError(Exception ex)
{
Log.Error("ui", "Operation failed", ex);
ShowToast(Loc.L("Errors.Unexpected"), Loc.L("Common.OpenLogs"), Loc.L("Tooltips.Common.OpenLogs"), new RelayCommand(OpenLogs));
}
public void TogglePause()
{
if (_s.Queue.IsPaused) _s.Engine.Resume();
else _s.Engine.Pause();
RefreshQueue();
}
public override void Dispose()
{
_refresh.Stop();
_s.Session.PropertyChanged -= OnSessionChanged;
_s.Session.SessionEnded -= OnSessionEnded;
_s.Engine.Drained -= OnDrained;
base.Dispose();
}
private int Add(UploadBatch batch, IReadOnlyList<QueueEntry> entries)
{
// A new batch after a finished one starts a fresh count.
if (!_s.Queue.HasPending) _s.Queue.RemoveCompleted();
var added = _s.Queue.Add(batch, entries);
_s.Engine.Pump();
RefreshQueue();
return added;
}
/// <summary>Session keys per source folder (BRIEF §13 rules), entries in capture order.</summary>
private static List<QueueEntry> SessionEntries(IReadOnlyList<SourceFile> files, string? watchRoot, SessionContinuation? previous, out SessionContinuation? last)
{
var entries = new List<QueueEntry>(files.Count);
last = previous;
foreach (var group in files.GroupBy(f => watchRoot ?? f.Root, StringComparer.OrdinalIgnoreCase))
{
var ordered = group.OrderBy(f => f.CapturedAt).ToList();
var assignment = SessionGrouper.Assign([.. ordered.Select(f => f.CapturedAt)], SessionGrouper.SourceTag(group.Key), watchRoot is null ? null : previous);
for (var i = 0; i < ordered.Count; i++)
{
var f = ordered[i];
entries.Add(new QueueEntry(f.Path, f.Size, f.ModifiedUtc, f.CapturedAt, assignment.Keys[i], watchRoot));
}
last = assignment.Last;
}
return entries;
}
/// <summary>Recomputes the queue line, progress and current file (also every 500 ms once started).</summary>
public void RefreshQueue()
{
var summary = QueueSummary.From(_s.Queue.Items);
var rate = _s.Engine.BytesPerSecond;
var activity = summary.Files == 0 ? QueueActivity.Idle : _s.Engine.Status switch
{
EngineStatus.Paused => QueueActivity.Paused,
EngineStatus.WaitingForServer => QueueActivity.WaitingForServer,
EngineStatus.Running => QueueActivity.Running,
_ => QueueActivity.Done,
};
QueueText = UploaderText.QueueLine(summary, activity, rate, RateMeter.TimeLeft(summary.RemainingBytes, rate), Loc.Culture);
ProgressText = summary.Files == 0 ? string.Empty : UploaderText.ProgressLine(summary, Loc.Culture);
Progress = summary.Progress;
CurrentFileText = summary.CurrentFile;
CurrentItem = _s.Queue.Items.FirstOrDefault(i => i.State == UploadItemState.Uploading) ?? _s.Queue.Items.FirstOrDefault(i => i.IsActive);
OnPropertyChanged(nameof(IsPaused));
OnPropertyChanged(nameof(PauseToolTip));
OnPropertyChanged(nameof(PauseLabel));
OnPropertyChanged(nameof(TrayText));
}
private void SetTarget(bool selected, UploadTargetMode mode)
{
if (!selected || _target == mode) return;
_target = mode;
_s.Settings.Target = mode;
_s.SaveSettings();
OnPropertyChanged(nameof(IsSessionsTarget));
OnPropertyChanged(nameof(IsSequenceTarget));
OnPropertyChanged(nameof(IsNewTarget));
if (mode == UploadTargetMode.Sequence && Sequences.Count == 0) _ = LoadSequencesAsync();
}
private async Task LoadSequencesAsync()
{
var list = await _s.Session.ListSequencesAsync(CancellationToken.None);
if (list.Count == 0 && Sequences.Count > 0) return;
_loadingSequences = true;
try
{
Sequences.Clear();
foreach (var s in list.OrderBy(s => s.DisplayTitle, StringComparer.CurrentCultureIgnoreCase)) Sequences.Add(new SequenceOption(s.Id, s.DisplayTitle));
}
finally
{
_loadingSequences = false;
}
_selectedSequence = Sequences.FirstOrDefault(s => s.Id == _s.Settings.TargetSequenceId);
OnPropertyChanged(nameof(SelectedSequence));
}
private async Task SignOutAsync()
{
IsSettingsOpen = false;
await _s.Session.SignOutAsync();
}
private void ToggleDeleteAfterUpload()
{
var enable = !_s.Settings.DeleteAfterUpload;
if (enable && !_s.Dialogs.ConfirmDeleteAfterUpload())
{
// The check box toggled itself; put it back.
OnPropertyChanged(nameof(DeleteAfterUpload));
return;
}
_s.Settings.DeleteAfterUpload = enable;
_s.SaveSettings();
Log.Info("settings", "Delete after verified upload " + (enable ? "on" : "off"));
OnPropertyChanged(nameof(DeleteAfterUpload));
}
private void AddWatchFolder()
{
if (_s.Dialogs.PickWatchFolder() is not { } path) return;
if (WatchFolders.Any(w => string.Equals(w.Path, path, StringComparison.OrdinalIgnoreCase))) return;
var interval = (int)WatchFolderService.DefaultInterval(path).TotalSeconds;
_s.Settings.WatchFolders.Add(new UploaderSettings.WatchFolderSettings { Path = path, IntervalSeconds = interval });
_s.SaveSettings();
WatchFolders.Add(NewWatchFolder(path, interval));
_s.Watch.Watch(path, TimeSpan.FromSeconds(interval));
}
private WatchFolderViewModel NewWatchFolder(string path, int intervalSeconds) =>
new(path, intervalSeconds, WatchFolderService.IsNetworkPath(path), SetWatchInterval, RemoveWatchFolder);
private void SetWatchInterval(WatchFolderViewModel folder, int seconds)
{
folder.IntervalSeconds = seconds;
foreach (var w in _s.Settings.WatchFolders.Where(w => string.Equals(w.Path, folder.Path, StringComparison.OrdinalIgnoreCase))) w.IntervalSeconds = seconds;
_s.SaveSettings();
_s.Watch.Watch(folder.Path, TimeSpan.FromSeconds(seconds));
}
private void RemoveWatchFolder(WatchFolderViewModel folder)
{
_s.Watch.Stop(folder.Path);
_s.Memory.RemoveFolder(folder.Path);
_s.Settings.WatchFolders.RemoveAll(w => string.Equals(w.Path, folder.Path, StringComparison.OrdinalIgnoreCase));
_s.SaveSettings();
WatchFolders.Remove(folder);
}
private void OnSessionChanged(object? sender, PropertyChangedEventArgs e)
{
OnPropertyChanged(nameof(ServerText));
OnPropertyChanged(nameof(UserText));
OnPropertyChanged(nameof(ConnectionKind));
OnPropertyChanged(nameof(ConnectionText));
OnPropertyChanged(nameof(QuotaText));
OnPropertyChanged(nameof(IsConnectVisible));
OnPropertyChanged(nameof(BandwidthLimitText));
if (e.PropertyName != nameof(IServerSession.State)) return;
if (_s.Session.State == ConnectionState.Connected) _ = LoadSequencesAsync();
if (IsConnectVisible)
{
Connect.Address = ConnectViewModel.Display(_s.Session.Address);
Connect.Username = _s.Session.Username ?? Connect.Username;
}
CommandManager.InvalidateRequerySuggested();
}
private void OnSessionEnded(object? sender, ServerProblem problem) =>
ShowToast(Loc.L(problem == ServerProblem.CertificateChanged ? "Uploader.Toast.CertificateChanged" : "Uploader.Toast.SignedOut"));
private void OnDrained(object? sender, EventArgs e)
{
// The queue restarts its count with each new batch, so every confirmed item belongs to this run.
var confirmed = _s.Queue.Items.Count(i => i.IsDone);
RefreshQueue();
_ = _s.Session.RefreshAsync();
if (confirmed > 0) UploadsCompleted?.Invoke(confirmed);
}
private void ShowToast(string title, string? actionText = null, string? actionToolTip = null, ICommand? action = null) =>
PendingToasts.Add(new Toast { Title = title, ActionText = actionText, ActionToolTip = actionToolTip, ActionCommand = action });
private void OpenLogs()
{
if (Directory.Exists(_s.LogDirectory)) Process.Start(new ProcessStartInfo(_s.LogDirectory) { UseShellExecute = true, Verb = "explore" });
}
}
+433
View File
@@ -0,0 +1,433 @@
<ui:TitanoWindow x:Class="Titano.Uploader.Shell.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:ui="clr-namespace:Titano.Ui.Controls;assembly=Titano.Ui"
xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui"
xmlns:s="clr-namespace:Titano.Uploader.Shell"
xmlns:u="clr-namespace:Titano.Uploader.Uploads"
Title="{l:Loc Uploader.App.Title}"
Width="760" Height="560" MinWidth="640" MinHeight="480"
WindowStartupLocation="CenterScreen" AllowDrop="True">
<Window.Resources>
<Style x:Key="Text.Label" TargetType="TextBlock" BasedOn="{StaticResource Text.Base}">
<Setter Property="Foreground" Value="{DynamicResource Brush.TextMuted}" />
<Setter Property="MinWidth" Value="92" />
<Setter Property="Margin" Value="0,0,12,0" />
</Style>
<!-- Watch-folder chip (mockup: 28 px pill, Card fill, status dot). -->
<Style x:Key="Button.Chip" TargetType="Button" BasedOn="{StaticResource Button.Base}">
<Setter Property="Height" Value="28" />
<Setter Property="Padding" Value="10,0" />
<Setter Property="ui:ControlState.CornerRadius" Value="14" />
</Style>
<Style x:Key="Button.Round" TargetType="Button" BasedOn="{StaticResource Button.Icon}">
<Setter Property="Width" Value="28" />
<Setter Property="MinWidth" Value="28" />
<Setter Property="Height" Value="28" />
<Setter Property="ui:ControlState.CornerRadius" Value="14" />
</Style>
<Style x:Key="Button.Square" TargetType="Button" BasedOn="{StaticResource Button.Icon}">
<Setter Property="Width" Value="30" />
<Setter Property="MinWidth" Value="30" />
<Setter Property="Height" Value="30" />
</Style>
<!-- Queue rows: hover only, no selection. -->
<Style x:Key="QueueRow" TargetType="ListBoxItem">
<Setter Property="Focusable" Value="False" />
<Setter Property="HorizontalContentAlignment" Value="Stretch" />
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="ListBoxItem">
<Border x:Name="Bd" Background="Transparent" CornerRadius="{StaticResource Radius.Control}" Padding="10,0,4,0">
<ContentPresenter />
</Border>
<ControlTemplate.Triggers>
<Trigger Property="IsMouseOver" Value="True">
<Setter TargetName="Bd" Property="Background" Value="{DynamicResource Brush.Card}" />
</Trigger>
</ControlTemplate.Triggers>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
<Style x:Key="WatchMenuItem" TargetType="MenuItem" BasedOn="{StaticResource {x:Type MenuItem}}">
<Setter Property="Header" Value="{Binding Text}" />
<Setter Property="Command" Value="{Binding Command}" />
<Setter Property="IsChecked" Value="{Binding IsChecked, Mode=OneWay}" />
<Setter Property="ToolTip" Value="{Binding ToolTip}" />
<Style.Triggers>
<DataTrigger Binding="{Binding IsSeparator}" Value="True">
<Setter Property="Height" Value="9" />
<Setter Property="IsEnabled" Value="False" />
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="MenuItem">
<Border Height="1" Margin="4" Background="{DynamicResource Brush.Stroke}" />
</ControlTemplate>
</Setter.Value>
</Setter>
</DataTrigger>
</Style.Triggers>
</Style>
</Window.Resources>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<!-- Header: server · user · connection, quota, settings. -->
<Border Height="40" Background="{DynamicResource Brush.Surface}" BorderBrush="{DynamicResource Brush.Stroke}" BorderThickness="0,0,0,1" Padding="16,0,10,0">
<DockPanel LastChildFill="True">
<Button DockPanel.Dock="Right" Style="{StaticResource Button.Square}" ui:ButtonIcon.Glyph="{StaticResource Icon.Settings}"
Command="{Binding OpenSettingsCommand}" ToolTip="{l:Loc Tooltips.Uploader.Settings}" AutomationProperties.Name="{l:Loc Uploader.Settings.Title}" />
<TextBlock DockPanel.Dock="Right" Text="{Binding QuotaText}" Style="{StaticResource Text.Secondary}" Margin="12,0,12,0"
ToolTip="{l:Loc Tooltips.Uploader.Quota}" Visibility="{Binding QuotaText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}" />
<StackPanel Orientation="Horizontal" VerticalAlignment="Center">
<ui:Icon Glyph="{StaticResource Icon.Server}" Foreground="{DynamicResource Brush.Accent}" Margin="0,0,10,0" VerticalAlignment="Center" />
<TextBlock Text="{Binding ServerText}" Style="{StaticResource Text.Body}" MaxWidth="320" />
<StackPanel Orientation="Horizontal" Visibility="{Binding UserText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
<TextBlock Text="·" Foreground="{DynamicResource Brush.TextFaint}" Margin="10,0" VerticalAlignment="Center" />
<TextBlock Text="{Binding UserText}" Style="{StaticResource Text.Body}" />
</StackPanel>
<StackPanel Orientation="Horizontal" Visibility="{Binding ConnectionText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
<TextBlock Text="·" Foreground="{DynamicResource Brush.TextFaint}" Margin="10,0" VerticalAlignment="Center" />
<ui:StatusGlyph Kind="{Binding ConnectionKind}" Text="{Binding ConnectionText}" FontSize="{StaticResource Size.Body}" VerticalAlignment="Center" />
</StackPanel>
</StackPanel>
</DockPanel>
</Border>
<!-- First run / signed out: connect form. -->
<Grid Grid.Row="1" Visibility="{Binding IsConnectVisible, Converter={StaticResource BoolToVisibility}}">
<StackPanel DataContext="{Binding Connect}" Width="440" HorizontalAlignment="Center" VerticalAlignment="Center">
<ui:BrandMarkIcon Width="48" Height="48" HorizontalAlignment="Center" />
<TextBlock Text="{l:Loc Uploader.Connect.Title}" Style="{StaticResource Text.Title}" HorizontalAlignment="Center" Margin="0,14,0,20" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" MinWidth="92" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<TextBlock Text="{l:Loc Uploader.Connect.Server}" Style="{StaticResource Text.Label}" />
<TextBox Grid.Column="1" Text="{Binding Address, UpdateSourceTrigger=PropertyChanged}" ui:Field.Glyph="{StaticResource Icon.Server}"
ui:Field.Placeholder="{l:Loc Uploader.Connect.AddressPlaceholder}" ToolTip="{l:Loc Tooltips.Uploader.ServerAddress}" AutomationProperties.Name="{l:Loc Uploader.Connect.Server}" />
<TextBlock Grid.Row="1" Text="{l:Loc Uploader.Connect.Found}" Style="{StaticResource Text.Label}" Margin="0,8,12,0" VerticalAlignment="Top"
Visibility="{Binding Discovered.Count, Converter={x:Static ui:ZeroToCollapsedConverter.Instance}}" />
<ItemsControl Grid.Row="1" Grid.Column="1" ItemsSource="{Binding Discovered}" Margin="0,8,0,0" Focusable="False"
Visibility="{Binding Discovered.Count, Converter={x:Static ui:ZeroToCollapsedConverter.Instance}}">
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
<WrapPanel />
</ItemsPanelTemplate>
</ItemsControl.ItemsPanel>
<ItemsControl.ItemTemplate>
<DataTemplate>
<Button Style="{StaticResource Button.Chip}" Margin="0,0,8,4" Command="{Binding DataContext.UseServerCommand, RelativeSource={RelativeSource AncestorType=ItemsControl}}"
CommandParameter="{Binding}" ToolTip="{l:Loc Tooltips.Uploader.DiscoveredServer}" AutomationProperties.Name="{Binding Name}">
<StackPanel Orientation="Horizontal">
<Ellipse Width="8" Height="8" Fill="{DynamicResource Brush.Accent}" Margin="0,0,8,0" VerticalAlignment="Center" />
<TextBlock Text="{Binding Name}" VerticalAlignment="Center" />
<TextBlock Text="{Binding Address}" Foreground="{DynamicResource Brush.TextMuted}" Margin="8,0,0,0" VerticalAlignment="Center" />
</StackPanel>
</Button>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
<TextBlock Grid.Row="2" Text="{l:Loc Uploader.Connect.User}" Style="{StaticResource Text.Label}" Margin="0,12,12,0" />
<TextBox Grid.Row="2" Grid.Column="1" Margin="0,12,0,0" Text="{Binding Username, UpdateSourceTrigger=PropertyChanged}" ui:Field.Glyph="{StaticResource Icon.User}"
ToolTip="{l:Loc Tooltips.Uploader.User}" AutomationProperties.Name="{l:Loc Uploader.Connect.User}" />
<TextBlock Grid.Row="3" Text="{l:Loc Uploader.Connect.Password}" Style="{StaticResource Text.Label}" Margin="0,12,12,0" />
<PasswordBox x:Name="Password" Grid.Row="3" Grid.Column="1" Margin="0,12,0,0" PasswordChanged="OnPasswordChanged"
ToolTip="{l:Loc Tooltips.Uploader.Password}" AutomationProperties.Name="{l:Loc Uploader.Connect.Password}" />
<Border Grid.Row="4" Grid.Column="1" Margin="0,12,0,0" Padding="10,6,6,6" CornerRadius="{StaticResource Radius.Control}" Background="{DynamicResource Brush.ErrorSubtle}"
Visibility="{Binding ErrorText, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
<DockPanel>
<Button DockPanel.Dock="Right" Style="{StaticResource Button.Compact}" Content="{l:Loc Uploader.Action.Retry}" Command="{Binding SignInCommand}"
ToolTip="{l:Loc Tooltips.Uploader.Retry}" Margin="8,0,0,0" />
<ui:Icon Glyph="{StaticResource Icon.ErrorCircle}" Foreground="{DynamicResource Brush.Error}" Margin="0,0,8,0" VerticalAlignment="Center" />
<TextBlock Text="{Binding ErrorText}" TextWrapping="Wrap" VerticalAlignment="Center" />
</DockPanel>
</Border>
<Button Grid.Row="5" Grid.Column="1" Margin="0,20,0,0" HorizontalAlignment="Left" Style="{StaticResource Button.Primary}" MinWidth="120"
IsDefault="{Binding IsVisible, RelativeSource={RelativeSource Self}}"
Content="{l:Loc Uploader.Connect.SignIn}" Command="{Binding SignInCommand}" ToolTip="{l:Loc Tooltips.Uploader.SignIn}" />
</Grid>
</StackPanel>
</Grid>
<!-- Signed in: drop zone, target, queue, watch folders, options. -->
<Grid Grid.Row="1" Margin="16,14,16,14" Grid.IsSharedSizeScope="True"
Visibility="{Binding IsConnectVisible, Converter={x:Static ui:InverseBoolToVisibilityConverter.Instance}}">
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<!-- Drop zone: the empty state's sentence and button. -->
<Grid Height="150" Background="Transparent">
<Rectangle x:Name="DropBorder" RadiusX="8" RadiusY="8" StrokeThickness="2" StrokeDashArray="3 2" SnapsToDevicePixels="True"
Stroke="{DynamicResource Brush.Stroke}" Fill="Transparent" />
<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
<ui:Icon Glyph="{StaticResource Icon.Upload}" Size="28" Foreground="{DynamicResource Brush.TextMuted}" HorizontalAlignment="Center" />
<TextBlock Text="{l:Loc Uploader.Drop.Message}" FontSize="{StaticResource Size.Section}" Foreground="{DynamicResource Brush.TextMuted}"
HorizontalAlignment="Center" Margin="0,10,0,10" />
<Button Content="{l:Loc Uploader.Browse.Button}" Height="30" Padding="14,0" HorizontalAlignment="Center"
ToolTip="{l:Loc Tooltips.Uploader.Browse}" Click="OnBrowseClick">
<Button.ContextMenu>
<ContextMenu>
<MenuItem Header="{l:Loc Uploader.Browse.Files}" Command="{Binding BrowseFilesCommand}" ToolTip="{l:Loc Tooltips.Uploader.BrowseFiles}" />
<MenuItem Header="{l:Loc Uploader.Browse.Folder}" Command="{Binding BrowseFolderCommand}" ToolTip="{l:Loc Tooltips.Uploader.BrowseFolder}" />
</ContextMenu>
</Button.ContextMenu>
</Button>
</StackPanel>
</Grid>
<!-- Target -->
<Grid Grid.Row="1" Margin="0,12,0,0" MinHeight="30">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="Label" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<TextBlock Text="{l:Loc Uploader.Target.Label}" Style="{StaticResource Text.Label}" />
<WrapPanel Grid.Column="1" VerticalAlignment="Center">
<RadioButton GroupName="Target" Content="{l:Loc Uploader.Target.Sessions}" IsChecked="{Binding IsSessionsTarget}" Margin="0,0,16,0" VerticalAlignment="Center"
ToolTip="{l:Loc Tooltips.Uploader.TargetSessions}" />
<RadioButton GroupName="Target" Content="{l:Loc Uploader.Target.Sequence}" IsChecked="{Binding IsSequenceTarget}" Margin="0,0,8,0" VerticalAlignment="Center"
ToolTip="{l:Loc Tooltips.Uploader.TargetSequence}" />
<ComboBox Width="170" Height="30" Margin="0,0,16,0" ItemsSource="{Binding Sequences}" SelectedItem="{Binding SelectedSequence}" DisplayMemberPath="Title"
IsEnabled="{Binding IsSequenceTarget}" DropDownOpened="OnSequencesDropDownOpened" ToolTip="{l:Loc Tooltips.Uploader.ChooseSequence}"
AutomationProperties.Name="{l:Loc Uploader.Target.Sequence}" />
<RadioButton GroupName="Target" Content="{l:Loc Uploader.Target.New}" IsChecked="{Binding IsNewTarget}" Margin="0,0,8,0" VerticalAlignment="Center"
ToolTip="{l:Loc Tooltips.Uploader.TargetNew}" />
<TextBox Width="150" Height="30" Text="{Binding NewTitle}" ui:Field.Placeholder="{l:Loc Uploader.Target.TitlePlaceholder}"
Visibility="{Binding IsNewTarget, Converter={StaticResource BoolToVisibility}}" ToolTip="{l:Loc Tooltips.Uploader.NewTitle}"
AutomationProperties.Name="{l:Loc Uploader.Target.TitlePlaceholder}" />
</WrapPanel>
</Grid>
<!-- Queue line, pause/stop, bandwidth limit -->
<Grid Grid.Row="2" Margin="0,12,0,0" MinHeight="30">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="Label" />
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<TextBlock Text="{l:Loc Uploader.Queue.Label}" Style="{StaticResource Text.Label}" />
<TextBlock Grid.Column="1" Text="{Binding QueueText}" Style="{StaticResource Text.Body}" Typography.NumeralAlignment="Tabular" />
<StackPanel Grid.Column="2" Orientation="Horizontal" Margin="10,0,0,0">
<Button Command="{Binding PauseCommand}" ToolTip="{Binding PauseToolTip}" AutomationProperties.Name="{Binding PauseLabel}">
<Button.Style>
<Style TargetType="Button" BasedOn="{StaticResource Button.Square}">
<Setter Property="ui:ButtonIcon.Glyph" Value="{StaticResource Icon.Pause}" />
<Style.Triggers>
<DataTrigger Binding="{Binding IsPaused}" Value="True">
<Setter Property="ui:ButtonIcon.Glyph" Value="{StaticResource Icon.Play}" />
</DataTrigger>
</Style.Triggers>
</Style>
</Button.Style>
</Button>
<Button Style="{StaticResource Button.Square}" Margin="10,0,0,0" ui:ButtonIcon.Glyph="{StaticResource Icon.Stop}" Command="{Binding StopCommand}"
ToolTip="{l:Loc Tooltips.Uploader.Stop}" AutomationProperties.Name="{l:Loc Uploader.Action.Stop}" />
</StackPanel>
<StackPanel Grid.Column="3" Orientation="Horizontal" Margin="16,0,0,0">
<TextBlock Text="{l:Loc Uploader.Limit.Label}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="0,0,6,0" />
<TextBox Width="58" Height="30" Text="{Binding BandwidthLimitText}" TextAlignment="Right" ToolTip="{l:Loc Tooltips.Uploader.Limit}"
AutomationProperties.Name="{l:Loc Uploader.Limit.Label}" />
<TextBlock Text="{l:Loc Uploader.Limit.Unit}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="6,0,0,0" />
</StackPanel>
</Grid>
<!-- Progress: bar, current file, counts -->
<StackPanel Grid.Row="3" Margin="0,12,0,0" Visibility="{Binding HasItems, Converter={StaticResource BoolToVisibility}}">
<ProgressBar Height="8" Maximum="1" Value="{Binding Progress, Mode=OneWay}" />
<Grid Margin="0,5,0,0">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<TextBlock Text="{Binding CurrentFileText}" Style="{StaticResource Text.Secondary}" />
<TextBlock Grid.Column="1" Text="{Binding ProgressText}" Style="{StaticResource Text.Secondary}" Margin="12,0,0,0" Typography.NumeralAlignment="Tabular" />
</Grid>
</StackPanel>
<!-- Watch folders -->
<Grid Grid.Row="4" Margin="0,12,0,0" MinHeight="30">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="Label" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<TextBlock Text="{l:Loc Uploader.Watch.Label}" Style="{StaticResource Text.Label}" VerticalAlignment="Top" Margin="0,6,12,0" />
<StackPanel Grid.Column="1" Orientation="Horizontal">
<ItemsControl ItemsSource="{Binding WatchFolders}" Focusable="False">
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
<StackPanel Orientation="Horizontal" />
</ItemsPanelTemplate>
</ItemsControl.ItemsPanel>
<ItemsControl.ItemTemplate>
<DataTemplate DataType="{x:Type s:WatchFolderViewModel}">
<Button Style="{StaticResource Button.Chip}" Margin="0,0,10,0" Click="OnWatchChipClick" ToolTip="{Binding ToolTip}" AutomationProperties.Name="{Binding Path}">
<Button.ContextMenu>
<ContextMenu ItemsSource="{Binding MenuOptions}" ItemContainerStyle="{StaticResource WatchMenuItem}" />
</Button.ContextMenu>
<StackPanel Orientation="Horizontal">
<Ellipse x:Name="Dot" Width="8" Height="8" Margin="0,0,8,0" VerticalAlignment="Center" StrokeThickness="1.5"
Fill="{DynamicResource Brush.TextFaint}" />
<TextBlock Text="{Binding Text}" VerticalAlignment="Center" />
</StackPanel>
</Button>
<DataTemplate.Triggers>
<DataTrigger Binding="{Binding IsAvailable}" Value="True">
<Setter TargetName="Dot" Property="Fill" Value="{DynamicResource Brush.Success}" />
</DataTrigger>
<!-- Unreachable: hollow ring (shape, not colour alone), reason in the tooltip. -->
<DataTrigger Binding="{Binding IsAvailable}" Value="False">
<Setter TargetName="Dot" Property="Fill" Value="Transparent" />
<Setter TargetName="Dot" Property="Stroke" Value="{DynamicResource Brush.Error}" />
</DataTrigger>
</DataTemplate.Triggers>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
<Button Style="{StaticResource Button.Round}" ui:ButtonIcon.Glyph="{StaticResource Icon.Plus}" Command="{Binding AddWatchFolderCommand}"
ToolTip="{l:Loc Tooltips.Uploader.AddWatchFolder}" AutomationProperties.Name="{l:Loc Uploader.Action.AddFolder}" />
</StackPanel>
</Grid>
<!-- Per-file state -->
<Border Grid.Row="5" Margin="0,12,0,0" Style="{StaticResource Border.Panel}" Padding="4"
Visibility="{Binding HasItems, Converter={StaticResource BoolToVisibility}}">
<ListBox x:Name="ItemList" ItemsSource="{Binding Items}" ItemContainerStyle="{StaticResource QueueRow}">
<ListBox.ItemTemplate>
<DataTemplate DataType="{x:Type u:UploadItem}">
<Grid Height="28">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
<ColumnDefinition Width="Auto" MinWidth="120" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<TextBlock Text="{Binding FileName}" Style="{StaticResource Text.Body}" />
<TextBlock Grid.Column="1" Text="{Binding Size, Converter={x:Static s:SizeConverter.Instance}}" Style="{StaticResource Text.Secondary}"
Typography.NumeralAlignment="Tabular" Margin="12,0,0,0" />
<ui:StatusGlyph Grid.Column="2" Margin="16,0,0,0" FontSize="{StaticResource Size.Secondary}" VerticalAlignment="Center"
Kind="{Binding State, Converter={x:Static s:UploadStateKindConverter.Instance}}"
Text="{Binding State, Converter={x:Static s:UploadStateTextConverter.Instance}}">
<ui:StatusGlyph.ToolTip>
<MultiBinding Converter="{x:Static s:FailureTextConverter.Instance}">
<Binding Path="Failure" />
<Binding Path="FailureDetail" />
</MultiBinding>
</ui:StatusGlyph.ToolTip>
</ui:StatusGlyph>
<Button Grid.Column="3" Style="{StaticResource Button.IconSubtle}" Width="26" Height="26" MinWidth="26" Margin="4,0,0,0"
ui:ButtonIcon.Glyph="{StaticResource Icon.Retry}" CommandParameter="{Binding}"
Command="{Binding DataContext.RetryItemCommand, RelativeSource={RelativeSource AncestorType=ListBox}}"
Visibility="{Binding State, Converter={x:Static s:FailedToVisibleConverter.Instance}}"
ToolTip="{l:Loc Tooltips.Uploader.RetryItem}" AutomationProperties.Name="{l:Loc Uploader.Action.Retry}" />
</Grid>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
</Border>
<!-- Options -->
<WrapPanel Grid.Row="6" Margin="0,12,0,0" MinHeight="30">
<CheckBox Content="{l:Loc Uploader.Options.DeleteSource}" IsChecked="{Binding DeleteAfterUpload, Mode=OneWay}" Command="{Binding ToggleDeleteAfterUploadCommand}"
ToolTip="{l:Loc Tooltips.Uploader.DeleteSource}" Margin="0,0,22,0" VerticalAlignment="Center" />
<CheckBox Content="{l:Loc Uploader.Options.StartWithWindows}" IsChecked="{Binding StartWithWindows}" ToolTip="{l:Loc Tooltips.Uploader.StartWithWindows}"
Margin="0,0,22,0" VerticalAlignment="Center" />
<CheckBox Content="{l:Loc Uploader.Options.MinimizeToTray}" IsChecked="{Binding MinimizeToTray}" ToolTip="{l:Loc Tooltips.Uploader.MinimizeToTray}"
VerticalAlignment="Center" />
</WrapPanel>
</Grid>
<!-- Settings panel over the window content. -->
<Grid Grid.RowSpan="2" Visibility="{Binding IsSettingsOpen, Converter={StaticResource BoolToVisibility}}">
<Border Background="{DynamicResource Brush.Scrim}">
<Border.InputBindings>
<MouseBinding MouseAction="LeftClick" Command="{Binding CloseSettingsCommand}" />
</Border.InputBindings>
</Border>
<Border HorizontalAlignment="Right" Width="340" Background="{DynamicResource Brush.Surface}" BorderBrush="{DynamicResource Brush.Stroke}" BorderThickness="1,0,0,0">
<DockPanel Margin="20,12,12,20">
<DockPanel DockPanel.Dock="Top" Margin="0,0,0,12">
<Button DockPanel.Dock="Right" Style="{StaticResource Button.IconSubtle}" ui:ButtonIcon.Glyph="{StaticResource Icon.Close}" Command="{Binding CloseSettingsCommand}"
ToolTip="{l:Loc Tooltips.Uploader.CloseSettings}" AutomationProperties.Name="{l:Loc Uploader.Action.Close}" />
<TextBlock Text="{l:Loc Uploader.Settings.Title}" Style="{StaticResource Text.Title}" />
</DockPanel>
<Grid Margin="0,0,8,0">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" MinWidth="100" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="36" />
<RowDefinition Height="36" />
<RowDefinition Height="Auto" />
<RowDefinition Height="44" />
<RowDefinition Height="36" />
<RowDefinition Height="36" />
<RowDefinition Height="36" />
</Grid.RowDefinitions>
<TextBlock Text="{l:Loc Uploader.Settings.Server}" Style="{StaticResource Text.Label}" MinWidth="0" />
<TextBlock Grid.Column="1" Text="{Binding ServerText}" Style="{StaticResource Text.Body}" />
<TextBlock Grid.Row="1" Text="{l:Loc Uploader.Settings.User}" Style="{StaticResource Text.Label}" MinWidth="0" />
<TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding UserText}" Style="{StaticResource Text.Body}" />
<Button Grid.Row="2" Grid.Column="1" HorizontalAlignment="Left" Margin="0,4,0,8" Content="{l:Loc Uploader.Settings.SignOut}" Command="{Binding SignOutCommand}"
ToolTip="{l:Loc Tooltips.Uploader.SignOut}" Visibility="{Binding IsConnectVisible, Converter={x:Static ui:InverseBoolToVisibilityConverter.Instance}}" />
<TextBlock Grid.Row="3" Text="{l:Loc Uploader.Settings.Bandwidth}" Style="{StaticResource Text.Label}" MinWidth="0" />
<StackPanel Grid.Row="3" Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Center">
<TextBlock Text="{l:Loc Uploader.Limit.Label}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="0,0,6,0" />
<TextBox Width="58" Height="30" Text="{Binding BandwidthLimitText}" TextAlignment="Right" ToolTip="{l:Loc Tooltips.Uploader.Limit}"
AutomationProperties.Name="{l:Loc Uploader.Limit.Label}" />
<TextBlock Text="{l:Loc Uploader.Limit.Unit}" Style="{StaticResource Text.Base}" Foreground="{DynamicResource Brush.TextMuted}" Margin="6,0,0,0" />
</StackPanel>
<TextBlock Grid.Row="4" Text="{l:Loc Uploader.Settings.Startup}" Style="{StaticResource Text.Label}" MinWidth="0" />
<CheckBox Grid.Row="4" Grid.Column="1" Content="{l:Loc Uploader.Options.StartWithWindows}" IsChecked="{Binding StartWithWindows}"
ToolTip="{l:Loc Tooltips.Uploader.StartWithWindows}" VerticalAlignment="Center" />
<CheckBox Grid.Row="5" Grid.Column="1" Content="{l:Loc Uploader.Options.MinimizeToTray}" IsChecked="{Binding MinimizeToTray}"
ToolTip="{l:Loc Tooltips.Uploader.MinimizeToTray}" VerticalAlignment="Center" />
<TextBlock Grid.Row="6" Text="{l:Loc Uploader.Settings.Files}" Style="{StaticResource Text.Label}" MinWidth="0" />
<CheckBox Grid.Row="6" Grid.Column="1" Content="{l:Loc Uploader.Options.DeleteSource}" IsChecked="{Binding DeleteAfterUpload, Mode=OneWay}"
Command="{Binding ToggleDeleteAfterUploadCommand}" ToolTip="{l:Loc Tooltips.Uploader.DeleteSource}" VerticalAlignment="Center" />
</Grid>
</DockPanel>
</Border>
</Grid>
<ui:ToastHost x:Name="Toasts" Grid.RowSpan="2" Margin="0,0,16,16" />
</Grid>
</ui:TitanoWindow>
@@ -0,0 +1,139 @@
using System.Collections.Specialized;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;
using Titano.Ui.Controls;
using Titano.Uploader.Infrastructure;
namespace Titano.Uploader.Shell;
/// <summary>The uploader's single window (mockup Uploader.html).</summary>
public sealed partial class MainWindow : TitanoWindow
{
private readonly MainViewModel _vm;
private readonly UploaderSettings _settings;
public MainWindow(MainViewModel vm, UploaderSettings settings)
{
_vm = vm;
_settings = settings;
DataContext = vm;
InitializeComponent();
vm.PendingToasts.CollectionChanged += OnToastRequested;
vm.PropertyChanged += OnViewModelChanged;
PreviewKeyDown += OnPreviewKeyDown;
RestorePlacement();
}
/// <summary>Remembers size and position (also when the window only hides to the tray).</summary>
public void SavePlacement()
{
var b = RestoreBounds;
if (b.IsEmpty || b.Width < MinWidth || b.Height < MinHeight) return;
_settings.Window = new UploaderSettings.WindowPlacement { Left = b.Left, Top = b.Top, Width = b.Width, Height = b.Height };
}
protected override void OnDragOver(DragEventArgs e)
{
var accepted = CanDrop(e);
e.Effects = accepted ? DragDropEffects.Copy : DragDropEffects.None;
SetDropHighlight(accepted);
e.Handled = true;
}
protected override void OnDragLeave(DragEventArgs e) => SetDropHighlight(false);
protected override void OnDrop(DragEventArgs e)
{
SetDropHighlight(false);
if (!CanDrop(e) || e.Data.GetData(DataFormats.FileDrop) is not string[] paths) return;
e.Handled = true;
_ = EnqueueAsync(paths);
}
private async Task EnqueueAsync(IReadOnlyList<string> paths)
{
try
{
await _vm.EnqueueAsync(paths);
}
catch (Exception ex)
{
// UI boundary: a drop must never take the window down.
_vm.ReportError(ex);
}
}
private bool CanDrop(DragEventArgs e) => !_vm.IsConnectVisible && e.Data.GetDataPresent(DataFormats.FileDrop);
private void SetDropHighlight(bool on)
{
DropBorder.SetResourceReference(Shape.StrokeProperty, on ? "Brush.Accent" : "Brush.Stroke");
if (on) DropBorder.SetResourceReference(Shape.FillProperty, "Brush.AccentSubtle");
else DropBorder.Fill = Brushes.Transparent;
}
private void OnBrowseClick(object sender, RoutedEventArgs e) => OpenMenu((Button)sender);
private void OnWatchChipClick(object sender, RoutedEventArgs e) => OpenMenu((Button)sender);
/// <summary>Opens a button's menu under it on a normal click.</summary>
private static void OpenMenu(Button button)
{
if (button.ContextMenu is not { } menu) return;
menu.DataContext = button.DataContext;
menu.PlacementTarget = button;
menu.Placement = PlacementMode.Bottom;
menu.IsOpen = true;
}
private void OnSequencesDropDownOpened(object? sender, EventArgs e) => _vm.RefreshSequencesCommand.Execute(null);
private void OnPasswordChanged(object sender, RoutedEventArgs e) => _vm.Connect.Password = Password.Password;
/// <summary>DESIGN §4 inputs: Enter commits, Esc reverts; Esc also closes the settings panel.</summary>
private void OnPreviewKeyDown(object sender, KeyEventArgs e)
{
if (e.OriginalSource is TextBox box && (e.Key is Key.Enter or Key.Escape) && box.GetBindingExpression(TextBox.TextProperty) is { } binding)
{
if (e.Key == Key.Enter) binding.UpdateSource();
else binding.UpdateTarget();
if (e.Key == Key.Escape) e.Handled = true;
return;
}
if (e.Key == Key.Escape && _vm.IsSettingsOpen)
{
_vm.IsSettingsOpen = false;
e.Handled = true;
}
}
private void OnViewModelChanged(object? sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == nameof(MainViewModel.CurrentItem) && _vm.CurrentItem is { } item) ItemList.ScrollIntoView(item);
if (e.PropertyName == nameof(MainViewModel.IsConnectVisible) && _vm.IsConnectVisible) Password.Clear();
}
private void OnToastRequested(object? sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action != NotifyCollectionChangedAction.Add || e.NewItems is null) return;
foreach (Toast t in e.NewItems) Toasts.Show(t);
Dispatcher.BeginInvoke(() => _vm.PendingToasts.Clear());
}
private void RestorePlacement()
{
if (_settings.Window is not { } p || p.Width < MinWidth || p.Height < MinHeight) return;
var screen = new Rect(SystemParameters.VirtualScreenLeft, SystemParameters.VirtualScreenTop, SystemParameters.VirtualScreenWidth, SystemParameters.VirtualScreenHeight);
if (!screen.IntersectsWith(new Rect(p.Left, p.Top, p.Width, p.Height))) return;
WindowStartupLocation = WindowStartupLocation.Manual;
Left = p.Left;
Top = p.Top;
Width = p.Width;
Height = p.Height;
}
}
@@ -0,0 +1,79 @@
using System.IO;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Titano.Core.Diagnostics;
using Titano.Ui.Theming;
using Titano.Uploader.DesignTime;
namespace Titano.Uploader.Shell;
/// <summary>
/// <c>Titano.Uploader.exe --capture &lt;dir&gt;</c>: renders the window at 760×560 in the dark and light themes —
/// first run (connect), queue running, settings panel — from <see cref="SampleData"/>, then exits.
/// </summary>
public static class ScreenCapture
{
public static void Run(MainWindow window, MainViewModel vm, SampleData sample, string directory)
{
Directory.CreateDirectory(directory);
window.WindowStartupLocation = WindowStartupLocation.Manual;
window.Left = -20000;
window.Top = -20000;
window.Width = 760;
window.Height = 560;
window.ShowActivated = false;
window.ShowInTaskbar = false;
window.Show();
window.Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, () =>
{
try
{
foreach (var theme in new[] { AppTheme.Dark, AppTheme.Light })
{
var suffix = theme.ToString().ToLowerInvariant();
ThemeManager.Apply(theme);
sample.ShowConnect();
Save(window, Path.Combine(directory, $"uploader-connect-{suffix}.png"));
sample.ShowQueue();
Save(window, Path.Combine(directory, $"uploader-queue-{suffix}.png"));
vm.IsSettingsOpen = true;
Save(window, Path.Combine(directory, $"uploader-settings-{suffix}.png"));
vm.IsSettingsOpen = false;
}
Log.Info("capture", $"Screenshots written to {Path.GetFullPath(directory)}");
}
catch (Exception ex)
{
Log.Error("capture", "Capture failed", ex);
Environment.ExitCode = 1;
}
finally
{
Application.Current.Shutdown();
}
});
}
private static void Save(Window window, string path)
{
// Let bindings, templates and deferred layout complete.
window.UpdateLayout();
window.Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, () => { });
window.UpdateLayout();
if (VisualTreeHelper.GetChildrenCount(window) == 0) return;
var root = (FrameworkElement)VisualTreeHelper.GetChild(window, 0);
var dpi = VisualTreeHelper.GetDpi(window);
var width = (int)Math.Ceiling(root.ActualWidth * dpi.DpiScaleX);
var height = (int)Math.Ceiling(root.ActualHeight * dpi.DpiScaleY);
if (width <= 0 || height <= 0) return;
var bitmap = new RenderTargetBitmap(width, height, dpi.PixelsPerInchX, dpi.PixelsPerInchY, PixelFormats.Pbgra32);
bitmap.Render(root);
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmap));
using var stream = File.Create(path);
encoder.Save(stream);
}
}
@@ -0,0 +1,80 @@
using System.Windows;
using System.Windows.Interop;
using Titano.Core.Imaging;
using Titano.Core.Localization;
using Titano.Uploader.Interop;
namespace Titano.Uploader.Shell;
/// <summary>Pickers and confirmations the view model asks for.</summary>
public interface IUploaderDialogs
{
/// <summary>Photos to add; empty when cancelled.</summary>
IReadOnlyList<string> PickFiles();
/// <summary>A folder or card root to add; null when cancelled.</summary>
string? PickFolder();
/// <summary>A folder to watch; null when cancelled.</summary>
string? PickWatchFolder();
/// <summary>Trust-on-first-use: shows the certificate fingerprint; true when the user trusts it.</summary>
bool ConfirmTrust(string address, string fingerprint);
/// <summary>Destructive confirmation for "Delete after upload"; true when the user turns it on.</summary>
bool ConfirmDeleteAfterUpload();
}
/// <summary>Window-owned implementation: shell Open dialogs and <see cref="ConfirmDialog"/>.</summary>
public sealed class UploaderDialogs : IUploaderDialogs
{
/// <summary>Owner of the dialogs; set once the main window exists.</summary>
public Window? Owner { get; set; }
private IntPtr OwnerHandle => Owner is null ? IntPtr.Zero : new WindowInteropHelper(Owner).Handle;
public IReadOnlyList<string> PickFiles()
{
var photos = string.Join(';', ImageFormatInfo.Known.SelectMany(f => f.Extensions).Select(e => "*." + e));
return FileDialogs.PickFiles(OwnerHandle, Loc.L("Uploader.Browse.FilesTitle"),
[
new FileFilter(Loc.L("Uploader.Browse.Photos"), photos),
new FileFilter(Loc.L("Uploader.Browse.AllFiles"), "*.*"),
]);
}
public string? PickFolder() => FileDialogs.PickFolder(OwnerHandle, Loc.L("Uploader.Browse.FolderTitle"));
public string? PickWatchFolder() => FileDialogs.PickFolder(OwnerHandle, Loc.L("Uploader.Browse.WatchTitle"));
public bool ConfirmTrust(string address, string fingerprint) => ConfirmDialog.Ask(Owner, new ConfirmRequest
{
Heading = Loc.L("Uploader.Trust.Title"),
Message = Loc.L("Uploader.Trust.Message"),
Detail = address + "\n" + FormatFingerprint(fingerprint),
DetailToolTip = Loc.L("Tooltips.Uploader.Fingerprint"),
SafeText = Loc.L("Uploader.Trust.Cancel"),
SafeToolTip = Loc.L("Tooltips.Uploader.CancelTrust"),
ActionText = Loc.L("Uploader.Trust.Accept"),
ActionToolTip = Loc.L("Tooltips.Uploader.Trust"),
IsDestructive = false,
});
public bool ConfirmDeleteAfterUpload() => ConfirmDialog.Ask(Owner, new ConfirmRequest
{
Heading = Loc.L("Uploader.Delete.Title"),
Message = Loc.L("Uploader.Delete.Message"),
SafeText = Loc.L("Uploader.Delete.Keep"),
SafeToolTip = Loc.L("Tooltips.Uploader.KeepFiles"),
ActionText = Loc.L("Uploader.Delete.Accept"),
ActionToolTip = Loc.L("Tooltips.Uploader.ConfirmDelete"),
IsDestructive = true,
});
/// <summary>Splits the 32-byte SHA-256 fingerprint into two readable lines of 16 bytes.</summary>
public static string FormatFingerprint(string fingerprint)
{
var bytes = fingerprint.Split(':');
return bytes.Length <= 16 ? fingerprint : string.Join(':', bytes.Take(16)) + "\n" + string.Join(':', bytes.Skip(16));
}
}
@@ -0,0 +1,78 @@
using System.Windows.Input;
using Titano.Core.Localization;
using Titano.Ui.Mvvm;
using Titano.Uploader.Text;
namespace Titano.Uploader.Shell;
/// <summary>An entry of a watch folder chip's menu: an interval choice, a separator (no text) or "Remove".</summary>
public sealed record WatchMenuOption(string? Text, string? ToolTip, ICommand? Command, bool IsChecked)
{
public bool IsSeparator => Text is null;
}
/// <summary>One watch folder chip: path, interval, reachability.</summary>
public sealed class WatchFolderViewModel : ObservableObject
{
/// <summary>Intervals offered in the chip menu.</summary>
public static readonly int[] IntervalChoices = [30, 60, 300, 900];
private readonly Action<WatchFolderViewModel, int> _setInterval;
private readonly Action<WatchFolderViewModel> _remove;
private int _intervalSeconds;
private bool? _isAvailable;
public WatchFolderViewModel(string path, int intervalSeconds, bool isNetwork, Action<WatchFolderViewModel, int> setInterval, Action<WatchFolderViewModel> remove)
{
Path = path;
IsNetwork = isNetwork;
_intervalSeconds = intervalSeconds;
_setInterval = setInterval;
_remove = remove;
}
public string Path { get; }
public bool IsNetwork { get; }
public int IntervalSeconds
{
get => _intervalSeconds;
set
{
if (!Set(ref _intervalSeconds, value)) return;
OnPropertyChanged(nameof(Text));
OnPropertyChanged(nameof(ToolTip));
OnPropertyChanged(nameof(MenuOptions));
}
}
/// <summary>Null until the first check finished.</summary>
public bool? IsAvailable
{
get => _isAvailable;
set
{
if (Set(ref _isAvailable, value)) OnPropertyChanged(nameof(ToolTip));
}
}
/// <summary>"D:\Cam\Roof · every 1 min".</summary>
public string Text => Loc.L("Uploader.Watch.Chip", Path, Interval(IntervalSeconds));
public string ToolTip => IsAvailable == false ? Loc.L("Tooltips.Uploader.WatchFolderMissing", Interval(IntervalSeconds))
: IsNetwork ? Loc.L("Tooltips.Uploader.WatchFolderNetwork", Interval(IntervalSeconds))
: Loc.L("Tooltips.Uploader.WatchFolder", Interval(IntervalSeconds));
public IReadOnlyList<WatchMenuOption> MenuOptions =>
[
.. IntervalChoices.Select(s => new WatchMenuOption(
Loc.L("Uploader.Watch.Every", Interval(s)),
Loc.L("Tooltips.Uploader.WatchInterval"),
new RelayCommand(() => _setInterval(this, s)),
s == IntervalSeconds)),
new WatchMenuOption(null, null, null, false),
new WatchMenuOption(Loc.L("Uploader.Watch.Remove"), Loc.L("Tooltips.Uploader.RemoveWatchFolder"), new RelayCommand(() => _remove(this)), false),
];
private static string Interval(int seconds) => UploaderText.Duration(TimeSpan.FromSeconds(seconds), Loc.Culture);
}
@@ -0,0 +1,82 @@
using System.IO;
using Titano.Core.Diagnostics;
using Titano.Core.Imaging;
namespace Titano.Uploader.Sources;
/// <summary>A photo found on disk. <see cref="Root"/> is the dropped folder (or the file's folder) it was found under.</summary>
public sealed record SourceFile(string Path, long Size, DateTime ModifiedUtc, DateTime CapturedAt, string Root);
/// <summary>Finds supported photos under dropped files, folders and card roots (BRIEF §15: zero analysis).</summary>
public static class PhotoScanner
{
private static readonly EnumerationOptions Recursive = new()
{
RecurseSubdirectories = true,
IgnoreInaccessible = true,
// Skips "System Volume Information", "$RECYCLE.BIN" and camera housekeeping files.
AttributesToSkip = FileAttributes.Hidden | FileAttributes.System,
MatchType = MatchType.Simple,
};
/// <summary>Supported photos under <paramref name="paths"/>, in path order, without duplicates.</summary>
public static IReadOnlyList<SourceFile> Scan(IEnumerable<string> paths, CancellationToken ct = default)
{
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var result = new List<SourceFile>();
foreach (var raw in paths)
{
ct.ThrowIfCancellationRequested();
string full;
try
{
full = Path.GetFullPath(raw);
}
catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
{
Log.Warning("scan", $"Ignored path {raw}", ex);
continue;
}
if (Directory.Exists(full))
{
try
{
foreach (var file in Files(full, ct))
{
if (seen.Add(file.FullName)) result.Add(ToSource(file, full));
}
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
// A card pulled mid-scan: keep what was found; the rest can be dropped again.
Log.Warning("scan", $"Listing of {full} stopped early", ex);
}
}
else if (File.Exists(full) && ImageFormatInfo.IsSupportedExtension(full) && seen.Add(full))
{
var info = new FileInfo(full);
result.Add(ToSource(info, info.DirectoryName ?? full));
}
}
return result;
}
/// <summary>Supported photos under <paramref name="folder"/>, recursively. I/O errors while listing propagate.</summary>
public static IEnumerable<FileInfo> Files(string folder, CancellationToken ct = default)
{
foreach (var file in new DirectoryInfo(folder).EnumerateFiles("*", Recursive))
{
ct.ThrowIfCancellationRequested();
if (ImageFormatInfo.IsSupportedExtension(file.Name)) yield return file;
}
}
public static SourceFile ToSource(FileInfo file, string root) =>
new(file.FullName, file.Length, file.LastWriteTimeUtc, CaptureTime(file), root);
/// <summary>
/// Capture time read cheaply: the file's last-write time in local wall-clock, which cameras set to the shot time.
/// Exif dates replace it when the metadata reader lands in Titano.Core.
/// </summary>
public static DateTime CaptureTime(FileInfo file) => DateTime.SpecifyKind(file.LastWriteTime, DateTimeKind.Unspecified);
}
@@ -0,0 +1,89 @@
using System.Globalization;
using System.IO;
using System.Security.Cryptography;
using System.Text;
namespace Titano.Uploader.Sources;
/// <summary>The last session of a source, so later files within the gap join it (watch folders).</summary>
public sealed record SessionContinuation(string Key, DateTime LastCapture);
/// <summary>Session key per input frame (input order) and the session the next batch may continue.</summary>
public sealed record SessionAssignment(IReadOnlyList<string> Keys, SessionContinuation? Last);
/// <summary>
/// Splits frames of one source into shooting sessions with the card-import rules (BRIEF §13): a gap longer than
/// <see cref="Gap"/> starts a session; sessions with fewer than <see cref="MinimumFrames"/> frames (test shots) merge
/// into the previous session, or into the next one when they come first. The server turns each key into a sequence.
/// </summary>
public static class SessionGrouper
{
/// <summary><c>SessionGapMinutes</c> default.</summary>
public static readonly TimeSpan Gap = TimeSpan.FromMinutes(45);
/// <summary><c>MinimumSessionFrames</c> default.</summary>
public const int MinimumFrames = 8;
/// <summary>Groups <paramref name="captureTimes"/>; keys start with <paramref name="sourceTag"/> so sources never collide.</summary>
public static SessionAssignment Assign(IReadOnlyList<DateTime> captureTimes, string sourceTag, SessionContinuation? previous = null)
{
if (captureTimes.Count == 0) return new SessionAssignment([], previous);
var order = Enumerable.Range(0, captureTimes.Count).OrderBy(i => captureTimes[i]).ToArray();
// Split on gaps; a group that continues the previous batch keeps its key and is never "small".
var groups = new List<Group>();
var current = new Group { Continues = previous is not null && (captureTimes[order[0]] - previous.LastCapture).Duration() <= Gap };
for (var n = 0; n < order.Length; n++)
{
var i = order[n];
if (n > 0 && captureTimes[i] - captureTimes[order[n - 1]] > Gap)
{
groups.Add(current);
current = new Group();
}
current.Members.Add(i);
}
groups.Add(current);
var merged = new List<Group>();
foreach (var g in groups)
{
if (merged.Count > 0 && g.Members.Count < MinimumFrames) merged[^1].Members.AddRange(g.Members);
else merged.Add(g);
}
if (merged.Count > 1 && merged[0].Members.Count < MinimumFrames && !merged[0].Continues)
{
merged[0].Members.AddRange(merged[1].Members);
merged.RemoveAt(1);
}
var keys = new string[captureTimes.Count];
string? lastKey = null;
foreach (var g in merged)
{
var first = g.Members.Min(i => captureTimes[i]);
lastKey = g.Continues ? previous!.Key : Key(sourceTag, first);
foreach (var i in g.Members) keys[i] = lastKey;
}
var lastCapture = captureTimes[order[^1]];
if (previous is not null && previous.LastCapture > lastCapture && merged[^1].Continues) lastCapture = previous.LastCapture;
return new SessionAssignment(keys, new SessionContinuation(lastKey!, lastCapture));
}
/// <summary>Short stable tag for a source folder: 8 hex digits of the SHA-256 of its normalised path.</summary>
public static string SourceTag(string root)
{
var normalized = Path.TrimEndingDirectorySeparator(Path.GetFullPath(root)).ToUpperInvariant();
return Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(normalized)))[..8];
}
/// <summary><c>{tag}-{yyyyMMdd-HHmmss}</c> of the session's first frame.</summary>
public static string Key(string sourceTag, DateTime firstCapture) =>
sourceTag + "-" + firstCapture.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
private sealed class Group
{
public List<int> Members { get; } = [];
public bool Continues { get; init; }
}
}
+114
View File
@@ -0,0 +1,114 @@
using System.Globalization;
using Titano.Core.Localization;
using Titano.Uploader.Uploads;
namespace Titano.Uploader.Text;
/// <summary>What the queue is doing, for the end of the queue line.</summary>
public enum QueueActivity
{
Idle,
Running,
Paused,
WaitingForServer,
Done,
}
/// <summary>
/// Culture-aware texts of the uploader: sizes, rates, durations and the queue/progress lines
/// ("4,812 files · 96.2 GB · 38 MB/s · 41 min left"). Every method takes the culture so results are deterministic.
/// </summary>
public static class UploaderText
{
private const string Separator = " · ";
private static readonly string[] ByteUnits = ["B", "KB", "MB", "GB", "TB", "PB"];
/// <summary>Localized string for <paramref name="key"/> in <paramref name="culture"/>, formatted with <paramref name="args"/>.</summary>
public static string L(string key, CultureInfo culture, params object?[] args)
{
var format = Loc.Get(key, culture) ?? "⟦" + key + "⟧";
return args.Length == 0 ? format : string.Format(culture, format, args);
}
/// <summary>Plural-aware lookup of <c>key.one/few/many/other</c>; <c>{0}</c> receives the count.</summary>
public static string Plural(string key, long count, CultureInfo culture)
{
var category = PluralRules.Suffix(PluralRules.Select(culture, count));
var format = Loc.Get(key + "." + category, culture) ?? Loc.Get(key + ".other", culture) ?? "⟦" + key + "⟧";
return string.Format(culture, format, count);
}
/// <summary>1,536 → "1.5 KB" (decimal units, as Explorer shows for drives).</summary>
public static string Bytes(long bytes, CultureInfo culture)
{
var (value, unit) = Scale(bytes);
var format = unit == 0 || value >= 100 ? "0" : "0.#";
return value.ToString(format, culture) + " " + ByteUnits[unit];
}
/// <summary>38,400,000 B/s → "38 MB/s"; one decimal below 10 units.</summary>
public static string Rate(double bytesPerSecond, CultureInfo culture)
{
var (value, unit) = Scale(Math.Max(0, bytesPerSecond));
var format = unit == 0 || value >= 10 ? "0" : "0.#";
return L("Uploader.Unit.PerSecond", culture, value.ToString(format, culture) + " " + ByteUnits[unit]);
}
/// <summary>Compact duration: "2 h 05 m", "41 min", "40 s".</summary>
public static string Duration(TimeSpan t, CultureInfo culture)
{
if (t.TotalHours >= 24) return L("Common.Duration.Days", culture, (int)t.TotalDays, t.Hours);
if (t.TotalMinutes >= 59.5) return L("Common.Duration.Hours", culture, (int)Math.Round(t.TotalMinutes) / 60, ((int)Math.Round(t.TotalMinutes) % 60).ToString("00", culture));
if (t.TotalSeconds >= 59.5) return L("Common.Duration.Minutes", culture, (int)Math.Round(t.TotalMinutes));
return L("Common.Duration.Seconds", culture, (int)Math.Round(t.TotalSeconds));
}
/// <summary>"4,812 files · 96.2 GB · 38 MB/s · 41 min left", or the files and size followed by the activity.</summary>
public static string QueueLine(QueueSummary summary, QueueActivity activity, double bytesPerSecond, TimeSpan? left, CultureInfo culture)
{
if (summary.Files == 0) return L("Uploader.Queue.Empty", culture);
var parts = new List<string> { Plural("Uploader.Queue.Files", summary.Files, culture), Bytes(summary.Bytes, culture) };
switch (activity)
{
case QueueActivity.Running:
if (bytesPerSecond > 0) parts.Add(Rate(bytesPerSecond, culture));
if (left is { } l) parts.Add(L("Uploader.Queue.Left", culture, Duration(l, culture)));
break;
case QueueActivity.Paused:
parts.Add(L("Uploader.Queue.Paused", culture));
break;
case QueueActivity.WaitingForServer:
parts.Add(L("Uploader.Queue.Waiting", culture));
break;
case QueueActivity.Done:
parts.Add(L("Uploader.Queue.Done", culture));
break;
}
return string.Join(Separator, parts);
}
/// <summary>"2,214 of 4,812 sent · 2,201 verified by the server · 0 retries", plus failures when there are any.</summary>
public static string ProgressLine(QueueSummary summary, CultureInfo culture)
{
var parts = new List<string>
{
L("Uploader.Progress.Sent", culture, summary.Sent, summary.Files),
L("Uploader.Progress.Verified", culture, summary.Verified),
Plural("Uploader.Progress.Retries", summary.Retries, culture),
};
if (summary.Failed > 0) parts.Add(L("Uploader.Progress.Failed", culture, summary.Failed));
return string.Join(Separator, parts);
}
private static (double Value, int Unit) Scale(double bytes)
{
var value = bytes;
var unit = 0;
while (value >= 999.95 && unit < ByteUnits.Length - 1)
{
value /= 1000;
unit++;
}
return (value, unit);
}
}
@@ -0,0 +1,47 @@
using Titano.Protocol.Client;
namespace Titano.Uploader.Uploads;
/// <summary>How the server answered a successful upload.</summary>
public enum UploadOutcome
{
/// <summary>Committed after the server checked the SHA-256 (<c>CompleteUploadResponse</c>).</summary>
Verified,
/// <summary>The server already held this SHA-256 (<c>AlreadyExists</c>).</summary>
AlreadyOnServer,
}
/// <summary>What the upload needs from the server connection.</summary>
public interface IUploadTransport
{
/// <summary>True while signed in and reachable; the engine waits otherwise.</summary>
bool IsReady { get; }
/// <summary>Raised (on the UI thread) when <see cref="IsReady"/> changes.</summary>
event EventHandler? ReadyChanged;
/// <summary>
/// Sends one file whose hash is known. Throws <see cref="ServerUnavailableException"/> when the server cannot be
/// used right now (offline, signed out, certificate changed); other failures concern this file only.
/// </summary>
Task<(UploadOutcome Outcome, Guid? FrameId)> UploadAsync(UploadItem item, Guid? sequenceId, string sha256, IProgress<UploadProgress> progress, CancellationToken ct);
/// <summary>Creates a sequence for a "new sequence" batch.</summary>
Task<Guid> CreateSequenceAsync(string? title, CancellationToken ct);
}
/// <summary>Why the server cannot be used.</summary>
public enum ServerProblem
{
Unreachable,
SignedOut,
CertificateChanged,
}
/// <summary>The server cannot take uploads right now; the item goes back in line without spending a retry.</summary>
public sealed class ServerUnavailableException(ServerProblem problem, Exception? inner = null)
: Exception("Server unavailable: " + problem, inner)
{
public ServerProblem Problem { get; } = problem;
}
+108
View File
@@ -0,0 +1,108 @@
using System.IO;
using System.Text.Json.Serialization;
using System.Text.Json;
using Titano.Core.Diagnostics;
namespace Titano.Uploader.Uploads;
/// <summary>
/// <c>uploader-queue.json</c>: the queue survives restarts (BRIEF §15). Server-side upload ids are not stored —
/// restarting an item calls <c>POST /uploads</c> again with the same SHA-256 and the server answers with the chunks
/// it already holds.
/// </summary>
public static class QueueStore
{
public const int Version = 1;
/// <summary>Serializes the queue on the calling (owning) thread; the bytes can be written anywhere.</summary>
public static byte[] Serialize(UploadQueue queue)
{
var file = new QueueFile
{
Version = Version,
Paused = queue.IsPaused,
Batches = [.. queue.Batches.Select(b => new BatchRecord(b.Id, b.Mode, b.SequenceId, b.Title))],
Items =
[
.. queue.Items.Select(i => new ItemRecord(
i.Id, i.BatchId, i.Path, i.Size, i.ModifiedUtc, i.CapturedAt, i.SessionKey, i.WatchRoot,
i.IsActive ? UploadItemState.Queued : i.State, i.Failure, i.FailureDetail, i.Retries, i.Sha256, i.FrameId, i.NextRetryUtc)),
],
};
return JsonSerializer.SerializeToUtf8Bytes(file, QueueJson.Default.QueueFile);
}
/// <summary>Loads <paramref name="path"/> into <paramref name="queue"/>; a missing or corrupt file leaves it empty.</summary>
public static void Load(string path, UploadQueue queue)
{
QueueFile? file = null;
try
{
if (File.Exists(path)) file = JsonSerializer.Deserialize(File.ReadAllBytes(path), QueueJson.Default.QueueFile);
}
catch (JsonException ex)
{
Log.Warning("queue", "Queue file unreadable; starting empty", ex);
}
catch (IOException ex)
{
Log.Warning("queue", "Queue file unreadable; starting empty", ex);
}
if (file is null || file.Version != Version) return;
queue.Restore(
file.Batches.Select(b => new UploadBatch { Id = b.Id, Mode = b.Mode, SequenceId = b.SequenceId, Title = b.Title }),
file.Items.Select(r => new UploadItem
{
Id = r.Id,
BatchId = r.BatchId,
Path = r.Path,
Size = r.Size,
ModifiedUtc = r.ModifiedUtc,
CapturedAt = r.CapturedAt,
SessionKey = r.SessionKey,
WatchRoot = r.WatchRoot,
State = r.State,
Failure = r.Failure,
FailureDetail = r.FailureDetail,
Retries = r.Retries,
Sha256 = r.Sha256,
FrameId = r.FrameId,
NextRetryUtc = r.NextRetryUtc,
}),
file.Paused);
}
internal sealed class QueueFile
{
public int Version { get; set; }
public bool Paused { get; set; }
public List<BatchRecord> Batches { get; set; } = [];
public List<ItemRecord> Items { get; set; } = [];
}
internal sealed record BatchRecord(Guid Id, UploadTargetMode Mode, Guid? SequenceId, string? Title);
internal sealed record ItemRecord(
Guid Id,
Guid BatchId,
string Path,
long Size,
DateTime ModifiedUtc,
DateTime? CapturedAt,
string? SessionKey,
string? WatchRoot,
UploadItemState State,
UploadFailure Failure,
string? FailureDetail,
int Retries,
string? Sha256,
Guid? FrameId,
DateTime? NextRetryUtc);
}
[JsonSourceGenerationOptions(
PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
UseStringEnumConverter = true)]
[JsonSerializable(typeof(QueueStore.QueueFile))]
internal sealed partial class QueueJson : JsonSerializerContext;
+115
View File
@@ -0,0 +1,115 @@
namespace Titano.Uploader.Uploads;
/// <summary>Aggregate figures behind the queue line and the progress bar.</summary>
public readonly record struct QueueSummary(
int Files,
long Bytes,
int Sent,
int Verified,
int Failed,
int Retries,
long DoneBytes,
string? CurrentFile)
{
/// <summary>0–1 share of bytes already on the server or in flight.</summary>
public double Progress => Bytes <= 0 ? 0 : Math.Clamp(DoneBytes / (double)Bytes, 0, 1);
/// <summary>Bytes still to send, counting only items that can still succeed.</summary>
public long RemainingBytes { get; init; }
public static QueueSummary From(IEnumerable<UploadItem> items)
{
int files = 0, sent = 0, verified = 0, failed = 0, retries = 0;
long bytes = 0, done = 0, remaining = 0;
UploadItem? current = null;
foreach (var item in items)
{
files++;
bytes += item.Size;
retries += item.Retries;
switch (item.State)
{
case UploadItemState.Verified or UploadItemState.Skipped:
sent++;
verified++;
done += item.Size;
break;
case UploadItemState.Uploading:
if (item.BytesSent >= item.Size) sent++;
done += Math.Min(item.BytesSent, item.Size);
remaining += Math.Max(0, item.Size - item.BytesSent);
current = item;
break;
case UploadItemState.Hashing:
remaining += item.Size;
current ??= item;
break;
case UploadItemState.Failed:
failed++;
if (item.NextRetryUtc is not null) remaining += item.Size;
break;
default:
remaining += item.Size;
break;
}
}
return new QueueSummary(files, bytes, sent, verified, failed, retries, done, current?.FileName) { RemainingBytes = remaining };
}
}
/// <summary>Throughput over a sliding window of cumulative byte counts.</summary>
public sealed class RateMeter(TimeSpan window)
{
private readonly List<(TimeSpan At, long Total)> _samples = [];
private long _total;
public RateMeter()
: this(TimeSpan.FromSeconds(10))
{
}
/// <summary>Adds <paramref name="bytes"/> sent at <paramref name="now"/> (monotonic clock).</summary>
public void Add(long bytes, TimeSpan now)
{
// The first sample is the zero baseline so the first chunk counts.
if (_samples.Count == 0) _samples.Add((now, _total));
_total += bytes;
_samples.Add((now, _total));
Trim(now);
}
/// <summary>Bytes per second over the window; 0 until the window spans at least one second.</summary>
public double BytesPerSecond(TimeSpan now)
{
Trim(now);
if (_samples.Count == 0) return 0;
var (at, total) = _samples[0];
// Measured up to now, so a stalled transfer decays towards zero.
var span = (now - at).TotalSeconds;
return span < 1 ? 0 : (_total - total) / span;
}
public void Reset()
{
_samples.Clear();
_total = 0;
}
/// <summary>Keeps the newest sample at or before <c>now − window</c> as the baseline and drops older ones.</summary>
private void Trim(TimeSpan now)
{
var cutoff = now - window;
var drop = 0;
while (drop + 1 < _samples.Count && _samples[drop + 1].At <= cutoff) drop++;
if (drop > 0) _samples.RemoveRange(0, drop);
}
/// <summary>Time to send <paramref name="remainingBytes"/> at <paramref name="bytesPerSecond"/>; null without a usable rate.</summary>
public static TimeSpan? TimeLeft(long remainingBytes, double bytesPerSecond)
{
if (remainingBytes <= 0) return TimeSpan.Zero;
if (bytesPerSecond < 1024) return null;
var seconds = Math.Ceiling(remainingBytes / bytesPerSecond);
return seconds >= TimeSpan.FromDays(365).TotalSeconds ? null : TimeSpan.FromSeconds(seconds);
}
}
+365
View File
@@ -0,0 +1,365 @@
using System.ComponentModel;
using System.IO;
using Titano.Core.Diagnostics;
using Titano.Protocol.Client;
namespace Titano.Uploader.Uploads;
/// <summary>What the upload engine is doing.</summary>
public enum EngineStatus
{
Idle,
Running,
Paused,
WaitingForServer,
}
/// <summary>Queue control used by the window and the tray.</summary>
public interface IUploadEngine : INotifyPropertyChanged
{
EngineStatus Status { get; }
/// <summary>Current throughput over the last seconds.</summary>
double BytesPerSecond { get; }
/// <summary>Raised when the last pending item finished (balloon on completion).</summary>
event EventHandler? Drained;
/// <summary>Starts work for newly queued items without waiting for the next tick.</summary>
void Pump();
void Pause();
void Resume();
/// <summary>Stops every transfer and clears the queue; files already uploaded stay on the server.</summary>
void StopAndClear();
/// <summary>Puts a failed item back in line with a fresh retry budget.</summary>
void Retry(UploadItem item);
}
/// <summary>
/// Works through the <see cref="UploadQueue"/> with <see cref="Parallelism"/> concurrent files: hash, upload
/// (resumable chunks; the server verifies the SHA-256), then optionally delete the source the server confirmed.
/// Lives on the UI thread: state changes happen there while hashing and HTTP run on the thread pool.
/// </summary>
public sealed class UploadEngine : IUploadEngine, IDisposable
{
public const int Parallelism = 2;
private readonly UploadQueue _queue;
private readonly IUploadTransport _transport;
private readonly Func<bool> _deleteAfterUpload;
private readonly TimeProvider _time;
private readonly long _origin;
private readonly RateMeter _meter = new();
private readonly Dictionary<UploadItem, CancellationTokenSource> _running = [];
private readonly Dictionary<Guid, Task<Guid>> _creating = [];
private readonly CancellationTokenSource _lifetime = new();
private EngineStatus _status;
private double _bytesPerSecond;
private bool _hadWork;
public UploadEngine(UploadQueue queue, IUploadTransport transport, Func<bool> deleteAfterUpload, TimeProvider? time = null)
{
_queue = queue;
_transport = transport;
_deleteAfterUpload = deleteAfterUpload;
_time = time ?? TimeProvider.System;
_origin = _time.GetTimestamp();
_transport.ReadyChanged += (_, _) => Pump();
}
public event PropertyChangedEventHandler? PropertyChanged;
public event EventHandler? Drained;
/// <summary>Raised when the server confirmed an item (verified or already present).</summary>
public event EventHandler<UploadItem>? ItemConfirmed;
public EngineStatus Status
{
get => _status;
private set
{
if (_status == value) return;
_status = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Status)));
}
}
public double BytesPerSecond
{
get => _bytesPerSecond;
private set
{
if (_bytesPerSecond.Equals(value)) return;
_bytesPerSecond = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(BytesPerSecond)));
}
}
private TimeSpan Now => _time.GetElapsedTime(_origin);
private DateTime UtcNow => _time.GetUtcNow().UtcDateTime;
/// <summary>Starts the once-a-second pump on the calling (UI) thread.</summary>
public void Start() => _ = TickAsync(_lifetime.Token);
/// <summary>Starts work for newly queued items without waiting for the next tick.</summary>
public void Pump()
{
if (_lifetime.IsCancellationRequested) return;
while (!_queue.IsPaused && _transport.IsReady && _running.Count < Parallelism)
{
var item = _queue.NextReady(UtcNow);
if (item is null) break;
Begin(item);
}
Refresh();
}
public void Pause()
{
_queue.IsPaused = true;
CancelRunning();
Refresh();
}
public void Resume()
{
_queue.IsPaused = false;
Pump();
}
public void StopAndClear()
{
CancelRunning();
_queue.Clear();
_creating.Clear();
_meter.Reset();
_hadWork = false;
Refresh();
}
public void Retry(UploadItem item)
{
_queue.Requeue(item);
Pump();
}
public void Dispose()
{
_lifetime.Cancel();
CancelRunning();
_lifetime.Dispose();
}
private async Task TickAsync(CancellationToken ct)
{
using var timer = new PeriodicTimer(TimeSpan.FromSeconds(1), _time);
try
{
do
{
Pump();
}
while (await timer.WaitForNextTickAsync(ct));
}
catch (OperationCanceledException)
{
}
}
private void Begin(UploadItem item)
{
if (item.State == UploadItemState.Failed)
{
item.Retries++;
item.NextRetryUtc = null;
item.Failure = UploadFailure.None;
item.FailureDetail = null;
}
// Leaving Queued/Failed synchronously keeps NextReady from handing the item out twice.
item.State = UploadItemState.Hashing;
var cts = CancellationTokenSource.CreateLinkedTokenSource(_lifetime.Token);
_running[item] = cts;
_hadWork = true;
_ = RunAsync(item, cts);
}
private async Task RunAsync(UploadItem item, CancellationTokenSource cts)
{
var ct = cts.Token;
try
{
await HashIfNeededAsync(item, ct);
if (item.State == UploadItemState.Failed) return;
item.State = UploadItemState.Uploading;
item.BytesSent = 0;
var batch = _queue.GetBatch(item.BatchId);
Guid? sequenceId = batch?.Mode switch
{
UploadTargetMode.Sequence => batch.SequenceId,
UploadTargetMode.NewSequence => await EnsureSequenceAsync(batch, ct),
_ => null,
};
var baseline = true;
var progress = new Progress<UploadProgress>(p =>
{
if (item.State != UploadItemState.Uploading) return;
// The first report of a resumed upload counts chunks the server already had: not throughput.
if (!baseline) _meter.Add(Math.Max(0, p.BytesSent - item.BytesSent), Now);
baseline = false;
item.BytesSent = p.BytesSent;
});
var (outcome, frameId) = await _transport.UploadAsync(item, sequenceId, item.Sha256!, progress, ct);
item.FrameId = frameId;
item.BytesSent = item.Size;
item.State = outcome == UploadOutcome.Verified ? UploadItemState.Verified : UploadItemState.Skipped;
_queue.OnChanged();
ItemConfirmed?.Invoke(this, item);
if (_deleteAfterUpload()) DeleteConfirmedSource(item);
}
catch (OperationCanceledException) when (ct.IsCancellationRequested)
{
Requeue(item);
}
catch (ServerUnavailableException ex)
{
Log.Info("upload", $"{item.FileName} waits for the server ({ex.Problem})");
Requeue(item);
}
catch (Exception ex) when (ex is FileNotFoundException or DirectoryNotFoundException)
{
_queue.Fail(item, UploadFailure.FileMissing, null, UtcNow);
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
Log.Warning("upload", $"Cannot read {item.Path}", ex);
_queue.Fail(item, File.Exists(item.Path) ? UploadFailure.FileUnreadable : UploadFailure.FileMissing, null, UtcNow);
}
catch (TitanoApiException ex)
{
Log.Warning("upload", $"Server refused {item.Path}: {ex.Error.Code}", ex);
_queue.Fail(item, UploadFailure.ServerRejected, ex.Error.Message, UtcNow);
}
catch (Exception ex)
{
// Worker boundary: nothing may leave an item stuck in an active state.
Log.Error("upload", $"Upload of {item.Path} failed", ex);
_queue.Fail(item, UploadFailure.Unexpected, null, UtcNow);
}
finally
{
_running.Remove(item);
cts.Dispose();
Pump();
}
}
/// <summary>Hashes when the file is new or changed; a file that changes while being read fails for a later retry.</summary>
private async Task HashIfNeededAsync(UploadItem item, CancellationToken ct)
{
var file = new FileInfo(item.Path);
if (!file.Exists)
{
_queue.Fail(item, UploadFailure.FileMissing, null, UtcNow);
return;
}
if (file.Length != item.Size || file.LastWriteTimeUtc != item.ModifiedUtc)
{
item.Sha256 = null;
item.Size = file.Length;
item.ModifiedUtc = file.LastWriteTimeUtc;
}
if (item.Sha256 is not null) return;
var sha = await Task.Run(() => TitanoClient.HashFileAsync(item.Path, ct), ct);
file.Refresh();
if (!file.Exists || file.Length != item.Size || file.LastWriteTimeUtc != item.ModifiedUtc)
{
_queue.Fail(item, UploadFailure.FileChanged, null, UtcNow);
return;
}
item.Sha256 = sha;
_queue.OnChanged();
}
/// <summary>Creates the batch's sequence once, shared by concurrent items of the same batch.</summary>
private async Task<Guid> EnsureSequenceAsync(UploadBatch batch, CancellationToken ct)
{
if (batch.SequenceId is { } known) return known;
if (!_creating.TryGetValue(batch.Id, out var creation))
{
creation = _transport.CreateSequenceAsync(batch.Title, _lifetime.Token);
_creating[batch.Id] = creation;
}
try
{
var id = await creation.WaitAsync(ct);
batch.SequenceId = id;
_queue.OnChanged();
return id;
}
catch when (creation.IsFaulted || creation.IsCanceled)
{
_creating.Remove(batch.Id);
throw;
}
}
/// <summary>
/// BRIEF §0.2 rule 8: deletes only a file the server confirmed by hash, and only when it is still exactly the
/// bytes that were hashed (same size and write time).
/// </summary>
private static void DeleteConfirmedSource(UploadItem item)
{
try
{
var file = new FileInfo(item.Path);
if (!file.Exists) return;
if (file.Length != item.Size || file.LastWriteTimeUtc != item.ModifiedUtc)
{
Log.Warning("upload", $"Kept {item.Path}: it changed after the server verified it");
return;
}
file.Delete();
Log.Info("upload", $"Deleted {item.Path} after the server confirmed SHA-256 {item.Sha256}");
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
Log.Warning("upload", $"Could not delete {item.Path}", ex);
}
}
private void Requeue(UploadItem item)
{
if (!item.IsActive) return;
item.State = UploadItemState.Queued;
item.BytesSent = 0;
}
private void CancelRunning()
{
foreach (var cts in _running.Values.ToList()) cts.Cancel();
}
private void Refresh()
{
BytesPerSecond = _meter.BytesPerSecond(Now);
var pending = _queue.HasPending;
Status = _queue.IsPaused && pending ? EngineStatus.Paused
: pending && !_transport.IsReady ? EngineStatus.WaitingForServer
: pending || _running.Count > 0 ? EngineStatus.Running
: EngineStatus.Idle;
if (_hadWork && !pending && _running.Count == 0)
{
_hadWork = false;
_meter.Reset();
Drained?.Invoke(this, EventArgs.Empty);
}
}
}
+139
View File
@@ -0,0 +1,139 @@
using System.ComponentModel;
using System.Runtime.CompilerServices;
namespace Titano.Uploader.Uploads;
/// <summary>Per-file state in the upload queue (BRIEF §15).</summary>
public enum UploadItemState
{
Queued,
Hashing,
Uploading,
/// <summary>The server committed the file after checking its SHA-256.</summary>
Verified,
/// <summary>The server already held a file with the same SHA-256.</summary>
Skipped,
Failed,
}
/// <summary>Why an item failed; the UI turns it into one localized sentence.</summary>
public enum UploadFailure
{
None,
FileMissing,
FileUnreadable,
/// <summary>The file changed while it was being hashed (still being written).</summary>
FileChanged,
ServerRejected,
Unexpected,
}
/// <summary>Where a batch of files goes on the server.</summary>
public enum UploadTargetMode
{
/// <summary>The server groups files by <see cref="UploadItem.SessionKey"/> into auto-created sequences.</summary>
Sessions,
/// <summary>Every file goes to one existing sequence.</summary>
Sequence,
/// <summary>One new sequence is created for the batch with the given title.</summary>
NewSequence,
}
/// <summary>Files added together share a target; a new sequence is created once per batch, on first upload.</summary>
public sealed class UploadBatch
{
public required Guid Id { get; init; }
public required UploadTargetMode Mode { get; init; }
/// <summary>Target sequence; for <see cref="UploadTargetMode.NewSequence"/> it is filled once the server created it.</summary>
public Guid? SequenceId { get; set; }
public string? Title { get; init; }
}
/// <summary>One file in the queue. Mutated only on the queue's owning (UI) thread.</summary>
public sealed class UploadItem : INotifyPropertyChanged
{
private UploadItemState _state;
private UploadFailure _failure;
private string? _failureDetail;
private int _retries;
private long _bytesSent;
public required Guid Id { get; init; }
public required Guid BatchId { get; init; }
public required string Path { get; init; }
/// <summary>Size and write time when the file was last hashed or enqueued; a change forces a new hash.</summary>
public required long Size { get; set; }
public required DateTime ModifiedUtc { get; set; }
/// <summary>Camera wall-clock capture time (unspecified kind).</summary>
public DateTime? CapturedAt { get; init; }
public string? SessionKey { get; init; }
/// <summary>Watch folder the file came from; null for files added by hand.</summary>
public string? WatchRoot { get; init; }
public string? Sha256 { get; set; }
public Guid? FrameId { get; set; }
/// <summary>Earliest time a failed item may be retried by the queue.</summary>
public DateTime? NextRetryUtc { get; set; }
public string FileName => System.IO.Path.GetFileName(Path);
public UploadItemState State
{
get => _state;
set => Set(ref _state, value);
}
public UploadFailure Failure
{
get => _failure;
set => Set(ref _failure, value);
}
/// <summary>Server message for <see cref="UploadFailure.ServerRejected"/>, otherwise null.</summary>
public string? FailureDetail
{
get => _failureDetail;
set => Set(ref _failureDetail, value);
}
/// <summary>Queue-level retries already spent on this item.</summary>
public int Retries
{
get => _retries;
set => Set(ref _retries, value);
}
/// <summary>Bytes sent in the current attempt (progress only; not persisted).</summary>
public long BytesSent
{
get => _bytesSent;
set => Set(ref _bytesSent, value);
}
public bool IsDone => _state is UploadItemState.Verified or UploadItemState.Skipped;
public bool IsActive => _state is UploadItemState.Hashing or UploadItemState.Uploading;
public event PropertyChangedEventHandler? PropertyChanged;
private void Set<T>(ref T field, T value, [CallerMemberName] string? name = null)
{
if (EqualityComparer<T>.Default.Equals(field, value)) return;
field = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}
}
+167
View File
@@ -0,0 +1,167 @@
using System.Collections.Concurrent;
using System.Collections.ObjectModel;
namespace Titano.Uploader.Uploads;
/// <summary>A file about to be enqueued.</summary>
public sealed record QueueEntry(string Path, long Size, DateTime ModifiedUtc, DateTime? CapturedAt, string? SessionKey, string? WatchRoot);
/// <summary>
/// Ordered upload queue with its batches. Owned by the UI thread: every mutation happens there, so bindings can
/// observe <see cref="Items"/> directly. <see cref="ContainsPath"/> is the only member safe from other threads.
/// </summary>
public sealed class UploadQueue
{
/// <summary>Queue-level retries per item after the client's own transient retries (BRIEF §15).</summary>
public const int MaxRetries = 3;
/// <summary>Delay before a failed item is tried again.</summary>
public static readonly TimeSpan RetryDelay = TimeSpan.FromSeconds(30);
private readonly Dictionary<Guid, UploadBatch> _batches = [];
private readonly ConcurrentDictionary<string, byte> _paths = new(StringComparer.OrdinalIgnoreCase);
private bool _isPaused;
public ObservableCollection<UploadItem> Items { get; } = [];
public IReadOnlyCollection<UploadBatch> Batches => _batches.Values;
/// <summary>True while the user has paused the queue; persisted so a restart keeps it paused.</summary>
public bool IsPaused
{
get => _isPaused;
set
{
if (_isPaused == value) return;
_isPaused = value;
OnChanged();
}
}
/// <summary>Raised after anything that must be persisted changed.</summary>
public event EventHandler? Changed;
/// <summary>True while an item for <paramref name="path"/> is queued (any state). Thread-safe.</summary>
public bool ContainsPath(string path) => _paths.ContainsKey(path);
/// <summary>True while some item still waits for, or is in, an upload attempt (retryable failures included).</summary>
public bool HasPending => Items.Any(IsPending);
/// <summary>Appends files not already queued, in the given order, under one batch; returns how many were added.</summary>
public int Add(UploadBatch batch, IEnumerable<QueueEntry> entries)
{
var added = 0;
foreach (var e in entries)
{
if (!_paths.TryAdd(e.Path, 0)) continue;
Items.Add(new UploadItem
{
Id = Guid.CreateVersion7(),
BatchId = batch.Id,
Path = e.Path,
Size = e.Size,
ModifiedUtc = e.ModifiedUtc,
CapturedAt = e.CapturedAt,
SessionKey = e.SessionKey,
WatchRoot = e.WatchRoot,
});
added++;
}
if (added > 0)
{
_batches[batch.Id] = batch;
OnChanged();
}
return added;
}
public UploadBatch? GetBatch(Guid id) => _batches.GetValueOrDefault(id);
/// <summary>
/// The next item to work on: the first queued one, otherwise the first failed one whose retry time has come.
/// </summary>
public UploadItem? NextReady(DateTime utcNow)
{
UploadItem? retry = null;
foreach (var item in Items)
{
if (item.State == UploadItemState.Queued) return item;
if (retry is null && IsRetryDue(item, utcNow)) retry = item;
}
return retry;
}
/// <summary>Records a failure and schedules the queue-level retry when retries are left.</summary>
public void Fail(UploadItem item, UploadFailure failure, string? detail, DateTime utcNow)
{
item.State = UploadItemState.Failed;
item.Failure = failure;
item.FailureDetail = detail;
item.BytesSent = 0;
item.NextRetryUtc = item.Retries < MaxRetries ? utcNow + RetryDelay : null;
OnChanged();
}
/// <summary>Puts a failed item back in line now, with a fresh retry budget (user action).</summary>
public void Requeue(UploadItem item)
{
if (item.State != UploadItemState.Failed) return;
item.State = UploadItemState.Queued;
item.Failure = UploadFailure.None;
item.FailureDetail = null;
item.Retries = 0;
item.NextRetryUtc = null;
OnChanged();
}
/// <summary>Drops finished items (verified or skipped) so a new batch starts a fresh count.</summary>
public void RemoveCompleted()
{
var removed = false;
for (var i = Items.Count - 1; i >= 0; i--)
{
if (!Items[i].IsDone) continue;
_paths.TryRemove(Items[i].Path, out _);
Items.RemoveAt(i);
removed = true;
}
if (!removed) return;
var used = Items.Select(i => i.BatchId).ToHashSet();
foreach (var id in _batches.Keys.Where(id => !used.Contains(id)).ToList()) _batches.Remove(id);
OnChanged();
}
public void Clear()
{
Items.Clear();
_paths.Clear();
_batches.Clear();
OnChanged();
}
/// <summary>Signals a persisted-state change made directly on an item.</summary>
public void OnChanged() => Changed?.Invoke(this, EventArgs.Empty);
/// <summary>Restores a persisted queue; interrupted attempts go back to <see cref="UploadItemState.Queued"/>.</summary>
public void Restore(IEnumerable<UploadBatch> batches, IEnumerable<UploadItem> items, bool paused)
{
Items.Clear();
_paths.Clear();
_batches.Clear();
foreach (var b in batches) _batches[b.Id] = b;
foreach (var item in items)
{
if (!_batches.ContainsKey(item.BatchId) || !_paths.TryAdd(item.Path, 0)) continue;
if (item.IsActive) item.State = UploadItemState.Queued;
Items.Add(item);
}
_isPaused = paused;
}
private static bool IsPending(UploadItem item) =>
item.State is UploadItemState.Queued or UploadItemState.Hashing or UploadItemState.Uploading
|| (item.State == UploadItemState.Failed && item.NextRetryUtc is not null);
private static bool IsRetryDue(UploadItem item, DateTime utcNow) =>
item.State == UploadItemState.Failed && item.NextRetryUtc is { } due && due <= utcNow;
}
@@ -0,0 +1,165 @@
using System.IO;
using System.Text.Json.Serialization;
using System.Text.Json;
using Titano.Core.Diagnostics;
using Titano.Uploader.Sources;
namespace Titano.Uploader.Watching;
/// <summary>
/// Files of each watch folder the server already confirmed, keyed by path + size + write time, so a poll never
/// uploads them again; plus the last session of each folder so new frames keep joining it. Thread-safe.
/// Persisted in <c>uploader-watch.json</c>.
/// </summary>
public sealed class ProcessedFileMemory
{
public const int Version = 1;
private readonly Lock _gate = new();
private readonly Dictionary<string, Folder> _folders = new(StringComparer.OrdinalIgnoreCase);
private bool _dirty;
/// <summary>True when something changed since the last <see cref="Serialize"/>.</summary>
public bool IsDirty
{
get
{
lock (_gate) return _dirty;
}
}
public bool Contains(string root, string path, long size, DateTime modifiedUtc)
{
lock (_gate)
{
return _folders.TryGetValue(root, out var f)
&& f.Files.TryGetValue(Relative(root, path), out var known)
&& known.Size == size && known.ModifiedTicks == modifiedUtc.Ticks;
}
}
public void Add(string root, string path, long size, DateTime modifiedUtc)
{
lock (_gate)
{
GetOrAdd(root).Files[Relative(root, path)] = new Entry(size, modifiedUtc.Ticks);
_dirty = true;
}
}
/// <summary>Forgets files of <paramref name="root"/> that a complete scan no longer found.</summary>
public void Prune(string root, IEnumerable<string> presentPaths)
{
lock (_gate)
{
if (!_folders.TryGetValue(root, out var f) || f.Files.Count == 0) return;
var present = new HashSet<string>(presentPaths.Select(p => Relative(root, p)), StringComparer.OrdinalIgnoreCase);
foreach (var key in f.Files.Keys.Where(k => !present.Contains(k)).ToList())
{
f.Files.Remove(key);
_dirty = true;
}
}
}
public void RemoveFolder(string root)
{
lock (_gate)
{
if (_folders.Remove(root)) _dirty = true;
}
}
public SessionContinuation? GetSession(string root)
{
lock (_gate) return _folders.TryGetValue(root, out var f) ? f.Session : null;
}
public void SetSession(string root, SessionContinuation? session)
{
lock (_gate)
{
GetOrAdd(root).Session = session;
_dirty = true;
}
}
public byte[] Serialize()
{
lock (_gate)
{
var file = new MemoryFile
{
Version = Version,
Folders =
[
.. _folders.Select(kv => new FolderRecord(
kv.Key,
kv.Value.Session?.Key,
kv.Value.Session?.LastCapture,
[.. kv.Value.Files.Select(f => new FileRecord(f.Key, f.Value.Size, f.Value.ModifiedTicks))])),
],
};
_dirty = false;
return JsonSerializer.SerializeToUtf8Bytes(file, WatchJson.Default.MemoryFile);
}
}
/// <summary>Loads <paramref name="path"/>; a missing or corrupt file gives an empty memory.</summary>
public static ProcessedFileMemory Load(string path)
{
var memory = new ProcessedFileMemory();
MemoryFile? file = null;
try
{
if (File.Exists(path)) file = JsonSerializer.Deserialize(File.ReadAllBytes(path), WatchJson.Default.MemoryFile);
}
catch (JsonException ex)
{
Log.Warning("watch", "Watch memory unreadable; starting empty", ex);
}
catch (IOException ex)
{
Log.Warning("watch", "Watch memory unreadable; starting empty", ex);
}
if (file is null || file.Version != Version) return memory;
foreach (var record in file.Folders)
{
var folder = memory.GetOrAdd(record.Root);
if (record.SessionKey is not null && record.LastCapture is { } last) folder.Session = new SessionContinuation(record.SessionKey, last);
foreach (var f in record.Files) folder.Files[f.Path] = new Entry(f.Size, f.Modified);
}
return memory;
}
private Folder GetOrAdd(string root)
{
if (!_folders.TryGetValue(root, out var f)) _folders[root] = f = new Folder();
return f;
}
/// <summary>Paths are stored relative to the folder to keep the file small.</summary>
private static string Relative(string root, string path) => Path.GetRelativePath(root, path);
private readonly record struct Entry(long Size, long ModifiedTicks);
private sealed class Folder
{
public Dictionary<string, Entry> Files { get; } = new(StringComparer.OrdinalIgnoreCase);
public SessionContinuation? Session { get; set; }
}
internal sealed class MemoryFile
{
public int Version { get; set; }
public List<FolderRecord> Folders { get; set; } = [];
}
internal sealed record FolderRecord(string Root, string? SessionKey, DateTime? LastCapture, List<FileRecord> Files);
internal sealed record FileRecord(string Path, long Size, long Modified);
}
[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
[JsonSerializable(typeof(ProcessedFileMemory.MemoryFile))]
internal sealed partial class WatchJson : JsonSerializerContext;
@@ -0,0 +1,47 @@
namespace Titano.Uploader.Watching;
/// <summary>Size and last-write time of a file at one check.</summary>
public readonly record struct FileObservation(string Path, long Size, DateTime ModifiedUtc);
/// <summary>
/// Decides when a file in a watch folder has stopped growing: it is reported once its size and write time were
/// identical in <see cref="RequiredChecks"/> consecutive checks, then forgotten (the caller enqueues it).
/// </summary>
public sealed class StableFileTracker
{
public const int RequiredChecks = 2;
private readonly Dictionary<string, (long Size, DateTime Modified, int Count)> _seen = new(StringComparer.OrdinalIgnoreCase);
/// <summary>Files seen but not yet stable.</summary>
public int PendingCount => _seen.Count;
/// <summary>
/// Records a complete scan: returns the files that are now stable and forgets files missing from the scan.
/// </summary>
public IReadOnlyList<FileObservation> Check(IEnumerable<FileObservation> scan)
{
var present = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var stable = new List<FileObservation>();
foreach (var o in scan)
{
present.Add(o.Path);
if (Observe(o)) stable.Add(o);
}
foreach (var path in _seen.Keys.Where(p => !present.Contains(p)).ToList()) _seen.Remove(path);
return stable;
}
/// <summary>Records one observation; true when the file just became stable.</summary>
public bool Observe(FileObservation o)
{
var count = _seen.TryGetValue(o.Path, out var last) && last.Size == o.Size && last.Modified == o.ModifiedUtc ? last.Count + 1 : 1;
if (count >= RequiredChecks)
{
_seen.Remove(o.Path);
return true;
}
_seen[o.Path] = (o.Size, o.ModifiedUtc, count);
return false;
}
}
@@ -0,0 +1,188 @@
using System.IO;
using Titano.Core.Diagnostics;
using Titano.Uploader.Sources;
namespace Titano.Uploader.Watching;
/// <summary>
/// Polls each watch folder at its interval, with <see cref="FileSystemWatcher"/> hints on local disks (change
/// notifications are unreliable on network shares, which are only polled). A photo is reported once it is stable
/// (<see cref="StableFileTracker"/>), not yet confirmed by the server (<see cref="ProcessedFileMemory"/>) and not queued.
/// </summary>
public sealed class WatchFolderService(ProcessedFileMemory memory, Func<string, bool> isQueued) : IDisposable
{
/// <summary>Re-check cadence while some file is still growing.</summary>
private static readonly TimeSpan QuickCheck = TimeSpan.FromSeconds(10);
/// <summary>Lets a burst of change notifications settle before scanning.</summary>
private static readonly TimeSpan HintDebounce = TimeSpan.FromSeconds(2);
private readonly Dictionary<string, Folder> _folders = new(StringComparer.OrdinalIgnoreCase);
private readonly ProcessedFileMemory _memory = memory;
private readonly Func<string, bool> _isQueued = isQueued;
/// <summary>Stable new photos of a folder; raised on the thread that called <see cref="Watch"/>.</summary>
public event Action<string, IReadOnlyList<SourceFile>>? FilesReady;
/// <summary>A folder became reachable (true) or unreachable (false); raised like <see cref="FilesReady"/>.</summary>
public event Action<string, bool>? AvailabilityChanged;
/// <summary>UNC paths and mapped network drives.</summary>
public static bool IsNetworkPath(string path)
{
if (path.StartsWith(@"\\", StringComparison.Ordinal)) return true;
try
{
var root = Path.GetPathRoot(Path.GetFullPath(path));
return !string.IsNullOrEmpty(root) && new DriveInfo(root).DriveType == DriveType.Network;
}
catch (Exception ex) when (ex is ArgumentException or IOException)
{
return false;
}
}
/// <summary>60 s on local disks; 5 min on network shares, where every poll lists the share.</summary>
public static TimeSpan DefaultInterval(string path) => IsNetworkPath(path) ? TimeSpan.FromMinutes(5) : TimeSpan.FromSeconds(60);
/// <summary>Starts (or restarts with a new interval) watching <paramref name="root"/>.</summary>
public void Watch(string root, TimeSpan interval)
{
Stop(root);
var folder = new Folder(root, interval, IsNetworkPath(root), SynchronizationContext.Current, this);
_folders[root] = folder;
folder.Start();
}
public void Stop(string root)
{
if (_folders.Remove(root, out var folder)) folder.Dispose();
}
public void Dispose()
{
foreach (var f in _folders.Values) f.Dispose();
_folders.Clear();
}
private void Raise(SynchronizationContext? context, Action action)
{
if (context is null) action();
else context.Post(_ => action(), null);
}
private sealed class Folder(string root, TimeSpan interval, bool network, SynchronizationContext? context, WatchFolderService owner) : IDisposable
{
private readonly StableFileTracker _tracker = new();
private readonly CancellationTokenSource _cts = new();
private FileSystemWatcher? _watcher;
private TaskCompletionSource _hint = NewHint();
private bool? _available;
public void Start() => _ = Task.Run(() => LoopAsync(_cts.Token));
public void Dispose()
{
_cts.Cancel();
_watcher?.Dispose();
_watcher = null;
}
private async Task LoopAsync(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
// Replaced before the scan so notifications arriving during it trigger the next one.
Volatile.Write(ref _hint, NewHint());
var available = Scan(ct);
if (available != _available)
{
_available = available;
if (available && !network) StartWatcher();
owner.Raise(context, () => owner.AvailabilityChanged?.Invoke(root, available));
}
var wait = _tracker.PendingCount > 0 && QuickCheck < interval ? QuickCheck : interval;
try
{
var hint = Volatile.Read(ref _hint).Task;
if (await Task.WhenAny(Task.Delay(wait, ct), hint).ConfigureAwait(false) == hint)
await Task.Delay(HintDebounce, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
return;
}
}
}
/// <summary>One complete listing; false when the folder cannot be reached.</summary>
private bool Scan(CancellationToken ct)
{
if (!Directory.Exists(root)) return false;
var present = new List<string>();
var candidates = new Dictionary<string, FileInfo>(StringComparer.OrdinalIgnoreCase);
try
{
foreach (var file in PhotoScanner.Files(root, ct))
{
present.Add(file.FullName);
if (IsKnown(file)) continue;
candidates[file.FullName] = file;
}
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
// A partial listing must not prune the memory or report files.
Log.Info("watch", $"{root} not readable: {ex.Message}");
return false;
}
catch (OperationCanceledException)
{
return _available ?? false;
}
owner._memory.Prune(root, present);
var stable = _tracker.Check(candidates.Values.Select(f => new FileObservation(f.FullName, f.Length, f.LastWriteTimeUtc)));
if (stable.Count > 0)
{
var files = stable.Select(o => PhotoScanner.ToSource(candidates[o.Path], root)).ToList();
Log.Info("watch", $"{files.Count} new file(s) in {root}");
owner.Raise(context, () => owner.FilesReady?.Invoke(root, files));
}
return true;
}
/// <summary>Already confirmed by the server, or already in the queue.</summary>
private bool IsKnown(FileInfo file) =>
owner._memory.Contains(root, file.FullName, file.Length, file.LastWriteTimeUtc) || owner._isQueued(file.FullName);
private void StartWatcher()
{
_watcher?.Dispose();
try
{
_watcher = new FileSystemWatcher(root)
{
IncludeSubdirectories = true,
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.Size | NotifyFilters.LastWrite,
};
_watcher.Created += (_, _) => Hint();
_watcher.Changed += (_, _) => Hint();
_watcher.Renamed += (_, _) => Hint();
// A lost buffer means unknown changes: scan.
_watcher.Error += (_, _) => Hint();
_watcher.EnableRaisingEvents = true;
}
catch (Exception ex) when (ex is ArgumentException or IOException or PlatformNotSupportedException)
{
Log.Info("watch", $"No change notifications for {root}; polling only: {ex.Message}");
_watcher?.Dispose();
_watcher = null;
}
}
private void Hint() => Volatile.Read(ref _hint).TrySetResult();
private static TaskCompletionSource NewHint() => new(TaskCreationOptions.RunContinuationsAsynchronously);
}
}
@@ -0,0 +1,18 @@
using System.IO;
using Titano.Testing;
using Titano.Uploader.Infrastructure;
namespace Titano.App.Tests.Uploader;
public sealed class CoalescingWriterTests(TestContext context)
{
[Test]
public void KeepsTheNewestContent()
{
var path = Path.Combine(context.CreateTempDirectory(), "uploader-queue.json");
var writer = new CoalescingWriter();
for (var i = 0; i < 50; i++) writer.Write(path, [(byte)i]);
writer.Flush(TimeSpan.FromSeconds(10));
Assert.SequenceEqual([(byte)49], File.ReadAllBytes(path));
}
}
@@ -0,0 +1,33 @@
using Titano.Testing;
using Titano.Uploader.Infrastructure;
namespace Titano.App.Tests.Uploader;
public sealed class CommandLineTests
{
[Test]
public void PathsAndOptionsAreSeparated()
{
var c = CommandLine.Parse([@"E:\", "--tray", @"D:\Cam\IMG_0001.CR2"]);
Assert.SequenceEqual([@"E:\", @"D:\Cam\IMG_0001.CR2"], c.Paths);
Assert.True(c.StartInTray);
Assert.Null(c.CaptureDirectory);
}
[Test]
public void CaptureTakesAnOptionalDirectory()
{
Assert.Equal("out/shots", CommandLine.Parse(["--capture", "out/shots"]).CaptureDirectory);
Assert.Equal("screenshots", CommandLine.Parse(["--capture"]).CaptureDirectory);
Assert.Equal("screenshots", CommandLine.Parse(["--capture", "--tray"]).CaptureDirectory);
}
[Test]
public void HandOverMessageRoundTrips()
{
string[] args = [@"E:\", @"\\garage-pi\cam\IMG 1.jpg"];
Assert.SequenceEqual(args, SingleInstance.Decode(SingleInstance.Encode(args))!);
Assert.Empty(SingleInstance.Decode(SingleInstance.Encode([]))!);
Assert.Null(SingleInstance.Decode("hello\nE:\\"u8));
}
}
@@ -0,0 +1,83 @@
using System.IO;
using Titano.Testing;
using Titano.Uploader.Sources;
using Titano.Uploader.Watching;
namespace Titano.App.Tests.Uploader;
public sealed class ProcessedFileMemoryTests(TestContext context)
{
private static readonly DateTime Written = new(2026, 9, 28, 16, 2, 11, DateTimeKind.Utc);
[Test]
public void RemembersPathSizeAndWriteTime()
{
var root = Path.Combine(Path.GetTempPath(), "roof");
var photo = Path.Combine(root, "100CANON", "IMG_0413.CR2");
var memory = new ProcessedFileMemory();
Assert.False(memory.Contains(root, photo, 25_000_000, Written));
memory.Add(root, photo, 25_000_000, Written);
Assert.True(memory.IsDirty);
Assert.True(memory.Contains(root, photo, 25_000_000, Written));
Assert.False(memory.Contains(root, photo, 25_000_001, Written), "a resized file is new");
Assert.False(memory.Contains(root, photo, 25_000_000, Written.AddSeconds(1)), "a rewritten file is new");
Assert.False(memory.Contains(Path.Combine(Path.GetTempPath(), "garden"), photo, 25_000_000, Written), "folders are separate");
}
[Test]
public void PruneForgetsFilesNoLongerInTheFolder()
{
var root = Path.Combine(Path.GetTempPath(), "roof");
var kept = Path.Combine(root, "a.jpg");
var gone = Path.Combine(root, "b.jpg");
var memory = new ProcessedFileMemory();
memory.Add(root, kept, 1, Written);
memory.Add(root, gone, 2, Written);
memory.Prune(root, [kept]);
Assert.True(memory.Contains(root, kept, 1, Written));
Assert.False(memory.Contains(root, gone, 2, Written));
}
[Test]
public void RoundTripKeepsFilesAndTheLastSession()
{
var dir = context.CreateTempDirectory();
var root = Path.Combine(dir, "cam");
var photo = Path.Combine(root, "IMG_0001.JPG");
var memory = new ProcessedFileMemory();
memory.Add(root, photo, 4_200_000, Written);
memory.SetSession(root, new SessionContinuation("1a2b3c4d-20260928-180000", new DateTime(2026, 9, 28, 18, 40, 0)));
var path = Path.Combine(dir, "uploader-watch.json");
File.WriteAllBytes(path, memory.Serialize());
Assert.False(memory.IsDirty);
var restored = ProcessedFileMemory.Load(path);
Assert.True(restored.Contains(root, photo, 4_200_000, Written));
Assert.Equal(new SessionContinuation("1a2b3c4d-20260928-180000", new DateTime(2026, 9, 28, 18, 40, 0)), restored.GetSession(root));
Assert.False(restored.IsDirty);
}
[Test]
public void RemovedFolderIsForgotten()
{
var root = Path.Combine(Path.GetTempPath(), "roof");
var memory = new ProcessedFileMemory();
memory.Add(root, Path.Combine(root, "a.jpg"), 1, Written);
memory.SetSession(root, new SessionContinuation("k", Written));
memory.RemoveFolder(root);
Assert.False(memory.Contains(root, Path.Combine(root, "a.jpg"), 1, Written));
Assert.Null(memory.GetSession(root));
}
[Test]
public void CorruptFileGivesAnEmptyMemory()
{
var path = Path.Combine(context.CreateTempDirectory(), "uploader-watch.json");
File.WriteAllText(path, "[1,2");
var memory = ProcessedFileMemory.Load(path);
Assert.False(memory.Contains("x", "x/a.jpg", 1, Written));
}
}
@@ -0,0 +1,25 @@
using Titano.Testing;
using Titano.Uploader.Server;
namespace Titano.App.Tests.Uploader;
public sealed class ServerAddressTests
{
[Theory]
[Case("nas.local:8443", "https://nas.local:8443/")]
[Case("https://nas.local:8443", "https://nas.local:8443/")]
[Case(" http://192.168.1.20:8080/titano ", "http://192.168.1.20:8080/titano/")]
[Case("https://nas.local/?x=1#y", "https://nas.local/")]
public void ServerAddressesBecomeApiBases(string typed, string expected)
{
Assert.True(ServerAddress.TryParse(typed, out var uri));
Assert.Equal(expected, uri.ToString());
}
[Theory]
[Case("")]
[Case(" ")]
[Case("ftp://nas.local")]
[Case("https://")]
public void InvalidServerAddressesAreRejected(string typed) => Assert.False(ServerAddress.TryParse(typed, out _));
}
@@ -0,0 +1,99 @@
using System.IO;
using Titano.Testing;
using Titano.Uploader.Sources;
namespace Titano.App.Tests.Uploader;
public sealed class SessionGrouperTests
{
private static readonly DateTime Evening = new(2026, 9, 28, 18, 0, 0);
[Test]
public void SplitsWhereTheGapExceedsFortyFiveMinutes()
{
var times = Series(Evening, 10).Concat(Series(Evening.AddMinutes(9 + 46), 10)).ToList();
var result = SessionGrouper.Assign(times, "abcd1234");
Assert.Equal(2, result.Keys.Distinct().Count());
Assert.Equal("abcd1234-20260928-180000", result.Keys[0]);
Assert.Equal("abcd1234-20260928-185500", result.Keys[^1]);
}
[Test]
public void GapOfExactlyFortyFiveMinutesStaysInOneSession()
{
var times = Series(Evening, 10).Concat(Series(Evening.AddMinutes(9 + 45), 10)).ToList();
Assert.Equal(1, SessionGrouper.Assign(times, "t").Keys.Distinct().Count());
}
[Test]
public void TestShotsAfterASessionMergeIntoIt()
{
var times = Series(Evening, 20).Concat(Series(Evening.AddHours(3), 3)).ToList();
var result = SessionGrouper.Assign(times, "t");
Assert.Equal(1, result.Keys.Distinct().Count());
Assert.Equal(Evening.AddHours(3).AddMinutes(2), result.Last!.LastCapture);
}
[Test]
public void LeadingTestShotsJoinTheFollowingSession()
{
var times = Series(Evening, 3).Concat(Series(Evening.AddHours(2), 30)).ToList();
var result = SessionGrouper.Assign(times, "t");
Assert.Equal(1, result.Keys.Distinct().Count());
Assert.Equal("t-20260928-180000", result.Keys[0]);
}
[Test]
public void KeysFollowTheInputOrder()
{
var first = Series(Evening, 10);
var second = Series(Evening.AddHours(5), 10);
var shuffled = new List<DateTime> { second[3], first[7], second[0], first[0] };
shuffled.AddRange(first.Skip(1).Take(6));
shuffled.AddRange(second.Skip(4));
var result = SessionGrouper.Assign(shuffled, "t");
Assert.Equal("t-20260928-230000", result.Keys[0]);
Assert.Equal("t-20260928-180000", result.Keys[1]);
Assert.Equal(result.Keys[0], result.Keys[2]);
Assert.Equal(result.Keys[1], result.Keys[3]);
}
[Test]
public void NewFramesWithinTheGapContinueThePreviousSession()
{
var previous = new SessionContinuation("t-20260928-180000", Evening.AddMinutes(30));
var result = SessionGrouper.Assign(Series(Evening.AddMinutes(40), 2), "t", previous);
Assert.SequenceEqual(["t-20260928-180000", "t-20260928-180000"], result.Keys);
Assert.Equal(Evening.AddMinutes(41), result.Last!.LastCapture);
}
[Test]
public void NewFramesAfterTheGapStartANewSession()
{
var previous = new SessionContinuation("t-20260928-180000", Evening.AddMinutes(30));
var result = SessionGrouper.Assign(Series(Evening.AddHours(2), 10), "t", previous);
Assert.Equal("t-20260928-200000", result.Keys[0]);
Assert.Equal("t-20260928-200000", result.Last!.Key);
}
[Test]
public void EmptyInputKeepsThePreviousSession()
{
var previous = new SessionContinuation("k", Evening);
var result = SessionGrouper.Assign([], "t", previous);
Assert.Empty(result.Keys);
Assert.Same(previous, result.Last);
}
[Test]
public void SourceTagIsStableShortAndPerFolder()
{
var a = SessionGrouper.SourceTag(Path.Combine(Path.GetTempPath(), "cam", "roof"));
Assert.Equal(8, a.Length);
Assert.True(a.All(Uri.IsHexDigit));
Assert.Equal(a, SessionGrouper.SourceTag(Path.Combine(Path.GetTempPath(), "cam", "roof") + Path.DirectorySeparatorChar));
Assert.NotEqual(a, SessionGrouper.SourceTag(Path.Combine(Path.GetTempPath(), "cam", "garden")));
}
private static List<DateTime> Series(DateTime start, int count) => [.. Enumerable.Range(0, count).Select(i => start.AddMinutes(i))];
}
@@ -0,0 +1,41 @@
using System.Collections.Concurrent;
namespace Titano.App.Tests.Uploader;
/// <summary>Runs async test code on one thread, as the UI dispatcher does for the upload engine.</summary>
internal sealed class SingleThreadedContext : SynchronizationContext
{
private readonly BlockingCollection<(SendOrPostCallback Callback, object? State)> _queue = [];
public override void Post(SendOrPostCallback d, object? state)
{
try
{
_queue.Add((d, state));
}
catch (InvalidOperationException)
{
// Late progress reports after the test body finished are dropped.
}
}
public override void Send(SendOrPostCallback d, object? state) => throw new NotSupportedException();
public static void Run(Func<Task> body)
{
var previous = Current;
var context = new SingleThreadedContext();
SetSynchronizationContext(context);
try
{
var task = body();
task.ContinueWith(_ => context._queue.CompleteAdding(), TaskScheduler.Default);
foreach (var (callback, state) in context._queue.GetConsumingEnumerable()) callback(state);
task.GetAwaiter().GetResult();
}
finally
{
SetSynchronizationContext(previous);
}
}
}
@@ -0,0 +1,71 @@
using Titano.Testing;
using Titano.Uploader.Watching;
namespace Titano.App.Tests.Uploader;
public sealed class StableFileTrackerTests
{
private static readonly DateTime T0 = new(2026, 9, 28, 16, 0, 0, DateTimeKind.Utc);
[Test]
public void FileIsStableAfterTwoIdenticalChecks()
{
var tracker = new StableFileTracker();
var photo = new FileObservation("a.cr2", 25_000_000, T0);
Assert.Empty(tracker.Check([photo]));
Assert.Equal(1, tracker.PendingCount);
Assert.SequenceEqual([photo], tracker.Check([photo]));
Assert.Equal(0, tracker.PendingCount);
}
[Test]
public void GrowingFileWaitsUntilItStopsGrowing()
{
var tracker = new StableFileTracker();
Assert.Empty(tracker.Check([new("a.cr2", 1_000, T0)]));
Assert.Empty(tracker.Check([new("a.cr2", 9_000, T0.AddSeconds(1))]));
Assert.Empty(tracker.Check([new("a.cr2", 25_000, T0.AddSeconds(2))]));
Assert.Count(1, tracker.Check([new("a.cr2", 25_000, T0.AddSeconds(2))]));
}
[Test]
public void TouchedFileWithSameSizeRestartsTheCount()
{
var tracker = new StableFileTracker();
Assert.Empty(tracker.Check([new("a.jpg", 500, T0)]));
Assert.Empty(tracker.Check([new("a.jpg", 500, T0.AddSeconds(5))]));
Assert.Count(1, tracker.Check([new("a.jpg", 500, T0.AddSeconds(5))]));
}
[Test]
public void FileMissingFromAScanIsForgotten()
{
var tracker = new StableFileTracker();
var photo = new FileObservation("a.jpg", 500, T0);
Assert.Empty(tracker.Check([photo]));
Assert.Empty(tracker.Check([]));
Assert.Empty(tracker.Check([photo]));
Assert.Count(1, tracker.Check([photo]));
}
[Test]
public void FilesProgressIndependently()
{
var tracker = new StableFileTracker();
var done = new FileObservation("done.jpg", 500, T0);
Assert.Empty(tracker.Check([done, new("growing.jpg", 10, T0)]));
var stable = tracker.Check([done, new("growing.jpg", 20, T0.AddSeconds(1))]);
Assert.SequenceEqual([done], stable);
Assert.Equal(1, tracker.PendingCount);
}
[Test]
public void SingleObservationsUseTheSameRule()
{
var tracker = new StableFileTracker();
var photo = new FileObservation("a.nef", 42, T0);
Assert.False(tracker.Observe(photo));
Assert.True(tracker.Observe(photo));
Assert.False(tracker.Observe(photo));
}
}
@@ -0,0 +1,27 @@
using Titano.Testing;
using Titano.Uploader.Infrastructure;
namespace Titano.App.Tests.Uploader;
public sealed class TokenProtectorTests
{
[Test]
[WindowsOnly]
public void TokenRoundTripsThroughDpapiWithoutPlainText()
{
const string token = "ttn_4f9a1c2e7b";
var blob = TokenProtector.Protect(token);
Assert.False(blob.Contains(token, StringComparison.Ordinal));
Assert.Equal(token, TokenProtector.Unprotect(blob));
}
[Test]
[WindowsOnly]
public void DamagedBlobsGiveNoToken()
{
var blob = Convert.FromBase64String(TokenProtector.Protect("secret"));
blob[^1] ^= 0xFF;
Assert.Null(TokenProtector.Unprotect(Convert.ToBase64String(blob)));
Assert.Null(TokenProtector.Unprotect("not base64!"));
}
}
@@ -0,0 +1,224 @@
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Security.Cryptography;
using Titano.Protocol;
using Titano.Protocol.Client;
using Titano.Testing;
using Titano.Uploader.Uploads;
namespace Titano.App.Tests.Uploader;
public sealed class UploadEngineTests(TestContext context)
{
private readonly ManualTime _time = new();
[Test]
public void VerifiedUploadsKeepTheSourceByDefault() => SingleThreadedContext.Run(async () =>
{
var queue = Queue(UploadTargetMode.Sessions, 2);
var transport = new FakeTransport();
using var engine = new UploadEngine(queue, transport, () => false, _time);
var confirmed = new List<UploadItem>();
engine.ItemConfirmed += (_, item) => confirmed.Add(item);
engine.Pump();
await Until(() => queue.Items.All(i => i.IsDone));
Assert.True(queue.Items.All(i => i.State == UploadItemState.Verified && i.FrameId is not null));
Assert.True(queue.Items.All(i => File.Exists(i.Path)));
// Two workers hash in parallel, so calls arrive in either order.
foreach (var item in queue.Items) Assert.Equal(Sha256(item.Path), transport.Calls.Single(c => c.Path == item.Path).Sha256);
Assert.Equal(2, confirmed.Count);
});
[Test]
public void DeleteAfterUploadRemovesOnlyConfirmedUnchangedFiles() => SingleThreadedContext.Run(async () =>
{
var queue = Queue(UploadTargetMode.Sessions, 3);
var (verified, existing, changed) = (queue.Items[0], queue.Items[1], queue.Items[2]);
var transport = new FakeTransport
{
Respond = item =>
{
if (item == existing) return (UploadOutcome.AlreadyOnServer, null);
// Written to after it was hashed: the bytes on disk are no longer the verified ones.
if (item == changed) File.AppendAllText(item.Path, "more");
return (UploadOutcome.Verified, Guid.CreateVersion7());
},
};
using var engine = new UploadEngine(queue, transport, () => true, _time);
engine.Pump();
await Until(() => queue.Items.All(i => i.IsDone));
Assert.Equal(UploadItemState.Skipped, existing.State);
Assert.False(File.Exists(verified.Path));
Assert.False(File.Exists(existing.Path));
Assert.True(File.Exists(changed.Path), "a file changed after verification is kept");
});
[Test]
public void RejectedFileIsRetriedAfterThirtySeconds() => SingleThreadedContext.Run(async () =>
{
var queue = Queue(UploadTargetMode.Sessions, 1);
var item = queue.Items[0];
var attempts = 0;
var transport = new FakeTransport
{
Respond = _ => ++attempts == 1
? throw new TitanoApiException(HttpStatusCode.UnprocessableEntity, new ApiError("hash_mismatch", "Hash mismatch"))
: (UploadOutcome.Verified, Guid.CreateVersion7()),
};
using var engine = new UploadEngine(queue, transport, () => false, _time);
engine.Pump();
await Until(() => item.State == UploadItemState.Failed);
Assert.Equal(UploadFailure.ServerRejected, item.Failure);
Assert.Equal("Hash mismatch", item.FailureDetail);
Assert.Equal(_time.UtcNow + UploadQueue.RetryDelay, item.NextRetryUtc);
_time.Advance(TimeSpan.FromSeconds(29));
engine.Pump();
Assert.Equal(UploadItemState.Failed, item.State);
_time.Advance(TimeSpan.FromSeconds(1));
engine.Pump();
await Until(() => item.IsDone);
Assert.Equal(1, item.Retries);
Assert.Equal(UploadFailure.None, item.Failure);
});
[Test]
public void UnreachableServerRequeuesWithoutSpendingARetry() => SingleThreadedContext.Run(async () =>
{
var queue = Queue(UploadTargetMode.Sessions, 1);
var item = queue.Items[0];
var transport = new FakeTransport();
transport.Respond = _ =>
{
transport.SetReady(false);
throw new ServerUnavailableException(ServerProblem.Unreachable);
};
using var engine = new UploadEngine(queue, transport, () => false, _time);
engine.Pump();
await Until(() => item.State == UploadItemState.Queued && transport.Calls.Count == 1);
Assert.Equal(0, item.Retries);
Assert.NotNull(item.Sha256);
Assert.Equal(EngineStatus.WaitingForServer, engine.Status);
transport.Respond = _ => (UploadOutcome.Verified, Guid.CreateVersion7());
transport.SetReady(true);
await Until(() => item.IsDone);
});
[Test]
public void NewSequenceIsCreatedOnceForTheBatch() => SingleThreadedContext.Run(async () =>
{
var queue = Queue(UploadTargetMode.NewSequence, 3);
var transport = new FakeTransport();
using var engine = new UploadEngine(queue, transport, () => false, _time);
engine.Pump();
await Until(() => queue.Items.All(i => i.IsDone));
Assert.Equal(1, transport.SequencesCreated);
Assert.True(transport.Calls.All(c => c.SequenceId == FakeTransport.CreatedSequence));
Assert.Equal(FakeTransport.CreatedSequence, queue.Batches.Single().SequenceId);
});
[Test]
public void AtMostTwoFilesAreInFlightAndPauseRequeuesThem() => SingleThreadedContext.Run(async () =>
{
var queue = Queue(UploadTargetMode.Sessions, 4);
var transport = new FakeTransport { Block = true };
using var engine = new UploadEngine(queue, transport, () => false, _time);
engine.Pump();
await Until(() => queue.Items.Count(i => i.State == UploadItemState.Uploading) == UploadEngine.Parallelism);
Assert.Equal(UploadEngine.Parallelism, queue.Items.Count(i => i.IsActive));
engine.Pause();
await Until(() => queue.Items.All(i => i.State == UploadItemState.Queued));
Assert.Equal(EngineStatus.Paused, engine.Status);
transport.Block = false;
engine.Resume();
await Until(() => queue.Items.All(i => i.IsDone));
Assert.False(queue.IsPaused);
});
private UploadQueue Queue(UploadTargetMode mode, int count)
{
var dir = context.CreateTempDirectory();
var queue = new UploadQueue();
var entries = Enumerable.Range(0, count).Select(i =>
{
var path = Path.Combine(dir, $"IMG_{i:0000}.JPG");
File.WriteAllBytes(path, RandomNumberGenerator.GetBytes(4096 + i));
var info = new FileInfo(path);
return new QueueEntry(path, info.Length, info.LastWriteTimeUtc, info.LastWriteTime, "k", null);
}).ToList();
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = mode, Title = mode == UploadTargetMode.NewSequence ? "Roof" : null }, entries);
return queue;
}
private static string Sha256(string path) => Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(path)));
private static async Task Until(Func<bool> condition)
{
var clock = Stopwatch.StartNew();
while (!condition())
{
if (clock.Elapsed > TimeSpan.FromSeconds(15)) throw new TimeoutException("Condition not reached");
await Task.Delay(5);
}
}
private sealed class ManualTime : TimeProvider
{
private DateTimeOffset _now = new(2026, 9, 28, 18, 0, 0, TimeSpan.Zero);
public DateTime UtcNow => _now.UtcDateTime;
public void Advance(TimeSpan by) => _now += by;
public override DateTimeOffset GetUtcNow() => _now;
}
private sealed class FakeTransport : IUploadTransport
{
public static readonly Guid CreatedSequence = Guid.CreateVersion7();
public event EventHandler? ReadyChanged;
public bool IsReady { get; private set; } = true;
public bool Block { get; set; }
public int SequencesCreated { get; private set; }
public List<(string Path, Guid? SequenceId, string Sha256)> Calls { get; } = [];
public Func<UploadItem, (UploadOutcome, Guid?)> Respond { get; set; } = _ => (UploadOutcome.Verified, Guid.CreateVersion7());
public void SetReady(bool ready)
{
IsReady = ready;
ReadyChanged?.Invoke(this, EventArgs.Empty);
}
public async Task<(UploadOutcome Outcome, Guid? FrameId)> UploadAsync(UploadItem item, Guid? sequenceId, string sha256, IProgress<UploadProgress> progress, CancellationToken ct)
{
Calls.Add((item.Path, sequenceId, sha256));
progress.Report(new UploadProgress(0, item.Size));
while (Block) await Task.Delay(5, ct);
await Task.Yield();
progress.Report(new UploadProgress(item.Size, item.Size));
return Respond(item);
}
public Task<Guid> CreateSequenceAsync(string? title, CancellationToken ct)
{
SequencesCreated++;
return Task.FromResult(CreatedSequence);
}
}
}
@@ -0,0 +1,143 @@
using System.IO;
using Titano.Testing;
using Titano.Uploader.Uploads;
namespace Titano.App.Tests.Uploader;
public sealed class UploadQueueTests(TestContext context)
{
private static readonly DateTime Now = new(2026, 9, 28, 18, 30, 0, DateTimeKind.Utc);
[Test]
public void PersistenceRoundTripKeepsBatchesItemsAndStates()
{
var queue = new UploadQueue();
var sessions = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
var created = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.NewSequence, Title = "Harbour sunset", SequenceId = Guid.CreateVersion7() };
queue.Add(sessions, [Entry("a.cr2", "k1", @"D:\Cam\Roof"), Entry("b.cr2", "k1", null)]);
queue.Add(created, [Entry("c.jpg", null, null)]);
var verified = queue.Items[0];
verified.State = UploadItemState.Verified;
verified.Sha256 = new string('a', 64);
verified.FrameId = Guid.CreateVersion7();
var failed = queue.Items[1];
failed.Retries = 2;
queue.Fail(failed, UploadFailure.ServerRejected, "quota exceeded", Now);
queue.IsPaused = true;
var path = Path.Combine(context.CreateTempDirectory(), "uploader-queue.json");
File.WriteAllBytes(path, QueueStore.Serialize(queue));
var restored = new UploadQueue();
QueueStore.Load(path, restored);
Assert.True(restored.IsPaused);
Assert.Equal(2, restored.Batches.Count);
Assert.Equal("Harbour sunset", restored.GetBatch(created.Id)!.Title);
Assert.Equal(created.SequenceId, restored.GetBatch(created.Id)!.SequenceId);
Assert.Equal(3, restored.Items.Count);
for (var i = 0; i < 3; i++)
{
var (a, b) = (queue.Items[i], restored.Items[i]);
Assert.Equal(a.Id, b.Id);
Assert.Equal(a.BatchId, b.BatchId);
Assert.Equal(a.Path, b.Path);
Assert.Equal(a.Size, b.Size);
Assert.Equal(a.ModifiedUtc, b.ModifiedUtc);
Assert.Equal(a.CapturedAt, b.CapturedAt);
Assert.Equal(a.SessionKey, b.SessionKey);
Assert.Equal(a.WatchRoot, b.WatchRoot);
Assert.Equal(a.State, b.State);
}
Assert.Equal(verified.Sha256, restored.Items[0].Sha256);
Assert.Equal(verified.FrameId, restored.Items[0].FrameId);
Assert.Equal(UploadFailure.ServerRejected, restored.Items[1].Failure);
Assert.Equal("quota exceeded", restored.Items[1].FailureDetail);
Assert.Equal(2, restored.Items[1].Retries);
Assert.Equal(Now + UploadQueue.RetryDelay, restored.Items[1].NextRetryUtc);
Assert.True(restored.ContainsPath("c.jpg"));
}
[Test]
public void InterruptedTransfersResumeAsQueued()
{
var queue = new UploadQueue();
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions }, [Entry("a.cr2", null, null), Entry("b.cr2", null, null)]);
queue.Items[0].State = UploadItemState.Uploading;
queue.Items[0].Sha256 = new string('b', 64);
queue.Items[1].State = UploadItemState.Hashing;
var path = Path.Combine(context.CreateTempDirectory(), "q.json");
File.WriteAllBytes(path, QueueStore.Serialize(queue));
var restored = new UploadQueue();
QueueStore.Load(path, restored);
Assert.Equal(UploadItemState.Queued, restored.Items[0].State);
Assert.Equal(UploadItemState.Queued, restored.Items[1].State);
// The known hash is kept: the server resumes from the chunks it already holds.
Assert.Equal(new string('b', 64), restored.Items[0].Sha256);
}
[Test]
public void CorruptOrMissingFileGivesAnEmptyQueue()
{
var dir = context.CreateTempDirectory();
var corrupt = Path.Combine(dir, "q.json");
File.WriteAllText(corrupt, "{ not json");
var queue = new UploadQueue();
QueueStore.Load(corrupt, queue);
QueueStore.Load(Path.Combine(dir, "missing.json"), queue);
Assert.Empty(queue.Items);
Assert.False(queue.IsPaused);
}
[Test]
public void AddingSkipsPathsAlreadyQueued()
{
var queue = new UploadQueue();
var batch = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
Assert.Equal(2, queue.Add(batch, [Entry("a.jpg", null, null), Entry("b.jpg", null, null)]));
Assert.Equal(1, queue.Add(batch, [Entry("b.jpg", null, null), Entry("c.jpg", null, null)]));
Assert.Equal(3, queue.Items.Count);
}
[Test]
public void FailedItemsComeBackAfterTheDelayUntilRetriesRunOut()
{
var queue = new UploadQueue();
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions }, [Entry("a.jpg", null, null)]);
var item = queue.Items[0];
item.State = UploadItemState.Hashing;
queue.Fail(item, UploadFailure.FileUnreadable, null, Now);
Assert.Null(queue.NextReady(Now.AddSeconds(29)));
Assert.Same(item, queue.NextReady(Now + UploadQueue.RetryDelay));
Assert.True(queue.HasPending);
item.Retries = UploadQueue.MaxRetries;
queue.Fail(item, UploadFailure.FileUnreadable, null, Now);
Assert.Null(item.NextRetryUtc);
Assert.Null(queue.NextReady(Now.AddDays(1)));
Assert.False(queue.HasPending);
queue.Requeue(item);
Assert.Equal(0, item.Retries);
Assert.Same(item, queue.NextReady(Now));
}
[Test]
public void RemovingCompletedItemsKeepsTheRest()
{
var queue = new UploadQueue();
var batch = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions };
queue.Add(batch, [Entry("a.jpg", null, null), Entry("b.jpg", null, null), Entry("c.jpg", null, null)]);
queue.Items[0].State = UploadItemState.Verified;
queue.Items[2].State = UploadItemState.Skipped;
queue.RemoveCompleted();
Assert.Equal(1, queue.Items.Count);
Assert.False(queue.ContainsPath("a.jpg"));
Assert.True(queue.ContainsPath("b.jpg"));
Assert.Equal(1, queue.Batches.Count);
}
private static QueueEntry Entry(string name, string? session, string? watchRoot) =>
new(name, 1_000 + name.Length, new DateTime(2026, 9, 28, 16, 2, 11, DateTimeKind.Utc), new DateTime(2026, 9, 28, 18, 2, 11), session, watchRoot);
}
@@ -0,0 +1,124 @@
using System.Globalization;
using Titano.Testing;
using Titano.Uploader.Text;
using Titano.Uploader.Uploads;
namespace Titano.App.Tests.Uploader;
public sealed class UploaderTextTests
{
private static readonly CultureInfo En = CultureInfo.GetCultureInfo("en");
private static readonly CultureInfo It = CultureInfo.GetCultureInfo("it");
private static readonly QueueSummary Mockup = new(4_812, 96_200_000_000, 2_214, 2_201, 0, 0, 44_000_000_000, "2026-09-28_18-02-11_0413.CR2")
{
RemainingBytes = 93_480_000_000,
};
[Test]
public void QueueLineMatchesTheMockup()
{
var left = RateMeter.TimeLeft(Mockup.RemainingBytes, 38_000_000);
Assert.Equal("4,812 files · 96.2 GB · 38 MB/s · 41 min left", UploaderText.QueueLine(Mockup, QueueActivity.Running, 38_000_000, left, En));
}
[Test]
public void QueueLineFollowsTheCulture()
{
Assert.Equal("4.812 file · 96,2 GB · 38 MB/s · mancano 41 min", UploaderText.QueueLine(Mockup, QueueActivity.Running, 38_000_000, TimeSpan.FromMinutes(41), It));
}
[Test]
public void QueueLineNamesTheActivityWhenNotRunning()
{
Assert.Equal("4,812 files · 96.2 GB · Paused", UploaderText.QueueLine(Mockup, QueueActivity.Paused, 0, null, En));
Assert.Equal("4,812 files · 96.2 GB · Waiting for server", UploaderText.QueueLine(Mockup, QueueActivity.WaitingForServer, 0, null, En));
Assert.Equal("1 file · 25 MB · Done", UploaderText.QueueLine(Mockup with { Files = 1, Bytes = 25_000_000 }, QueueActivity.Done, 0, null, En));
Assert.Equal("Nothing queued", UploaderText.QueueLine(default, QueueActivity.Idle, 0, null, En));
}
[Test]
public void RunningLineOmitsRateAndTimeUntilKnown()
{
Assert.Equal("4,812 files · 96.2 GB", UploaderText.QueueLine(Mockup, QueueActivity.Running, 0, null, En));
}
[Test]
public void ProgressLineMatchesTheMockup()
{
Assert.Equal("2,214 of 4,812 sent · 2,201 verified by the server · 0 retries", UploaderText.ProgressLine(Mockup, En));
Assert.Equal("2,214 of 4,812 sent · 2,201 verified by the server · 1 retry · 3 failed", UploaderText.ProgressLine(Mockup with { Retries = 1, Failed = 3 }, En));
}
[Theory]
[Case(0.0, "0 B/s")]
[Case(950_000.0, "950 KB/s")]
[Case(4_240_000.0, "4.2 MB/s")]
[Case(38_400_000.0, "38 MB/s")]
[Case(1_260_000_000.0, "1.3 GB/s")]
public void RatesUseDecimalUnits(double bytesPerSecond, string expected) =>
Assert.Equal(expected, UploaderText.Rate(bytesPerSecond, En));
[Theory]
[Case(40.0, "40 s")]
[Case(299.0, "5 min")]
[Case(3_590.0, "1 h 00 m")]
[Case(7_500.0, "2 h 05 m")]
[Case(93_600.0, "1 d 2 h")]
public void DurationsAreCompact(double seconds, string expected) =>
Assert.Equal(expected, UploaderText.Duration(TimeSpan.FromSeconds(seconds), En));
[Theory]
[Case(999L, "999 B")]
[Case(1_536L, "1.5 KB")]
[Case(96_200_000_000L, "96.2 GB")]
[Case(1_900_000_000_000L, "1.9 TB")]
public void SizesUseDecimalUnits(long bytes, string expected) => Assert.Equal(expected, UploaderText.Bytes(bytes, En));
[Test]
public void TimeLeftNeedsAUsableRate()
{
Assert.Equal(TimeSpan.FromMinutes(41), RateMeter.TimeLeft(93_480_000_000, 38_000_000));
Assert.Equal(TimeSpan.Zero, RateMeter.TimeLeft(0, 0));
Assert.Null(RateMeter.TimeLeft(1_000, 10));
}
[Test]
public void RateMeterAveragesTheWindowAndDecaysWhenStalled()
{
var meter = new RateMeter(TimeSpan.FromSeconds(10));
Assert.Equal(0.0, meter.BytesPerSecond(TimeSpan.Zero));
for (var s = 0; s <= 20; s++) meter.Add(4_000_000, TimeSpan.FromSeconds(s));
Assert.Approximately(4_000_000, meter.BytesPerSecond(TimeSpan.FromSeconds(20)), 1);
// Nothing sent for 20 s: the window holds no transfer any more.
Assert.Equal(0.0, meter.BytesPerSecond(TimeSpan.FromSeconds(40)));
meter.Reset();
Assert.Equal(0.0, meter.BytesPerSecond(TimeSpan.FromSeconds(40)));
}
[Test]
public void SummaryCountsStatesAndBytes()
{
var queue = new UploadQueue();
queue.Add(new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions },
Enumerable.Range(0, 5).Select(i => new QueueEntry($"{i}.jpg", 100, DateTime.UtcNow, null, null, null)));
queue.Items[0].State = UploadItemState.Verified;
queue.Items[1].State = UploadItemState.Skipped;
queue.Items[2].State = UploadItemState.Uploading;
queue.Items[2].BytesSent = 40;
queue.Items[3].State = UploadItemState.Failed;
queue.Items[3].Retries = 1;
var s = QueueSummary.From(queue.Items);
Assert.Equal(5, s.Files);
Assert.Equal(500L, s.Bytes);
Assert.Equal(2, s.Sent);
Assert.Equal(2, s.Verified);
Assert.Equal(1, s.Failed);
Assert.Equal(1, s.Retries);
Assert.Equal(240L, s.DoneBytes);
Assert.Equal(160L, s.RemainingBytes);
Assert.Equal("2.jpg", s.CurrentFile);
Assert.Approximately(0.48, s.Progress, 1e-9);
}
}