diff --git a/docs/guida/Attivita-e-arresti.md b/docs/guida/Attivita-e-arresti.md
index 8bfbab1..2261165 100644
--- a/docs/guida/Attivita-e-arresti.md
+++ b/docs/guida/Attivita-e-arresti.md
@@ -101,7 +101,8 @@ riprendere: lascia Febe in pausa.
## Che cosa fare dopo una disconnessione
-1. «Apri il browser»: la pagina mostra l'accesso di Instagram.
+1. «Apri il browser» nella striscia rossa: il browser apre la pagina di accesso di Instagram (anche se era a riposo
+ sulla pagina vuota).
2. Accedi a mano (nome utente, password, eventuale codice), aspetta la pagina iniziale, «Ho finito».
3. «Riprendi». Anche qui riparte l'avvio graduale.
diff --git a/docs/guida/Installazione-Windows.md b/docs/guida/Installazione-Windows.md
index 4e31286..ac416d8 100644
--- a/docs/guida/Installazione-Windows.md
+++ b/docs/guida/Installazione-Windows.md
@@ -19,6 +19,13 @@
automatica sono spenti.
- Ciò che scrivi nella finestra del browser va direttamente alla pagina di Instagram: Febe non riceve la password.
Mentre usi il browser il motore resta fermo; quando hai finito chiudi la finestra (o «Ho finito»): torna fuori vista.
+ Lasciare la pagina di Febe da cui l'hai aperta non la chiude: resta sullo schermo finché non la chiudi tu.
+- Sullo schermo la finestra ha il suo pulsante nella barra delle applicazioni, così ridurla a icona non la fa sparire.
+ Ridotta a icona però non può restare a lungo (S2): dopo due minuti Febe la rimette fuori vista, come se l'avessi
+ chiusa. Se lo schermo è troppo piccolo per la pagina e la sua barra, la finestra si restringe e mostra la pagina
+ rimpicciolita, sempre della stessa misura per Instagram. Nella barra in basso: «Indietro», «Ricarica», «Pagina
+ iniziale» (la home di Instagram se sei collegato, altrimenti la pagina di accesso) e l'indirizzo; sulla pagina
+ vuota di riposo la barra dice «Il browser è a riposo su una pagina vuota».
- Funzioni di Windows offerte all'interfaccia: scelta di una cartella, «Mostra nella cartella», indirizzi aperti nel
tuo browser predefinito (mai nel browser di Febe), notifiche di Windows, avvio con il computer.
diff --git a/docs/guida/Primo-collegamento.md b/docs/guida/Primo-collegamento.md
index 36bd4f0..1239c05 100644
--- a/docs/guida/Primo-collegamento.md
+++ b/docs/guida/Primo-collegamento.md
@@ -64,10 +64,20 @@ Poi aggiungi gli account da seguire: [Account e impostazioni](Account-e-impostaz
## Usare il browser a mano
Da collegato, **«Usa il browser»** apre il browser di Febe (in Docker la pagina «Browser», con la vista remota e i
-comandi «Indietro» e «Ricarica»; su Windows la finestra). Serve per controllare qualcosa a mano. Mentre lo usi il
-motore resta fermo; quando hai finito premi «Ho finito». Se lasci la pagina Browser, o la pagina Collegamento mentre
-accedi, senza premere «Ho finito» (un'altra pagina, la scheda chiusa o ricaricata), vale come «Annulla»: il browser
-torna sulla pagina vuota e il motore può lavorare di nuovo.
+comandi «Indietro», «Ricarica» e «Pagina iniziale»; su Windows la finestra, con gli stessi tre pulsanti nella barra in
+basso). Serve per controllare qualcosa a mano. Mentre lo usi il motore resta fermo; quando hai finito premi «Ho finito».
+
+Quando Febe non lo usa, il browser resta **a riposo su una pagina vuota**. Se lo apri mentre è a riposo, Febe apre per
+te la **pagina iniziale**: la home di Instagram se sei collegato, la pagina di accesso se non lo sei (o se Instagram ti
+ha scollegato). Se invece c'è già una pagina (per esempio quella di una verifica), la lascia com'è. «Pagina iniziale»
+ci torna quando vuoi; se la barra dice «Il browser è a riposo su una pagina vuota», premilo.
+
+Se lasci la pagina Browser, o la pagina Collegamento mentre accedi, senza premere «Ho finito» (un'altra pagina, la
+scheda chiusa o ricaricata):
+
+- **in Docker** vale come «Annulla»: il browser torna sulla pagina vuota e il motore può lavorare di nuovo;
+- **su Windows** la finestra «Browser di Febe» resta com'è, sullo schermo e con la sua pagina, finché non la chiudi (o
+ premi «Ho finito»); finché è sullo schermo il motore resta fermo.
## Scollegarsi
diff --git a/docs/guida/Problemi-comuni.md b/docs/guida/Problemi-comuni.md
index c4f5f4c..d09d198 100644
--- a/docs/guida/Problemi-comuni.md
+++ b/docs/guida/Problemi-comuni.md
@@ -26,6 +26,8 @@ dati.
| Che cosa vedi | Che cosa fare |
|---|---|
| La vista remota è lenta o non risponde | La vista è un'immagine della pagina inviata dal server: aspetta qualche secondo dopo ogni clic. Se dice «La vista remota non risponde», premi «Riprova»; se si apre in un'altra finestra, la precedente si chiude da sola (una vista alla volta) |
+| La vista remota dice «Nessuna immagine dal browser» | La vista è aperta ma la pagina non arriva. Febe riavvia da solo l'invio delle immagini quando si fermano; premi «Riprova». Se resta così, guarda il registro (categoria «vista»: avvii, riavvii e silenzi) e riferisci il caso |
+| Il browser è bianco, o la barra dice «Il browser è a riposo su una pagina vuota» | È la pagina vuota su cui Febe lascia il browser quando non lo usa: premi «Pagina iniziale» (la home di Instagram se sei collegato, altrimenti la pagina di accesso) |
| «Ho finito» dice che l'accesso non è riuscito | Nella pagina deve comparire la tua pagina iniziale di Instagram, non il modulo di accesso: completa l'accesso, poi di nuovo «Ho finito» |
| Dopo un riavvio Febe chiede di nuovo l'accesso | Non dovrebbe: la sessione è nel profilo del browser in `/dati/browser`. Controlla che `/dati` sia un volume persistente e non sia stato cancellato; riferisci il caso (è la voce S3 di [Ipotesi da verificare](Ipotesi-da-verificare)) |
diff --git a/src/Febe.App/BrowserConnectionService.cs b/src/Febe.App/BrowserConnectionService.cs
index 08da929..73000ef 100644
--- a/src/Febe.App/BrowserConnectionService.cs
+++ b/src/Febe.App/BrowserConnectionService.cs
@@ -17,9 +17,10 @@ namespace Febe.App;
/// means that the session cookie exists in the browser profile: only its existence is checked
/// (Network.getCookies, names only), never its value. Opening the login page is Alberto's action, not the
/// engine's (rule 7, last sentence): it happens only while he holds the «driving» lease and the engine is still.
-/// On Windows the browser is the window «Browser di Febe»: «Accedi» and «Portalo in primo piano» bring it to the front,
-/// «Ho finito» and «Annulla» put it back out of view, «Scollega» closes it before deleting the profile. In Docker
-/// showing and hiding do nothing (the remote view shows the browser).
+/// On Windows the browser is the window «Browser di Febe»: «Accedi», «Apri il browser» and «Portalo in primo piano»
+/// bring it to the front, «Ho finito» and «Annulla» put it back out of view, «Scollega» closes it before deleting the
+/// profile; leaving a page of Febe leaves it as it is. In Docker showing and hiding do nothing (the remote view shows
+/// the browser).
///
///
///
@@ -29,6 +30,11 @@ namespace Febe.App;
/// must not stay still for ever.
///
///
+/// Alberto never meets the empty rest page (issue #52): when he takes the browser while it rests there, his own first
+/// navigation (rule 7, like the login page) opens — the site's home when connected, the login
+/// page when not connected or after a disconnection.
+///
+///
/// A session cookie that disappears outside a session (or is missing at start-up after a connection) is a disconnection
/// (spec §7.6): reported to the breaker as the recipes would, so that it is an incident with its alert and only
/// «Riprendi» restarts the engine. Not when Alberto himself is at the browser, nor after his «Scollega».
@@ -54,6 +60,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
private readonly IClock _clock;
private readonly FebeLog _log;
private readonly string _loginUrl;
+ private readonly string _homeUrl;
private readonly SessionCookieOptions _cookie;
private readonly SemaphoreSlim _commands = new(1, 1);
private readonly Lock _gate = new();
@@ -65,7 +72,15 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
private bool? _disconnectedByUser;
private DateTimeOffset _checkedAt = DateTimeOffset.MinValue;
- public BrowserConnectionService(IFebeBrowser browser, IFebeStorage storage, BrowserUseTracker tracker, IClock clock, FebeLog log, string loginUrl, SessionCookieOptions cookie)
+ /// The browser of Febe.
+ /// The database (first connection, «Scollega»).
+ /// When Alberto last used the browser.
+ /// The composition's clock.
+ /// Febe's log.
+ /// The page «Accedi a Instagram» opens.
+ /// The site's home, the start page once connected.
+ /// The session cookie looked for (its name only).
+ public BrowserConnectionService(IFebeBrowser browser, IFebeStorage storage, BrowserUseTracker tracker, IClock clock, FebeLog log, string loginUrl, string homeUrl, SessionCookieOptions cookie)
{
_browser = browser ?? throw new ArgumentNullException(nameof(browser));
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
@@ -73,6 +88,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
_clock = clock ?? throw new ArgumentNullException(nameof(clock));
_log = log ?? throw new ArgumentNullException(nameof(log));
_loginUrl = loginUrl ?? throw new ArgumentNullException(nameof(loginUrl));
+ _homeUrl = homeUrl ?? throw new ArgumentNullException(nameof(homeUrl));
_cookie = cookie ?? throw new ArgumentNullException(nameof(cookie));
}
@@ -91,6 +107,14 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
}
}
+ ///
+ /// Where the browser goes when Alberto takes it from the rest page or presses «Pagina iniziale» (issue #52): the
+ /// site's home when the session is there, the login page when it is not (or not known yet) and after a disconnection
+ /// (spec §7.6), when Instagram's home would only send him there.
+ ///
+ public string StartPageUrl =>
+ IsConnected == true && _engine?.Services.Breaker.State.Status != BreakerStatus.Disconnected ? _homeUrl : _loginUrl;
+
///
/// Hook for the readers (hypothesis H10): when the data of the page tell which account is connected, the composition
/// marks it as «Tu» (); the status shows that account. Raised after every change of the
@@ -150,21 +174,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
}
_tracker.MarkUsed(_clock.Now);
- if (openLogin)
- {
- // The engine ends its session when the lease starts; wait for it before taking the page. A search step
- // in progress (issue #37) stops at its next check of the lease: the login page waits for its turn.
- await WaitForSessionEndAsync(ct).ConfigureAwait(false);
- using var turn = await TakePageAsync(ct).ConfigureAwait(false);
- var result = await _browser.Cdp.NavigateAsync(_loginUrl, ct).ConfigureAwait(false);
- _log.Info("collegamento", result.Succeeded
- ? "Alberto usa il browser: pagina di accesso aperta."
- : "Alberto usa il browser: la pagina di accesso non si è aperta (errore di rete del browser).");
- }
- else
- {
- _log.Info("collegamento", "Alberto usa il browser.");
- }
+ await OpenForAlbertoAsync(openLogin, ct).ConfigureAwait(false);
// Windows: the window «Browser di Febe» comes to the front (Docker: nothing, the remote view shows it).
await ShowQuietlyAsync(ct).ConfigureAwait(false);
@@ -175,6 +185,43 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
}
}
+ public async Task ShowBrowserAsync(bool openLogin, CancellationToken ct)
+ {
+ EnsureBrowser();
+ await _commands.WaitAsync(ct).ConfigureAwait(false);
+
+ // Alberto's hold while his page opens: the window takes its own lease when it comes on screen, and holds the
+ // engine still for as long as it stays there (closing it ends it, as before).
+ var hold = _browser.UserDriving.Begin();
+ try
+ {
+ _tracker.MarkUsed(_clock.Now);
+ await OpenForAlbertoAsync(openLogin, ct).ConfigureAwait(false);
+ await _browser.ShowToUserAsync(ct).ConfigureAwait(false);
+ }
+ finally
+ {
+ hold.Dispose();
+ _commands.Release();
+ }
+ }
+
+ public async Task ReleaseAsync(CancellationToken ct)
+ {
+ await _commands.WaitAsync(ct).ConfigureAwait(false);
+ try
+ {
+ if (ReleaseLease())
+ {
+ _log.Info("collegamento", "Pagina di Febe lasciata: la finestra del browser resta com'è finché non la chiudi.");
+ }
+ }
+ finally
+ {
+ _commands.Release();
+ }
+ }
+
public async Task FinishAsync(CancellationToken ct)
{
await _commands.WaitAsync(ct).ConfigureAwait(false);
@@ -305,16 +352,18 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
///
/// Looks at the cookie now (outside the cache) and records the change. Used at start-up, by the background loop
/// and after the test site's automatic login. A session that went away (or is missing at start-up after a
- /// connection) while Alberto is not at the browser is reported to the breaker as a disconnection (spec §7.6).
+ /// connection) while Alberto is not at the browser is reported to the breaker as a disconnection (spec §7.6) —
+ /// unless is false: the first look of a start with the test site's automatic login,
+ /// which is about to open the session itself (issue #52: a false disconnection at every development start).
///
- public async Task RefreshAsync(CancellationToken ct)
+ public async Task RefreshAsync(CancellationToken ct, bool mayReport = true)
{
if (!_browser.IsAvailable)
{
return IsConnected;
}
- var connected = await CheckAsync(force: true, mayReport: true, ct).ConfigureAwait(false);
+ var connected = await CheckAsync(force: true, mayReport, ct).ConfigureAwait(false);
if (connected == true)
{
await MarkConnectedAsync(ct).ConfigureAwait(false);
@@ -528,6 +577,64 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
return true;
}
+ ///
+ /// Alberto's own first navigation (rule 7: not an engine action, no Governor), under his lease: the login page when
+ /// asked for, and the start page when the browser rests on the empty page (issue #52). Any other page stays as it is
+ /// — the one he was using, or the verification page of a stop.
+ ///
+ private async Task OpenForAlbertoAsync(bool openLogin, CancellationToken ct)
+ {
+ if (!openLogin && !IsRest(await FullUrlAsync(ct).ConfigureAwait(false)))
+ {
+ _log.Info("collegamento", "Alberto usa il browser.");
+ return;
+ }
+
+ // The engine ends its session when the lease starts; wait for it before taking the page. A search step in
+ // progress (issue #37) stops at its next check of the lease: Alberto's page waits for its turn.
+ await WaitForSessionEndAsync(ct).ConfigureAwait(false);
+ using var turn = await TakePageAsync(ct).ConfigureAwait(false);
+ string target;
+ string what;
+ if (openLogin)
+ {
+ target = _loginUrl;
+ what = "pagina di accesso";
+ }
+ else if (IsRest(await FullUrlAsync(ct).ConfigureAwait(false)))
+ {
+ target = StartPageUrl;
+ what = target == _loginUrl ? "era a riposo, pagina di accesso" : "era a riposo, pagina iniziale del sito";
+ }
+ else
+ {
+ // The session that just ended left its page: his to look at.
+ _log.Info("collegamento", "Alberto usa il browser.");
+ return;
+ }
+
+ var result = await _browser.Cdp.NavigateAsync(target, ct).ConfigureAwait(false);
+ _log.Info("collegamento", result.Succeeded
+ ? $"Alberto usa il browser: {what} aperta."
+ : $"Alberto usa il browser: {what} non aperta (errore di rete del browser).");
+ }
+
+ /// The empty rest page (or no document at all): never what Alberto should be shown.
+ private static bool IsRest(string? url) => url is "" or CdpPageExtensions.RestUrl;
+
+ /// The address of the main frame, in full (never logged); null when the browser does not answer.
+ private async Task FullUrlAsync(CancellationToken ct)
+ {
+ try
+ {
+ return await _browser.Cdp.GetMainFrameUrlAsync(ct).ConfigureAwait(false);
+ }
+ catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException or KeyNotFoundException or InvalidOperationException)
+ {
+ return null;
+ }
+ }
+
private async Task WaitForSessionEndAsync(CancellationToken ct)
{
if (_engine is not { } engine)
diff --git a/src/Febe.App/FebeApp.cs b/src/Febe.App/FebeApp.cs
index 932ed93..d82a16b 100644
--- a/src/Febe.App/FebeApp.cs
+++ b/src/Febe.App/FebeApp.cs
@@ -245,9 +245,11 @@ public sealed class FebeApp : IAsyncDisposable
}
// Browser, connection, engine. The engine loop starts only once the browser is up.
- var browser = await _platform.CreateBrowserAsync(new FebePlatformContext(o, data, Database, Clock, Log, Tracker), ct).ConfigureAwait(false);
+ // The start page (issue #52) is the connection's, which exists only after the browser: read when asked.
+ var context = new FebePlatformContext(o, data, Database, Clock, Log, Tracker, () => Connection?.StartPageUrl ?? o.LoginUrl);
+ var browser = await _platform.CreateBrowserAsync(context, ct).ConfigureAwait(false);
Browser = browser;
- var connection = new BrowserConnectionService(browser, Database, Tracker, Clock, Log, o.LoginUrl, o.Site.SessionCookie);
+ var connection = new BrowserConnectionService(browser, Database, Tracker, Clock, Log, o.LoginUrl, HomeUrl(o.Site.BaseUrl), o.Site.SessionCookie);
Connection = connection;
var engineOptions = o.FirstSessionDelay is { } delay
? EngineOptions.Default with { StartupDelayMin = delay, StartupDelayMax = delay }
@@ -458,7 +460,9 @@ public sealed class FebeApp : IAsyncDisposable
services.Events.Notified += WakeDownloads;
OnStop(() => services.Events.Notified -= WakeDownloads);
- await Connection!.RefreshAsync(ct).ConfigureAwait(false);
+ // With the test site's automatic login the first look reports nothing: the session it may not find yet is
+ // the one the login below opens (issue #52), not a disconnection.
+ await Connection!.RefreshAsync(ct, mayReport: !o.TestSiteAutoLogin).ConfigureAwait(false);
if (o.TestSiteAutoLogin && Connection.IsConnected != true)
{
await TestSiteLoginAsync(ct).ConfigureAwait(false);
@@ -514,6 +518,10 @@ public sealed class FebeApp : IAsyncDisposable
}
}
+ /// The site's home page as the browser writes it (with its final slash), for «Pagina iniziale».
+ private static string HomeUrl(string baseUrl) =>
+ Uri.TryCreate(baseUrl, UriKind.Absolute, out var home) ? home.AbsoluteUri : baseUrl;
+
///
/// Development with the test site only (--accesso-di-prova): what Alberto does by hand on Instagram — open
/// the site once, so that its session cookie exists — then back to the rest page.
diff --git a/src/Febe.App/FebeLog.cs b/src/Febe.App/FebeLog.cs
index 90dbac2..fb3a81f 100644
--- a/src/Febe.App/FebeLog.cs
+++ b/src/Febe.App/FebeLog.cs
@@ -101,7 +101,8 @@ public sealed partial class FebeLog : IDisposable
}
/// The adapter for the browser layer (it logs only CDP command names, states and counts).
- public IBrowserLog ForBrowser() => new DelegateBrowserLog((level, message, exception) => Write(
+ /// The category of the lines (the remote view writes as «vista»).
+ public IBrowserLog ForBrowser(string category = "browser") => new DelegateBrowserLog((level, message, exception) => Write(
level switch
{
BrowserLogLevel.Error => LogLevel.Error,
@@ -109,7 +110,7 @@ public sealed partial class FebeLog : IDisposable
BrowserLogLevel.Information => LogLevel.Information,
_ => LogLevel.Debug,
},
- "browser",
+ category,
message,
exception));
diff --git a/src/Febe.App/IFebePlatform.cs b/src/Febe.App/IFebePlatform.cs
index acf5238..6f5e947 100644
--- a/src/Febe.App/IFebePlatform.cs
+++ b/src/Febe.App/IFebePlatform.cs
@@ -55,7 +55,15 @@ public interface IFebePlatform
/// The clock of the engine.
/// The log.
/// When Alberto last used the browser: the desktop window marks it when he uses and closes it.
-public sealed record FebePlatformContext(FebeAppOptions Options, DataFolderLayout Data, IFebeStorage Storage, IClock Clock, FebeLog Log, BrowserUseTracker Tracker);
+///
+/// Where «Pagina iniziale» of the browser window goes (issue #52): the site's home when connected, the login page
+/// otherwise. Null: the login page.
+///
+public sealed record FebePlatformContext(FebeAppOptions Options, DataFolderLayout Data, IFebeStorage Storage, IClock Clock, FebeLog Log, BrowserUseTracker Tracker, Func? StartPage = null)
+{
+ /// The start page now (, or the login page).
+ public string CurrentStartPage() => StartPage?.Invoke() ?? Options.LoginUrl;
+}
/// Options of the shared composition, filled by each shell from its own configuration.
public sealed record FebeAppOptions
diff --git a/src/Febe.App/StartupProblems.cs b/src/Febe.App/StartupProblems.cs
index 77338b6..b750e2d 100644
--- a/src/Febe.App/StartupProblems.cs
+++ b/src/Febe.App/StartupProblems.cs
@@ -47,6 +47,10 @@ public sealed class ProblemConnectionService(IReadOnlyList
public Task CancelAsync(CancellationToken ct) => Task.CompletedTask;
+ public Task ShowBrowserAsync(bool openLogin, CancellationToken ct) => throw Refused();
+
+ public Task ReleaseAsync(CancellationToken ct) => Task.CompletedTask;
+
public Task DisconnectAsync(CancellationToken ct) => throw Refused();
private Febe.Web.Api.BadRequestException Refused() =>
diff --git a/src/Febe.Browser/RemoteView/RemoteViewSession.cs b/src/Febe.Browser/RemoteView/RemoteViewSession.cs
index 9ab7dd1..c59fdf9 100644
--- a/src/Febe.Browser/RemoteView/RemoteViewSession.cs
+++ b/src/Febe.Browser/RemoteView/RemoteViewSession.cs
@@ -66,7 +66,7 @@ public sealed class RemoteViewSession : IAsyncDisposable
/// The page session.
/// Where the «Alberto is driving» lease is taken.
- /// Where opening and closing are noted (never keys).
+ /// Where the frames' starts, restarts and silences are noted (never keys).
/// Wall-clock time for the screencast's start attempts; null: the system clock.
public RemoteViewSession(ICdpSession cdp, UserDrivingGate gate, IBrowserLog? log = null, IClock? clock = null)
{
@@ -100,7 +100,8 @@ public sealed class RemoteViewSession : IAsyncDisposable
throw;
}
- _log.Info("Vista remota aperta: il motore resta fermo finché Alberto usa il browser.");
+ // The host notes the opening in its own words; here only for whoever uses the session alone.
+ _log.Debug("Vista remota aperta: il motore resta fermo finché Alberto usa il browser.");
}
public async Task MouseAsync(RemoteMouseEvent e, CancellationToken ct = default)
@@ -198,7 +199,7 @@ public sealed class RemoteViewSession : IAsyncDisposable
_buttons = 0;
}
- _log.Info("Vista remota chiusa.");
+ _log.Debug("Vista remota chiusa.");
}
public async ValueTask DisposeAsync()
diff --git a/src/Febe.Browser/RemoteView/ScreencastSession.cs b/src/Febe.Browser/RemoteView/ScreencastSession.cs
index 5b3e299..31604f4 100644
--- a/src/Febe.Browser/RemoteView/ScreencastSession.cs
+++ b/src/Febe.Browser/RemoteView/ScreencastSession.cs
@@ -1,3 +1,4 @@
+using System.Globalization;
using System.Runtime.CompilerServices;
using System.Text.Json;
using System.Text.Json.Nodes;
@@ -13,7 +14,33 @@ namespace Febe.Browser.RemoteView;
/// Largest frame width in pixels.
/// Largest frame height in pixels.
/// Send one frame out of this many.
-public sealed record ScreencastOptions(int Quality = 70, int MaxWidth = 1280, int MaxHeight = 900, int EveryNthFrame = 1);
+/// How missing frames are noticed and the frames started again; null: never (issue #52).
+public sealed record ScreencastOptions(int Quality = 70, int MaxWidth = 1280, int MaxHeight = 900, int EveryNthFrame = 1, ScreencastWatchdog? Watchdog = null);
+
+///
+/// When the remote view starts its frames again (issue #52): Chromium sends a frame only when the page repaints, a
+/// lost acknowledgement stops the frames for good, and a change of renderer (another site, the rest page, a crash) may
+/// leave the screencast on the old one. After without frames — measured from the start, from the
+/// last frame or from the last change of document of the main frame — the screencast is stopped and started again (a
+/// new screencast session), and one still picture of the page is sent when the start brings no frame. Each restart
+/// doubles the wait, up to : a page that does not move (Chromium sends nothing then) costs
+/// one restart every so often, not one every two seconds. Frames that flow again ( after a
+/// restart) or a new document bring the wait back to .
+///
+/// Time without frames before the first restart.
+/// How often the watchdog looks.
+/// The longest wait between two restarts without frames.
+public sealed record ScreencastWatchdog(TimeSpan Silence, TimeSpan Tick, TimeSpan LongestSilence)
+{
+ ///
+ /// Frames after a restart that show the page is moving: a start alone brings one frame even on a still page, which
+ /// says that the screencast works, not that it keeps going.
+ ///
+ public const int FlowingFrames = 3;
+
+ /// About two seconds, looked at four times a second, at most half a minute between restarts.
+ public static ScreencastWatchdog Default { get; } = new(TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(250), TimeSpan.FromSeconds(30));
+}
/// One frame of the remote view.
/// The image.
@@ -24,6 +51,7 @@ public sealed record ScreencastOptions(int Quality = 70, int MaxWidth = 1280, in
/// Horizontal scroll position.
/// Vertical scroll position.
/// Browser timestamp (seconds), when given.
+/// True for a still picture (Page.captureScreenshot) sent because no frame came.
public sealed record ScreencastFrame(
byte[] Jpeg,
double DeviceWidth,
@@ -32,7 +60,8 @@ public sealed record ScreencastFrame(
double OffsetTop,
double ScrollOffsetX,
double ScrollOffsetY,
- double? Timestamp);
+ double? Timestamp,
+ bool Still = false);
///
/// The remote view's video (spec §4.1, §11): Page.startScreencast in JPEG, every frame acknowledged with
@@ -40,9 +69,16 @@ public sealed record ScreencastFrame(
/// (only the latest ones are kept when the reader is slow) and .
///
///
+///
/// A view opened while the page changes document (the rest page after a session, the login page opened together with
/// the view) can meet the moment in which Chromium refuses the start with «Not attached to an active page»: the start
/// is sent again, a few times, for at most . Any other failure is reported at once.
+///
+///
+/// With a the frames are started again when they stop coming (issue #52): after a
+/// silence, and when the main frame finished loading a new document (Page.loadEventFired) without a frame. Every
+/// restart, the start after a browser restart and the stop run one at a time, so the stop is never followed by a start.
+///
///
public sealed class ScreencastSession : IAsyncDisposable
{
@@ -60,15 +96,32 @@ public sealed class ScreencastSession : IAsyncDisposable
private readonly Channel _acks = Channel.CreateUnbounded(new UnboundedChannelOptions { SingleReader = true });
private readonly CancellationTokenSource _lifetime = new();
+
+ // Starts after the first one (watchdog, browser restart) and the stop: one at a time.
+ private readonly SemaphoreSlim _starts = new(1, 1);
+ private readonly Lock _watch = new();
+ private readonly List _pageEvents = [];
private IDisposable? _subscription;
private Task? _ackPump;
+ private Task? _watchdog;
private ScreencastOptions? _options;
private int _stopped;
private long _framesReceived;
+ private long _restarts;
+
+ // Guarded by _watch: when silence is measured from, how long it may last, and what the page did meanwhile.
+ private DateTimeOffset _lastFrameAt;
+ private DateTimeOffset _watchFrom;
+ private TimeSpan _silenceLimit;
+ private long _framesAtNavigation;
+ private int _framesSinceRestart;
+ private bool _restartWanted;
+ private bool _silent;
+ private DateTimeOffset _silentSince;
/// The page session.
- /// Where the start and stop are noted (never parameters or frames).
- /// Wall-clock time for the pauses between start attempts; null: the system clock.
+ /// Where starts, restarts and silences are noted (never parameters or frames).
+ /// Wall-clock time for the pauses between start attempts and the watchdog; null: the system clock.
public ScreencastSession(ICdpSession cdp, IBrowserLog? log = null, IClock? clock = null)
{
_cdp = cdp ?? throw new ArgumentNullException(nameof(cdp));
@@ -79,11 +132,15 @@ public sealed class ScreencastSession : IAsyncDisposable
/// Raised on the browser event thread for every frame: handlers must be quick.
public event EventHandler? FrameReceived;
- /// The last frame received, for mapping input coordinates.
+ /// The last frame received (or still picture sent), for mapping input coordinates.
public ScreencastFrame? LastFrame { get; private set; }
+ /// Frames of the screencast received so far (still pictures not counted).
public long FramesReceived => Interlocked.Read(ref _framesReceived);
+ /// How many times the watchdog started the frames again.
+ public long Restarts => Interlocked.Read(ref _restarts);
+
public async Task StartAsync(ScreencastOptions? options = null, CancellationToken ct = default)
{
if (_subscription is not null)
@@ -100,7 +157,20 @@ public sealed class ScreencastSession : IAsyncDisposable
_ackPump = Task.Run(() => AckPumpAsync(_lifetime.Token), CancellationToken.None);
await SendStartAsync(ct).ConfigureAwait(false);
- _log.Debug("Vista remota avviata.");
+ if (_options.Watchdog is { } watchdog)
+ {
+ lock (_watch)
+ {
+ _watchFrom = _clock.Now;
+ _silenceLimit = watchdog.Silence;
+ }
+
+ _pageEvents.Add(_cdp.On("Page.frameNavigated", OnFrameNavigated));
+ _pageEvents.Add(_cdp.On("Page.loadEventFired", OnLoadEventFired));
+ _watchdog = Task.Run(() => WatchAsync(watchdog, _lifetime.Token), CancellationToken.None);
+ }
+
+ _log.Info("Vista remota: fotogrammi avviati.");
}
/// Frames as they arrive; the oldest are dropped if the reader falls behind. Ends when the session stops.
@@ -124,31 +194,44 @@ public sealed class ScreencastSession : IAsyncDisposable
events.Reconnected -= OnReconnected;
}
- if (_subscription is not null)
+ foreach (var subscription in _pageEvents)
{
- _subscription.Dispose();
- try
+ subscription.Dispose();
+ }
+
+ // The watchdog and any start under way end first: no start may follow the stop below.
+ await _lifetime.CancelAsync().ConfigureAwait(false);
+ if (_watchdog is not null)
+ {
+ await Quietly(_watchdog).ConfigureAwait(false);
+ }
+
+ await _starts.WaitAsync(CancellationToken.None).ConfigureAwait(false);
+ try
+ {
+ if (_subscription is not null)
{
- await _cdp.SendAsync("Page.stopScreencast", null, ct).ConfigureAwait(false);
- }
- catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException)
- {
- // The browser is gone: nothing to stop.
+ _subscription.Dispose();
+ try
+ {
+ await _cdp.SendAsync("Page.stopScreencast", null, ct).ConfigureAwait(false);
+ }
+ catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException)
+ {
+ // The browser is gone: nothing to stop.
+ }
}
}
+ finally
+ {
+ _starts.Release();
+ }
_frames.Writer.TryComplete();
_acks.Writer.TryComplete();
- await _lifetime.CancelAsync().ConfigureAwait(false);
if (_ackPump is not null)
{
- try
- {
- await _ackPump.ConfigureAwait(false);
- }
- catch (OperationCanceledException)
- {
- }
+ await Quietly(_ackPump).ConfigureAwait(false);
}
_log.Debug("Vista remota fermata.");
@@ -158,6 +241,55 @@ public sealed class ScreencastSession : IAsyncDisposable
{
await StopAsync().ConfigureAwait(false);
_lifetime.Dispose();
+ _starts.Dispose();
+ }
+
+ /// The width and height written in a JPEG's frame header (SOFn), or null when the data has none.
+ internal static (int Width, int Height)? JpegSize(ReadOnlySpan jpeg)
+ {
+ if (jpeg.Length < 4 || jpeg[0] != 0xFF || jpeg[1] != 0xD8)
+ {
+ return null;
+ }
+
+ var i = 2;
+ while (i + 3 < jpeg.Length)
+ {
+ if (jpeg[i] != 0xFF)
+ {
+ return null;
+ }
+
+ var marker = jpeg[i + 1];
+ if (marker == 0xFF)
+ {
+ i++;
+ continue;
+ }
+
+ var length = (jpeg[i + 2] << 8) | jpeg[i + 3];
+ var isFrame = marker is >= 0xC0 and <= 0xCF && marker is not (0xC4 or 0xC8 or 0xCC);
+ if (isFrame)
+ {
+ if (i + 8 >= jpeg.Length)
+ {
+ return null;
+ }
+
+ var height = (jpeg[i + 5] << 8) | jpeg[i + 6];
+ var width = (jpeg[i + 7] << 8) | jpeg[i + 8];
+ return width > 0 && height > 0 ? (width, height) : null;
+ }
+
+ if (length < 2)
+ {
+ return null;
+ }
+
+ i += 2 + length;
+ }
+
+ return null;
}
private async Task SendStartAsync(CancellationToken ct)
@@ -182,7 +314,7 @@ public sealed class ScreencastSession : IAsyncDisposable
ct).ConfigureAwait(false);
if (attempt > 1)
{
- _log.Debug($"Vista remota: fotogrammi avviati al tentativo {attempt.ToString(System.Globalization.CultureInfo.InvariantCulture)}, dopo un cambio di pagina.");
+ _log.Info($"Vista remota: fotogrammi avviati al tentativo {attempt.ToString(CultureInfo.InvariantCulture)}, dopo un cambio di pagina.");
}
return;
@@ -206,16 +338,213 @@ public sealed class ScreencastSession : IAsyncDisposable
private void OnReconnected(object? sender, EventArgs e) =>
_ = Task.Run(async () =>
{
+ var ct = _lifetime.Token;
try
{
- await SendStartAsync(_lifetime.Token).ConfigureAwait(false);
+ await _starts.WaitAsync(ct).ConfigureAwait(false);
+ try
+ {
+ if (Volatile.Read(ref _stopped) == 0)
+ {
+ await SendStartAsync(ct).ConfigureAwait(false);
+ _log.Info("Vista remota: fotogrammi avviati di nuovo dopo il riavvio del browser.");
+ }
+ }
+ finally
+ {
+ _starts.Release();
+ }
+
+ lock (_watch)
+ {
+ _watchFrom = _clock.Now;
+ }
}
- catch (Exception ex) when (ex is not OperationCanceledException)
+ catch (OperationCanceledException) when (ct.IsCancellationRequested)
+ {
+ }
+ catch (ObjectDisposedException)
+ {
+ }
+ catch (Exception ex) when (ex is not OutOfMemoryException)
{
_log.Warn("Vista remota: non è ripartita dopo il riavvio del browser.", ex);
}
});
+ ///
+ /// The watchdog: every it looks how long no frame came; past the allowed
+ /// silence (or when a new document loaded without frames) it starts the frames again.
+ ///
+ private async Task WatchAsync(ScreencastWatchdog watchdog, CancellationToken ct)
+ {
+ while (!ct.IsCancellationRequested)
+ {
+ try
+ {
+ await _clock.Delay(watchdog.Tick, ct).ConfigureAwait(false);
+ bool due;
+ bool afterLoad;
+ TimeSpan silence;
+ lock (_watch)
+ {
+ var now = _clock.Now;
+ var since = _lastFrameAt > _watchFrom ? _lastFrameAt : _watchFrom;
+ silence = now - since;
+ afterLoad = _restartWanted;
+ due = afterLoad || silence >= _silenceLimit;
+ }
+
+ if (due && Volatile.Read(ref _stopped) == 0)
+ {
+ await RestartAsync(watchdog, silence, afterLoad, ct).ConfigureAwait(false);
+ }
+ }
+ catch (OperationCanceledException) when (ct.IsCancellationRequested)
+ {
+ return;
+ }
+ catch (Exception ex) when (ex is not OutOfMemoryException)
+ {
+ // Never the end of the watchdog: the next look tries again.
+ _log.Debug($"Vista remota: controllo dei fotogrammi non riuscito ({ex.GetType().Name}).");
+ }
+ }
+ }
+
+ /// Stop and start again (a new screencast session), then one still picture when no frame came.
+ private async Task RestartAsync(ScreencastWatchdog watchdog, TimeSpan silence, bool afterLoad, CancellationToken ct)
+ {
+ await _starts.WaitAsync(ct).ConfigureAwait(false);
+ try
+ {
+ bool first;
+ lock (_watch)
+ {
+ first = !_silent;
+ if (first)
+ {
+ _silent = true;
+ _silentSince = _clock.Now - silence;
+ }
+ }
+
+ var seconds = Math.Max(1, (int)Math.Round(silence.TotalSeconds)).ToString(CultureInfo.InvariantCulture);
+ var why = afterLoad
+ ? "pagina nuova caricata senza fotogrammi"
+ : $"nessun fotogramma da {seconds} s";
+ var line = $"Vista remota: {why}, riavvio dei fotogrammi.";
+ if (first)
+ {
+ _log.Info(line);
+ }
+ else
+ {
+ _log.Debug(line);
+ }
+
+ var before = FramesReceived;
+ try
+ {
+ await _cdp.SendAsync("Page.stopScreencast", null, ct).ConfigureAwait(false);
+ }
+ catch (Exception ex) when (ex is CdpCommandException or TimeoutException)
+ {
+ // Nothing was running on the browser side: the start below is what matters.
+ }
+
+ await SendStartAsync(ct).ConfigureAwait(false);
+ Interlocked.Increment(ref _restarts);
+ if (FramesReceived == before)
+ {
+ await SendStillAsync(ct).ConfigureAwait(false);
+ }
+ }
+ catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException)
+ {
+ // The browser is restarting or the page is between two documents for longer than the budget: next time.
+ _log.Debug($"Vista remota: riavvio dei fotogrammi non riuscito ({ex.GetType().Name}).");
+ }
+ finally
+ {
+ lock (_watch)
+ {
+ _watchFrom = _clock.Now;
+ _restartWanted = false;
+ _framesSinceRestart = 0;
+ var longer = _silenceLimit + _silenceLimit;
+ _silenceLimit = longer < watchdog.LongestSilence ? longer : watchdog.LongestSilence;
+ }
+
+ _starts.Release();
+ }
+ }
+
+ ///
+ /// One picture of the page as it is (Page.captureScreenshot, already allowed for the preview): a page that
+ /// does not repaint shows something, and the pointer can be placed on it.
+ ///
+ private async Task SendStillAsync(CancellationToken ct)
+ {
+ var jpeg = await PagePreview.CaptureAsync(_cdp, Math.Clamp((_options ?? new ScreencastOptions()).Quality, 0, 100), ct).ConfigureAwait(false);
+ if (jpeg.Length == 0 || Volatile.Read(ref _stopped) == 1)
+ {
+ return;
+ }
+
+ var last = LastFrame;
+ double width;
+ double height;
+ if (last is { DeviceWidth: > 0, DeviceHeight: > 0 })
+ {
+ width = last.DeviceWidth;
+ height = last.DeviceHeight;
+ }
+ else if (JpegSize(jpeg) is { } size)
+ {
+ // Docker's browser draws at one device pixel per CSS pixel.
+ width = size.Width;
+ height = size.Height;
+ }
+ else
+ {
+ var o = _options ?? new ScreencastOptions();
+ width = o.MaxWidth;
+ height = o.MaxHeight;
+ }
+
+ Deliver(new ScreencastFrame(jpeg, width, height, 1, 0, 0, 0, null, Still: true));
+ _log.Debug("Vista remota: immagine ferma della pagina inviata.");
+ }
+
+ private void OnFrameNavigated(JsonElement e)
+ {
+ if (!e.TryGetProperty("frame", out var frame) || frame.TryGetProperty("parentId", out _))
+ {
+ return;
+ }
+
+ // A new document in the main frame (perhaps in another renderer): the silence counts from here, short again.
+ lock (_watch)
+ {
+ _watchFrom = _clock.Now;
+ _framesAtNavigation = FramesReceived;
+ _silenceLimit = _options?.Watchdog?.Silence ?? _silenceLimit;
+ _silent = false;
+ }
+ }
+
+ private void OnLoadEventFired(JsonElement e)
+ {
+ lock (_watch)
+ {
+ if (FramesReceived == _framesAtNavigation)
+ {
+ _restartWanted = true; // loaded and still no frame of it: the next look starts them again
+ }
+ }
+ }
+
private void OnFrame(JsonElement p)
{
if (!p.TryGetProperty("sessionId", out var sid) || !sid.TryGetInt32(out var sessionId))
@@ -242,8 +571,35 @@ public sealed class ScreencastSession : IAsyncDisposable
Read(meta, "scrollOffsetY"),
meta.ValueKind == JsonValueKind.Object && meta.TryGetProperty("timestamp", out var ts) && ts.TryGetDouble(out var t) ? t : null);
- LastFrame = frame;
Interlocked.Increment(ref _framesReceived);
+ TimeSpan? resumedAfter = null;
+ lock (_watch)
+ {
+ _lastFrameAt = _clock.Now;
+ _restartWanted = false;
+ if (++_framesSinceRestart >= ScreencastWatchdog.FlowingFrames && _options?.Watchdog is { } watchdog)
+ {
+ // The page moves: frames flow, and a silence from now on is worth a quick restart again.
+ _silenceLimit = watchdog.Silence;
+ if (_silent)
+ {
+ _silent = false;
+ resumedAfter = _lastFrameAt - _silentSince;
+ }
+ }
+ }
+
+ if (resumedAfter is { } after)
+ {
+ _log.Info($"Vista remota: fotogrammi di nuovo in arrivo, dopo {Math.Max(1, (int)Math.Round(after.TotalSeconds)).ToString(CultureInfo.InvariantCulture)} s di silenzio.");
+ }
+
+ Deliver(frame);
+ }
+
+ private void Deliver(ScreencastFrame frame)
+ {
+ LastFrame = frame;
_frames.Writer.TryWrite(frame);
FrameReceived?.Invoke(this, frame);
}
@@ -258,11 +614,22 @@ public sealed class ScreencastSession : IAsyncDisposable
}
catch (Exception ex) when (ex is CdpDisconnectedException or BrowserUnavailableException or CdpCommandException or TimeoutException)
{
- // A lost ack only pauses frames until the next start.
+ // A lost ack pauses the frames: the watchdog, when there is one, starts them again after the silence.
}
}
}
+ private static async Task Quietly(Task task)
+ {
+ try
+ {
+ await task.ConfigureAwait(false);
+ }
+ catch (OperationCanceledException)
+ {
+ }
+ }
+
private static double Read(JsonElement meta, string name, double fallback = 0) =>
meta.ValueKind == JsonValueKind.Object && meta.TryGetProperty(name, out var v) && v.TryGetDouble(out var d) ? d : fallback;
}
diff --git a/src/Febe.Desktop.Core/DesktopPlatform.cs b/src/Febe.Desktop.Core/DesktopPlatform.cs
index d65691c..7147b55 100644
--- a/src/Febe.Desktop.Core/DesktopPlatform.cs
+++ b/src/Febe.Desktop.Core/DesktopPlatform.cs
@@ -152,7 +152,7 @@ public sealed class DesktopPlatform : IFebePlatform
ArgumentNullException.ThrowIfNull(services);
ArgumentNullException.ThrowIfNull(app);
services.AddSingleton(_shell.Native);
- services.AddSingleton(new DesktopBrowserWindow(() => app.Browser));
+ services.AddSingleton(new DesktopBrowserWindow());
services.AddSingleton(new DesktopDataFolderChange(_locations, app.Options.DataFolder, _dataFolderFixed));
}
@@ -200,29 +200,14 @@ public sealed class DesktopPlatform : IFebePlatform
}
///
-/// «Apri il browser» on Windows (spec §10.3): brings the window «Browser di Febe» to the front. While it is in front
-/// Alberto is driving and the engine is still; closing the window ends it.
+/// The browser of Windows is the window «Browser di Febe» (spec §10.3): «Apri il browser» brings it to the front through
+/// the connection (IConnectionService.ShowBrowserAsync, which opens the start page when it was at rest). While
+/// it is on screen Alberto is driving and the engine is still; closing the window ends it, leaving a page of Febe does
+/// not (issue #52).
///
-public sealed class DesktopBrowserWindow(Func browser) : IBrowserWindow
+public sealed class DesktopBrowserWindow : IBrowserWindow
{
public bool IsSeparateWindow => true;
-
- public async Task ShowAsync(CancellationToken ct)
- {
- if (browser() is not { } current)
- {
- throw new BadRequestException("Il browser di Febe non è in funzione in questo momento.");
- }
-
- if (!current.IsAvailable)
- {
- throw new BadRequestException(current.LastError is { } error
- ? "Il browser di Febe non è in funzione: " + error
- : "Il browser di Febe si sta avviando: riprova fra qualche secondo.");
- }
-
- await current.ShowToUserAsync(ct).ConfigureAwait(false);
- }
}
///
diff --git a/src/Febe.Desktop/Browser/BrowserWindow.cs b/src/Febe.Desktop/Browser/BrowserWindow.cs
index d5017b8..1387333 100644
--- a/src/Febe.Desktop/Browser/BrowserWindow.cs
+++ b/src/Febe.Desktop/Browser/BrowserWindow.cs
@@ -3,21 +3,40 @@ using System.Windows;
using System.Windows.Controls;
using System.Windows.Interop;
using System.Windows.Media;
+using System.Windows.Threading;
namespace Febe.Desktop.Browser;
///
/// The window «Browser di Febe» (spec §4.1, §12): the page of Instagram at a fixed size, always the same, and below it a
-/// thin bar with «Indietro», «Ricarica» and the address without its query string. WebView2 draws into the upper area
-/// (as a child window, or as a DirectComposition visual for S2). When Alberto does not use it the window stays open
-/// but out of view, never hidden nor minimised: WebView2 would stop painting (S2). Closing it only puts it out of view.
+/// thin bar with «Indietro», «Ricarica», «Pagina iniziale» and the address without its query string. WebView2 draws
+/// into the upper area (as a child window, or as a DirectComposition visual for S2). When Alberto does not use it the
+/// window stays open but out of view, never hidden: WebView2 would stop painting (S2). Closing it only puts it out of
+/// view.
///
+///
+///
+/// Issue #52. On screen it has a button in the taskbar, so that minimising it does not make it vanish; minimised it
+/// keeps Alberto at the wheel, but never for long (S2): after it is restored and put out of
+/// view as if he had closed it. When the page and its bar do not fit in the work area of the screen (a small screen, a
+/// large text scale) the window shrinks to fit and the page is shown zoomed out (), always with the
+/// same size in CSS pixels. While the page is the empty rest page the bar says so.
+///
+///
internal sealed class BrowserWindow : Window
{
/// Height of the bar under the page, in device-independent pixels.
public const double BarHeight = 40;
+ /// The smallest zoom the page is shown at when the screen is small.
+ public const double SmallestFit = 0.4;
+
+ /// What the bar says while the page is the empty rest page.
+ public const string RestNotice = "Il browser è a riposo su una pagina vuota: premi «Pagina iniziale».";
+
private readonly TextBlock _address;
+ private readonly Border _page;
+ private readonly DispatcherTimer _minimized;
private bool _allowClose;
public BrowserWindow(int pageWidth, int pageHeight, ImageSource? icon)
@@ -31,8 +50,9 @@ internal sealed class BrowserWindow : Window
WindowStartupLocation = WindowStartupLocation.Manual;
ShowActivated = false;
- // No taskbar button: out of view the window must not be reachable by accident (a click on a button that shows
+ // Out of view no taskbar button: the window must not be reachable by accident (a click on a button that shows
// nothing). It comes to the front from the interface: «Apri il browser», «Portalo in primo piano», the login.
+ // On screen it has one (MoveOnScreen), so a minimised window can be brought back.
ShowInTaskbar = false;
Background = new SolidColorBrush(Color.FromRgb(0xF4, 0xF5, 0xF7));
@@ -40,6 +60,8 @@ internal sealed class BrowserWindow : Window
back.Click += (_, _) => BackRequested?.Invoke(this, EventArgs.Empty);
var reload = BarButton("Ricarica", "Ricarica la pagina");
reload.Click += (_, _) => ReloadRequested?.Invoke(this, EventArgs.Empty);
+ var home = BarButton("Pagina iniziale", "Apre la pagina iniziale del sito, o la pagina di accesso se non sei collegato");
+ home.Click += (_, _) => HomeRequested?.Invoke(this, EventArgs.Empty);
_address = new TextBlock
{
VerticalAlignment = VerticalAlignment.Center,
@@ -57,24 +79,30 @@ internal sealed class BrowserWindow : Window
Foreground = new SolidColorBrush(Color.FromRgb(0x5B, 0x63, 0x6E)),
FontFamily = new FontFamily("Segoe UI"),
FontSize = 12,
+ TextTrimming = TextTrimming.CharacterEllipsis,
};
var bar = new DockPanel { Height = BarHeight, LastChildFill = true, Background = new SolidColorBrush(Color.FromRgb(0xFF, 0xFF, 0xFF)) };
DockPanel.SetDock(back, Dock.Left);
DockPanel.SetDock(reload, Dock.Left);
+ DockPanel.SetDock(home, Dock.Left);
DockPanel.SetDock(hint, Dock.Right);
bar.Children.Add(back);
bar.Children.Add(reload);
+ bar.Children.Add(home);
bar.Children.Add(hint);
bar.Children.Add(_address);
- // The page area: WebView2 covers it (its bounds are computed from PageWidth/PageHeight and the DPI).
- var page = new Border { Width = pageWidth, Height = pageHeight, Background = Brushes.White };
+ // The page area: WebView2 covers it (its bounds are computed from PageWidth/PageHeight, the fit and the DPI).
+ _page = new Border { Width = pageWidth, Height = pageHeight, Background = Brushes.White };
var layout = new DockPanel { LastChildFill = true };
DockPanel.SetDock(bar, Dock.Bottom);
layout.Children.Add(bar);
- layout.Children.Add(page);
+ layout.Children.Add(_page);
Content = layout;
+
+ _minimized = new DispatcherTimer(DispatcherPriority.Normal, Dispatcher);
+ _minimized.Tick += (_, _) => MinimizedTooLong();
}
/// Width of the page in device-independent pixels (CSS pixels of the page at zoom 100%).
@@ -82,15 +110,30 @@ internal sealed class BrowserWindow : Window
public int PageHeight { get; }
+ ///
+ /// The zoom the page is shown at: 1, or less when the page and its bar do not fit in the work area of the screen.
+ /// The page keeps its size in CSS pixels whatever the fit (the host zooms WebView2 out by the same factor).
+ ///
+ public double Fit { get; private set; } = 1;
+
+ /// How long the window may stay minimised before it is put out of view as «ho finito» (S2).
+ public TimeSpan MinimizedLimit { get; set; } = TimeSpan.FromMinutes(2);
+
/// Raised by «Indietro».
public event EventHandler? BackRequested;
/// Raised by «Ricarica».
public event EventHandler? ReloadRequested;
- /// Raised when Alberto closes or minimises the window: the owner puts it out of view.
+ /// Raised by «Pagina iniziale».
+ public event EventHandler? HomeRequested;
+
+ /// Raised when Alberto closes the window, or leaves it minimised too long: the owner puts it out of view.
public event EventHandler? DoneRequested;
+ /// Raised when the page area changed size (a new fit): the owner sizes WebView2 again.
+ public event EventHandler? PageAreaChanged;
+
/// The window handle (created on first use).
public IntPtr Handle => new WindowInteropHelper(this).EnsureHandle();
@@ -98,32 +141,68 @@ internal sealed class BrowserWindow : Window
public double Scale => VisualTreeHelper.GetDpi(this).DpiScaleX;
/// Where WebView2 draws, in physical pixels of the client area.
- public System.Drawing.Rectangle PageBounds => new(0, 0, (int)Math.Round(PageWidth * Scale), (int)Math.Round(PageHeight * Scale));
+ public System.Drawing.Rectangle PageBounds => new(0, 0, (int)Math.Round(PageWidth * Fit * Scale), (int)Math.Round(PageHeight * Fit * Scale));
/// True while the window is on a screen, false while it is parked out of view.
public bool IsOnScreen =>
Left < SystemParameters.VirtualScreenLeft + SystemParameters.VirtualScreenWidth
&& Left + ActualWidth > SystemParameters.VirtualScreenLeft;
- /// Shows the address of the page, without query string or fragment (they may carry tokens).
- public void ShowAddress(string? address) => _address.Text = address ?? string.Empty;
+ /// The text the bar shows now (the address, or ).
+ public string AddressText => _address.Text;
- /// Centres the window on the work area of the primary screen.
+ ///
+ /// The zoom at which a page of × plus its bar and the
+ /// window's frame fits in an area of × (all in
+ /// device-independent pixels): 1 when it fits, never below .
+ ///
+ public static double FitFor(double areaWidth, double areaHeight, double pageWidth, double pageHeight, double frameWidth, double frameHeight)
+ {
+ if (pageWidth <= 0 || pageHeight <= 0)
+ {
+ return 1;
+ }
+
+ var byWidth = (areaWidth - frameWidth) / pageWidth;
+ var byHeight = (areaHeight - frameHeight - BarHeight) / pageHeight;
+ var fit = Math.Min(1, Math.Min(byWidth, byHeight));
+ return Math.Max(SmallestFit, Math.Floor(fit * 100) / 100);
+ }
+
+ ///
+ /// Shows the address of the page, without query string or fragment (they may carry tokens); on the empty rest page,
+ /// .
+ ///
+ public void ShowAddress(string? address) =>
+ _address.Text = address is null or "" or "about:blank" ? RestNotice : address;
+
+ ///
+ /// Centres the window on the work area of the primary screen, shrunk to fit it when needed, with its taskbar button.
+ ///
public void MoveOnScreen()
{
var area = SystemParameters.WorkArea;
- var width = ActualWidth > 0 ? ActualWidth : PageWidth;
- var height = ActualHeight > 0 ? ActualHeight : PageHeight + BarHeight;
+ FitTo(area);
+ ShowInTaskbar = true;
+ var width = ActualWidth > 0 ? ActualWidth : PageWidth * Fit;
+ var height = ActualHeight > 0 ? ActualHeight : (PageHeight * Fit) + BarHeight;
Left = area.Left + Math.Max(0, (area.Width - width) / 2);
Top = area.Top + Math.Max(0, (area.Height - height) / 2);
}
///
/// Parks the window just right of every screen: open, «visible» for Windows and for WebView2, out of Alberto's view
- /// (S2). Never Hide() and never minimised.
+ /// (S2), without its taskbar button. Never Hide(), never left minimised.
///
public void MoveOffScreen()
{
+ _minimized.Stop();
+ if (WindowState == WindowState.Minimized)
+ {
+ WindowState = WindowState.Normal;
+ }
+
+ ShowInTaskbar = false;
Left = SystemParameters.VirtualScreenLeft + SystemParameters.VirtualScreenWidth + 64;
Top = SystemParameters.VirtualScreenTop;
}
@@ -132,6 +211,7 @@ internal sealed class BrowserWindow : Window
public void CloseForGood()
{
_allowClose = true;
+ _minimized.Stop();
Close();
}
@@ -151,14 +231,48 @@ internal sealed class BrowserWindow : Window
{
if (WindowState == WindowState.Minimized)
{
- // A minimised window stops painting (S2): back to normal, out of view.
- WindowState = WindowState.Normal;
- DoneRequested?.Invoke(this, EventArgs.Empty);
+ // Minimised Alberto still has it (its taskbar button brings it back), but WebView2 stops painting (S2):
+ // left there too long it counts as closed.
+ _minimized.Interval = MinimizedLimit;
+ _minimized.Stop();
+ _minimized.Start();
+ }
+ else
+ {
+ _minimized.Stop();
}
base.OnStateChanged(e);
}
+ private void MinimizedTooLong()
+ {
+ _minimized.Stop();
+ if (WindowState == WindowState.Minimized)
+ {
+ WindowState = WindowState.Normal;
+ DoneRequested?.Invoke(this, EventArgs.Empty);
+ }
+ }
+
+ private void FitTo(Rect area)
+ {
+ // The frame of the window (title bar and borders) around the page and its bar.
+ var frame = SystemParameters.WindowNonClientFrameThickness;
+ var resize = SystemParameters.WindowResizeBorderThickness;
+ var fit = FitFor(area.Width, area.Height, PageWidth, PageHeight, frame.Left + frame.Right + resize.Left + resize.Right, frame.Top + frame.Bottom + resize.Top + resize.Bottom);
+ if (Math.Abs(fit - Fit) < 0.001)
+ {
+ return;
+ }
+
+ Fit = fit;
+ _page.Width = PageWidth * fit;
+ _page.Height = PageHeight * fit;
+ UpdateLayout();
+ PageAreaChanged?.Invoke(this, EventArgs.Empty);
+ }
+
private static Button BarButton(string text, string tip) => new()
{
Content = text,
diff --git a/src/Febe.Desktop/Browser/WebView2Browser.cs b/src/Febe.Desktop/Browser/WebView2Browser.cs
index 36c8405..a80f3ab 100644
--- a/src/Febe.Desktop/Browser/WebView2Browser.cs
+++ b/src/Febe.Desktop/Browser/WebView2Browser.cs
@@ -52,7 +52,7 @@ internal sealed class WebView2Browser : IFebeBrowser
_options = new BrowserOptions(ProfileDirectory, settings.Width, settings.Height);
Host = new WebView2Host(
ui,
- new WebView2HostOptions(settings.Hosting, settings.AdditionalBrowserArguments, icon, () => context.Tracker.MarkUsed(context.Clock.Now)),
+ new WebView2HostOptions(settings.Hosting, settings.AdditionalBrowserArguments, icon, () => context.Tracker.MarkUsed(context.Clock.Now), context.CurrentStartPage),
context.Log);
Host.BrowserProcessFailed += (_, _) => RequestRestart(null);
}
diff --git a/src/Febe.Desktop/Browser/WebView2Host.cs b/src/Febe.Desktop/Browser/WebView2Host.cs
index 51db2fc..c3692cc 100644
--- a/src/Febe.Desktop/Browser/WebView2Host.cs
+++ b/src/Febe.Desktop/Browser/WebView2Host.cs
@@ -18,7 +18,24 @@ namespace Febe.Desktop.Browser;
/// The switches of S2 ().
/// The icon of the window.
/// Called when Alberto uses the browser and when he is done with it («Riprendi»).
-internal sealed record WebView2HostOptions(BrowserHosting Hosting, string AdditionalBrowserArguments, ImageSource? Icon, Action MarkUsed);
+/// Where «Pagina iniziale» goes: the site's home when connected, the login page otherwise (issue #52).
+internal sealed record WebView2HostOptions(BrowserHosting Hosting, string AdditionalBrowserArguments, ImageSource? Icon, Action MarkUsed, Func? StartPage = null);
+
+/// What the host does when a process of WebView2 fails (issue #52).
+internal enum ProcessFailureResponse
+{
+ /// Nothing: WebView2 recovers by itself (an unresponsive page while Alberto looks at it, a helper process).
+ None,
+
+ /// The whole browser is gone: the owner starts it again.
+ Restart,
+
+ /// The page crashed (or hangs while nobody looks): back to the rest page (spec §6.1).
+ Rest,
+
+ /// The GPU process restarted: the bounds are given again, or the window may stay blank or black.
+ Redraw,
+}
///
/// The browser host of the Windows edition (spec §5, §6.1, §12): WebView2 in the window «Browser di Febe», with its own
@@ -36,6 +53,9 @@ internal sealed record WebView2HostOptions(BrowserHosting Hosting, string Additi
/// «Ho finito»; using and closing it marks the browser as used for «Riprendi».
/// Stopping closes the WebView and waits for its browser process to exit, so the session is on disk (S3);
/// («Scollega») does the same before deleting the profile.
+/// Issue #52: the bounds (and the zoom of a window shrunk to fit the screen) are given again, and WebView2 told of
+/// the window's new place, whenever the window moves on or off screen and after the GPU process restarted; a page that
+/// hangs while Alberto looks at it is left to recover instead of being replaced by the rest page.
/// Threads: every WebView2 object (environment, controller, CoreWebView2, its settings and DevTools
/// receivers) and the window are touched only on the UI thread, through its dispatcher; WebView2 throws on any other
/// thread. Callers on other threads (the composition, the engine) get only plain values captured on the UI thread
@@ -147,12 +167,20 @@ internal sealed class WebView2Host : IBrowserHost
}
window.MoveOnScreen();
+ if (window.WindowState == System.Windows.WindowState.Minimized)
+ {
+ window.WindowState = System.Windows.WindowState.Normal;
+ }
+
window.Activate();
window.Topmost = true;
window.Topmost = false;
// The lease first: once the window is on screen the engine must be still, whatever happens to the focus.
TakeLease();
+
+ // On screen, perhaps shrunk to fit it: WebView2 gets its bounds again and learns where its window is now.
+ UpdateBounds();
try
{
_controller?.MoveFocus(CoreWebView2MoveFocusReason.Programmatic);
@@ -169,9 +197,24 @@ internal sealed class WebView2Host : IBrowserHost
{
_window?.MoveOffScreen();
ReleaseLease();
+ NotifyPositionChanged();
return Task.CompletedTask;
});
+ ///
+ /// What a failed process of WebView2 asks of the host (issue #52). A page that does not answer while Alberto is at
+ /// the window is his to wait for (WebView2 recovers, or he reloads): replacing it with the rest page would turn it
+ /// white under his eyes. Nobody looking, it goes to rest as a crashed page does.
+ ///
+ internal static ProcessFailureResponse ResponseTo(CoreWebView2ProcessFailedKind kind, bool userIsDriving) => kind switch
+ {
+ CoreWebView2ProcessFailedKind.BrowserProcessExited => ProcessFailureResponse.Restart,
+ CoreWebView2ProcessFailedKind.RenderProcessExited => ProcessFailureResponse.Rest,
+ CoreWebView2ProcessFailedKind.RenderProcessUnresponsive => userIsDriving ? ProcessFailureResponse.None : ProcessFailureResponse.Rest,
+ CoreWebView2ProcessFailedKind.GpuProcessExited => ProcessFailureResponse.Redraw,
+ _ => ProcessFailureResponse.None,
+ };
+
///
/// Closes the WebView, waits for its browser process to exit (the profile is free and written), runs
/// — «Scollega» deletes the profile there — and starts it again.
@@ -302,7 +345,14 @@ internal sealed class WebView2Host : IBrowserHost
window.DoneRequested += (_, _) => Done();
window.BackRequested += (_, _) => UserNavigation(core => core.GoBack(), core => core.CanGoBack);
window.ReloadRequested += (_, _) => UserNavigation(core => core.Reload(), _ => true);
+ window.HomeRequested += (_, _) => UserNavigation(core => core.Navigate(_settings.StartPage!()), _ => _settings.StartPage is not null);
window.DpiChanged += (_, _) => UpdateBounds();
+ window.PageAreaChanged += (_, _) => UpdateBounds();
+
+ // The raw controller does not follow its parent by itself: popups (lists of a
public interface IBrowserWindow
{
- /// True when the browser is a window of its own (Windows): «Apri il browser» calls .
+ ///
+ /// True when the browser is a window of its own (Windows): «Apri il browser» asks the connection to bring it to the
+ /// front (IConnectionService.ShowBrowserAsync), and leaving a Febe page leaves the window as it is.
+ ///
bool IsSeparateWindow { get; }
-
- /// Brings the browser window to the front (Windows). The engine stays still while Alberto uses it.
- Task ShowAsync(CancellationToken ct);
}
/// No browser window (Docker uses the Browser page; the demo has no browser).
public sealed class NoBrowserWindow : IBrowserWindow
{
public bool IsSeparateWindow => false;
-
- public Task ShowAsync(CancellationToken ct) => Task.CompletedTask;
}
diff --git a/src/Febe.Web/wwwroot/icone/house.svg b/src/Febe.Web/wwwroot/icone/house.svg
new file mode 100644
index 0000000..12d0c4e
--- /dev/null
+++ b/src/Febe.Web/wwwroot/icone/house.svg
@@ -0,0 +1,16 @@
+
+
diff --git a/src/Febe.Web/wwwroot/js/core/shell.js b/src/Febe.Web/wwwroot/js/core/shell.js
index 9866cae..003deef 100644
--- a/src/Febe.Web/wwwroot/js/core/shell.js
+++ b/src/Febe.Web/wwwroot/js/core/shell.js
@@ -248,7 +248,9 @@ function renderBanner(frame, state) {
}
},
}, icon('rotate-cw'), t('arresto.riprendi'));
- const open = h('button.btn.primo', { type: 'button', onclick: openBrowser }, icon('app-window'), t('arresto.apriBrowser'));
+ // After a disconnection the browser opens on the login page (issue #52); after a verification it stays as it is.
+ const disconnected = Boolean(state.connection && state.connection.state === 'disconnected');
+ const open = h('button.btn.primo', { type: 'button', onclick: () => openBrowser({ login: disconnected }) }, icon('app-window'), t('arresto.apriBrowser'));
const box = h(`div.arresto${isError ? '' : '.ambra'}`, { role: 'alert' },
icon(isError ? 'octagon-alert' : 'triangle-alert', 'l'),
h('div.testo', h('b', banner.title), h('span', banner.message)),
@@ -257,18 +259,22 @@ function renderBanner(frame, state) {
fill(frame.bannerSlot, box);
}
-/** «Apri il browser»: on Windows the window comes to the front; in Docker the Browser page with the remote view. */
-export async function openBrowser() {
+/**
+ * «Apri il browser»: on Windows the window comes to the front; in Docker the Browser page with the remote view. A
+ * browser at rest opens its start page; with login (the red strip of a disconnection) the login page.
+ */
+export async function openBrowser({ login = false } = {}) {
+ const openLogin = login === true;
if (caps().browserWindow) {
try {
- const result = await api('/api/browser/show', { method: 'POST' });
+ const result = await api('/api/browser/show', { method: 'POST', body: { openLogin } });
toast(result.message);
refreshEngine();
} catch (error) {
showError(error);
}
} else {
- navigate('/browser');
+ navigate(openLogin ? '/browser?accesso=1' : '/browser');
}
}
diff --git a/src/Febe.Web/wwwroot/js/pages/activity.js b/src/Febe.Web/wwwroot/js/pages/activity.js
index 6147f45..c7b351a 100644
--- a/src/Febe.Web/wwwroot/js/pages/activity.js
+++ b/src/Febe.Web/wwwroot/js/pages/activity.js
@@ -99,7 +99,7 @@ function drawActions(page, state) {
}, icon('pause'), h('span.testo-btn', t('attivita.pausa')));
page.actions(
first,
- h('button.btn', { type: 'button', onclick: openBrowser, 'aria-label': t('attivita.apriBrowser') }, icon('app-window'), h('span.testo-btn', t('attivita.apriBrowser'))),
+ h('button.btn', { type: 'button', onclick: () => openBrowser(), 'aria-label': t('attivita.apriBrowser') }, icon('app-window'), h('span.testo-btn', t('attivita.apriBrowser'))),
diagnosticsButton(),
);
}
diff --git a/src/Febe.Web/wwwroot/js/pages/browser.js b/src/Febe.Web/wwwroot/js/pages/browser.js
index 79a11de..41cf131 100644
--- a/src/Febe.Web/wwwroot/js/pages/browser.js
+++ b/src/Febe.Web/wwwroot/js/pages/browser.js
@@ -1,7 +1,9 @@
// Browser (spec §10.3 «Apri il browser»; mockup 10 without the steps column): in Docker the remote view of the
// server's browser and «Ho finito»; on Windows the browser is its own window. While Alberto uses the browser the
// engine is still; «Ho finito» lets «Riprendi» become active after a verification. Leaving the page without «Ho finito»
-// (another page, a reload, closing the tab) gives the browser back, like «Annulla».
+// (another page, a reload, closing the tab) gives the browser back, like «Annulla» (on Windows the window stays as it
+// is until Alberto closes it). A browser at rest opens its start page; «?accesso=1» (the red strip of a disconnection)
+// opens the login page.
import { api } from '../core/api.js';
import { caps } from '../core/context.js';
@@ -24,7 +26,8 @@ export default {
}
if (page.signal.aborted) return;
const lease = drivingLease(page);
- lease.begin(false);
+ const login = new URLSearchParams(location.search).get('accesso') === '1';
+ lease.begin(login);
const message = h('div', { 'aria-live': 'polite' });
const done = async () => {
const result = await finishDriving();
@@ -40,7 +43,7 @@ export default {
h('div.destra', h('button.btn.primo.grande', { type: 'button', onclick: done }, t('impostazioni.collegamento.hoFinito')))));
fill(page.body, h('div.pagina-browser',
message,
- windows ? windowPanel() : remoteView(page, { url: status && status.currentUrl, login: status && status.state === 'notConnected' }).element,
+ windows ? windowPanel() : remoteView(page, { url: status && status.currentUrl, login: login || (status && status.state === 'notConnected') }).element,
passwordNote(windows)));
},
};
diff --git a/src/Febe.Web/wwwroot/js/pages/connection.js b/src/Febe.Web/wwwroot/js/pages/connection.js
index 752312d..6f54b60 100644
--- a/src/Febe.Web/wwwroot/js/pages/connection.js
+++ b/src/Febe.Web/wwwroot/js/pages/connection.js
@@ -40,15 +40,16 @@ export async function beginDriving(openLogin) {
/**
* The browser as a page uses it (spec §4.1, §10.3: the engine is still only while Alberto uses the browser). begin()
* takes it; «Ho finito», «Annulla» and «Scollega» give it back on the server, and the page calls settled(). Leaving the
- * page in any other way — another page, a reload, closing the tab — counts as «Annulla»: the browser goes back to the
- * empty page and the engine may work again.
+ * page in any other way — another page, a reload, closing the tab — gives it back too: in Docker like «Annulla» (the
+ * browser goes back to the empty page and the engine may work again); on Windows the window «Browser di Febe» stays as
+ * it is, on screen until Alberto closes it (issue #52), and only the page's hold ends.
*/
export function drivingLease(page) {
let held = false;
const release = (keepalive) => {
if (!held) return;
held = false;
- releasing = api('/api/connection/cancel', { method: 'POST', keepalive }).then(() => {}, () => {});
+ releasing = api('/api/connection/cancel', { method: 'POST', body: { pageLeft: true }, keepalive }).then(() => {}, () => {});
};
const onHide = () => release(true);
window.addEventListener('pagehide', onHide);
diff --git a/src/Febe.Web/wwwroot/js/pages/remote-view.js b/src/Febe.Web/wwwroot/js/pages/remote-view.js
index 8dcb2a4..0a33cfb 100644
--- a/src/Febe.Web/wwwroot/js/pages/remote-view.js
+++ b/src/Febe.Web/wwwroot/js/pages/remote-view.js
@@ -11,6 +11,14 @@ import { label } from '../core/ui.js';
const BUTTONS = ['left', 'middle', 'right'];
const MAC = /Mac|iPhone|iPad/.test(navigator.platform || '');
+/** How long the view waits for the first image before saying that none comes (issue #52). */
+const FIRST_FRAME_WAIT = 8000;
+
+/** The empty page the browser rests on: the bar says so instead of showing an address. */
+function isRest(url) {
+ return !url || url === 'about:blank';
+}
+
function altGraph(e) {
return Boolean(e.getModifierState && e.getModifierState('AltGraph'));
}
@@ -44,8 +52,9 @@ export function remoteView(page, { url = null, login = false } = {}) {
const address = h('span.dati');
const back = h('button.btn.nudo.solo', { type: 'button', 'aria-label': t('browser.indietro'), title: t('browser.indietro'), onclick: () => send({ type: 'navigate', action: 'back' }) }, icon('arrow-left'));
const reload = h('button.btn.nudo.solo', { type: 'button', 'aria-label': t('browser.ricarica'), title: t('browser.ricarica'), onclick: () => send({ type: 'navigate', action: 'reload' }) }, icon('rotate-cw'));
+ const home = h('button.btn.nudo.solo', { type: 'button', 'aria-label': t('browser.paginaIniziale'), title: t('browser.paginaInizialeAiuto'), onclick: () => send({ type: 'navigate', action: 'home' }) }, icon('house'));
const bar = h('div.vista-barra',
- back, reload,
+ back, reload, home,
h('div.vista-indirizzo', { 'aria-label': t('browser.indirizzo') }, icon('lock', 's'), address),
label(t('browser.vista')));
const canvas = h('canvas.vista-schermo', { tabindex: '0', 'aria-label': t('browser.schermo'), hidden: true, width: '1280', height: '900' });
@@ -56,10 +65,14 @@ export function remoteView(page, { url = null, login = false } = {}) {
let socket = null;
let closed = false;
let frames = 0;
+ // Each connection has its number: what a replaced socket still says is ignored.
+ let generation = 0;
+ let waiting = null;
function showAddress(value) {
- if (!value) {
- address.replaceChildren();
+ if (isRest(value)) {
+ // Never a white area without a word (issue #52): the bar says the browser is resting, «Pagina iniziale» leaves.
+ fill(address, h('span.muto', t('browser.aRiposo')));
return;
}
const clean = String(value).replace(/^https?:\/\//, '');
@@ -85,16 +98,41 @@ export function remoteView(page, { url = null, login = false } = {}) {
status.hidden = false;
}
+ /** No image from the browser after a while (the view is open): said plainly, with «Riprova». */
+ function noImage() {
+ canvas.hidden = true;
+ fill(status, h('div.vista-segnaposto',
+ icon('image', 'l'),
+ h('p', t('browser.nessunaImmagine')),
+ h('button.btn', { type: 'button', onclick: connect }, icon('refresh-cw', 's'), t('browser.riprova'))));
+ status.hidden = false;
+ }
+
function send(message) {
if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));
}
+ function stopWaiting() {
+ if (waiting) clearTimeout(waiting);
+ waiting = null;
+ }
+
function connect() {
if (closed) return;
if (caps().demo) {
placeholder();
return;
}
+ generation += 1;
+ const mine = generation;
+ stopWaiting();
+ if (socket) {
+ // «Riprova» on an open view: the old socket goes, its close says nothing.
+ const old = socket;
+ socket = null;
+ old.close();
+ }
+ frames = 0;
fill(status, h('div.vista-segnaposto', icon('hourglass', 'l'), h('p', t('browser.collegamento'))));
status.hidden = false;
const scheme = location.protocol === 'https:' ? 'wss' : 'ws';
@@ -104,8 +142,13 @@ export function remoteView(page, { url = null, login = false } = {}) {
failure();
return;
}
+ waiting = setTimeout(() => {
+ waiting = null;
+ if (mine === generation && !closed && frames === 0) noImage();
+ }, FIRST_FRAME_WAIT);
socket.binaryType = 'blob';
socket.addEventListener('message', async (e) => {
+ if (mine !== generation) return;
if (typeof e.data === 'string') {
try {
const meta = JSON.parse(e.data);
@@ -127,6 +170,7 @@ export function remoteView(page, { url = null, login = false } = {}) {
bitmap.close();
frames += 1;
if (frames === 1) {
+ stopWaiting();
canvas.hidden = false;
status.hidden = true;
}
@@ -135,6 +179,8 @@ export function remoteView(page, { url = null, login = false } = {}) {
}
});
socket.addEventListener('close', () => {
+ if (mine !== generation) return;
+ stopWaiting();
socket = null;
if (!closed) failure();
});
@@ -220,6 +266,7 @@ export function remoteView(page, { url = null, login = false } = {}) {
function close() {
closed = true;
+ stopWaiting();
document.removeEventListener('paste', onPaste);
window.removeEventListener('blur', releaseAll);
if (socket) socket.close();
diff --git a/src/Febe.Web/wwwroot/testi/it.json b/src/Febe.Web/wwwroot/testi/it.json
index d0fcc17..8fbace2 100644
--- a/src/Febe.Web/wwwroot/testi/it.json
+++ b/src/Febe.Web/wwwroot/testi/it.json
@@ -832,6 +832,10 @@
"segnapostoAccesso": "Qui compare la vera pagina di accesso di Instagram, caricata dal sito. Febe non la ridisegna e non la imita.",
"indietro": "Indietro",
"ricarica": "Ricarica",
+ "paginaIniziale": "Pagina iniziale",
+ "paginaInizialeAiuto": "Pagina iniziale: la home del sito se sei collegato, altrimenti la pagina di accesso",
+ "aRiposo": "Il browser è a riposo su una pagina vuota: premi «Pagina iniziale».",
+ "nessunaImmagine": "Nessuna immagine dal browser: la vista è aperta, ma la pagina non arriva. Premi «Riprova»; se resta così, guarda il registro.",
"indirizzo": "Indirizzo della pagina",
"collegamento": "Collegamento alla vista remota…",
"nonRisponde": "La vista remota non risponde: il browser di Febe non è raggiungibile in questo momento.",
diff --git a/tests/Febe.Tests.Windows/BrowserWindowTests.cs b/tests/Febe.Tests.Windows/BrowserWindowTests.cs
new file mode 100644
index 0000000..4cfada2
--- /dev/null
+++ b/tests/Febe.Tests.Windows/BrowserWindowTests.cs
@@ -0,0 +1,183 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using Febe.Browser.Cdp;
+using Febe.Desktop.Browser;
+using Febe.SitoDiProva;
+using Febe.Tests.Windows.Support;
+using Microsoft.Web.WebView2.Core;
+
+namespace Febe.Tests.Windows;
+
+///
+/// The decisions of the window «Browser di Febe» that need no browser (Gitea issue #52): what a failed process of
+/// WebView2 asks of the host, and how much a page is shrunk to fit a small screen.
+///
+[TestClass]
+public sealed class BrowserWindowDecisionTests
+{
+ [TestMethod]
+ public void AFailedProcessIsAnsweredByWhatItBroke()
+ {
+ Assert.AreEqual(ProcessFailureResponse.Restart, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.BrowserProcessExited, userIsDriving: false));
+ Assert.AreEqual(ProcessFailureResponse.Restart, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.BrowserProcessExited, userIsDriving: true));
+ Assert.AreEqual(ProcessFailureResponse.Rest, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.RenderProcessExited, userIsDriving: true), "a crashed page is gone anyway");
+ Assert.AreEqual(ProcessFailureResponse.Rest, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.RenderProcessUnresponsive, userIsDriving: false));
+ Assert.AreEqual(ProcessFailureResponse.None, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.RenderProcessUnresponsive, userIsDriving: true), "never white under Alberto's eyes");
+ Assert.AreEqual(ProcessFailureResponse.Redraw, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.GpuProcessExited, userIsDriving: false));
+ Assert.AreEqual(ProcessFailureResponse.Redraw, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.GpuProcessExited, userIsDriving: true));
+ Assert.AreEqual(ProcessFailureResponse.None, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.UtilityProcessExited, userIsDriving: false));
+ Assert.AreEqual(ProcessFailureResponse.None, WebView2Host.ResponseTo(CoreWebView2ProcessFailedKind.FrameRenderProcessExited, userIsDriving: true));
+ }
+
+ [TestMethod]
+ public void APageThatDoesNotFitIsShrunkButNeverBelowTheSmallestFit()
+ {
+ // 1280×900 and its bar, in a frame of 16×39.
+ Assert.AreEqual(1, BrowserWindow.FitFor(1920, 1040, 1280, 900, 16, 39), "a full HD screen: as it is");
+ Assert.AreEqual(0.72, BrowserWindow.FitFor(1366, 728, 1280, 900, 16, 39), 1e-9, "a small laptop: by the height");
+ Assert.AreEqual(0.78, BrowserWindow.FitFor(1024, 1200, 1280, 900, 16, 39), 1e-9, "a narrow screen: by the width");
+ Assert.AreEqual(BrowserWindow.SmallestFit, BrowserWindow.FitFor(400, 300, 1280, 900, 16, 39));
+ Assert.AreEqual(1, BrowserWindow.FitFor(1366, 728, 0, 0, 16, 39), "no page size: nothing to fit");
+ }
+}
+
+///
+/// The window «Browser di Febe» on a real Windows (Gitea issue #52): on screen it has its taskbar button and says when
+/// the page is the empty rest page, «Pagina iniziale» opens the start page, and a minimised window keeps Alberto at the
+/// wheel until it has been minimised too long. The window comes on screen for a moment.
+///
+[TestClass]
+public sealed class BrowserWindowTests
+{
+ public TestContext TestContext { get; set; } = null!;
+
+ [TestInitialize]
+ public void RequireWebView2() => WebView2Runtime.Require();
+
+ [TestMethod]
+ [Timeout(120_000, CooperativeCancellation = true)]
+ public async Task OnScreenTheWindowHasItsTaskbarButtonAndSaysWhenItRests()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var site = await TestSite.StartAsync(new TestSiteOptions(), ct);
+ var start = site.Url("/benvenuto");
+ await using var bed = await BrowserBed.CreateAsync("finestra-pagina-iniziale", startPage: () => start);
+ await bed.StartAsync(ct);
+ var window = await bed.OnUiAsync(() => bed.Browser.Host.Window) ?? throw new AssertFailedException("nessuna finestra");
+ Assert.IsFalse(await bed.OnUiAsync(() => window.ShowInTaskbar), "out of view, no taskbar button");
+
+ await Task.Run(() => bed.Browser.ShowToUserAsync(ct), ct);
+ Assert.IsTrue(await bed.OnUiAsync(() => window.IsOnScreen));
+ Assert.IsTrue(await bed.OnUiAsync(() => window.ShowInTaskbar), "on screen, a taskbar button");
+ Assert.AreEqual(BrowserWindow.RestNotice, await bed.OnUiAsync(() => window.AddressText), "the empty page says what it is");
+ Assert.IsGreaterThan(0, await bed.OnUiAsync(() => window.Fit));
+
+ // «Pagina iniziale»: Alberto's own navigation, to the start page the composition gives.
+ await bed.OnUiAsync(() =>
+ {
+ Button(window, "Pagina iniziale").RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
+ return true;
+ });
+ var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(30);
+ while (await bed.OnUiAsync(() => window.AddressText) != start)
+ {
+ Assert.IsLessThan(deadline, DateTime.UtcNow, "la pagina iniziale nella barra: " + bed.Lines.Text);
+ await Task.Delay(100, ct);
+ }
+
+ Assert.AreEqual(start, await Task.Run(() => bed.Browser.Cdp.GetMainFrameUrlAsync(ct), ct));
+
+ await Task.Run(() => bed.Browser.HideFromUserAsync(ct), ct);
+ Assert.IsFalse(await bed.OnUiAsync(() => window.ShowInTaskbar), "out of view again, no taskbar button");
+ }
+
+ [TestMethod]
+ [Timeout(120_000, CooperativeCancellation = true)]
+ public async Task AMinimisedWindowKeepsAlbertoAtTheWheelUntilItIsMinimisedTooLong()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = await BrowserBed.CreateAsync("finestra-ridotta");
+ await bed.StartAsync(ct);
+ var window = await bed.OnUiAsync(() => bed.Browser.Host.Window) ?? throw new AssertFailedException("nessuna finestra");
+ await bed.OnUiAsync(() => window.MinimizedLimit = TimeSpan.FromSeconds(1));
+
+ await Task.Run(() => bed.Browser.ShowToUserAsync(ct), ct);
+ await bed.OnUiAsync(() => window.WindowState = WindowState.Minimized);
+ Assert.IsTrue(bed.Browser.UserIsDriving, "minimised is not «ho finito»: its taskbar button brings it back");
+ Assert.IsTrue(await bed.OnUiAsync(() => window.ShowInTaskbar));
+
+ // Left there: restored and put out of view, as if closed (S2: never minimised for long).
+ await bed.WaitUntilAsync(() => !bed.Browser.UserIsDriving, TimeSpan.FromSeconds(15), "la fine della guida dopo la finestra ridotta a icona", ct);
+ Assert.AreEqual(WindowState.Normal, await bed.OnUiAsync(() => window.WindowState));
+ Assert.IsFalse(await bed.OnUiAsync(() => window.IsOnScreen));
+ Assert.IsFalse(await bed.OnUiAsync(() => window.ShowInTaskbar));
+
+ // Brought back before the limit, it stays Alberto's.
+ await bed.OnUiAsync(() => window.MinimizedLimit = TimeSpan.FromMinutes(2));
+ await Task.Run(() => bed.Browser.ShowToUserAsync(ct), ct);
+ await bed.OnUiAsync(() => window.WindowState = WindowState.Minimized);
+ await bed.OnUiAsync(() => window.WindowState = WindowState.Normal);
+ await Task.Delay(1500, ct);
+ Assert.IsTrue(bed.Browser.UserIsDriving);
+ Assert.AreEqual(CdpPageExtensions.RestUrl, await Task.Run(() => bed.Browser.Cdp.GetMainFrameUrlAsync(ct), ct));
+ await Task.Run(() => bed.Browser.HideFromUserAsync(ct), ct);
+ }
+
+ [TestMethod]
+ [Timeout(240_000, CooperativeCancellation = true)]
+ public async Task LeavingThePageOfFebeLeavesTheWindowOnScreenWithItsPage()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = await DesktopBed.StartAsync("finestra-resta", autoLogin: false, ct);
+ await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(120), ct);
+ var connection = bed.App.Connection!;
+ var browser = bed.Browser;
+ var window = await bed.Ui.InvokeAsync(() => browser.Host.Window) ?? throw new AssertFailedException("nessuna finestra");
+
+ // «Usa il browser» on the rest page, not connected: the login page of the test site, never a white window.
+ await connection.BeginUserDrivingAsync(openLogin: false, ct);
+ var opened = (await connection.GetStatusAsync(ct)).CurrentUrl;
+ StringAssert.StartsWith(opened, bed.Site.Url("/benvenuto"));
+ Assert.IsTrue(await bed.Ui.InvokeAsync(() => window.IsOnScreen));
+
+ // The page of Febe goes (another page, the tab closed): the window stays, with its page and the engine still.
+ await connection.ReleaseAsync(ct);
+ await Task.Delay(1500, ct);
+ Assert.IsTrue(await bed.Ui.InvokeAsync(() => window.IsOnScreen), "still on screen");
+ Assert.IsTrue(browser.UserIsDriving, "the window on screen holds the engine");
+ Assert.AreEqual(opened, (await connection.GetStatusAsync(ct)).CurrentUrl, "its page as it was");
+ Assert.IsTrue(bed.Lines.Any("Pagina di Febe lasciata: la finestra del browser resta com'è finché non la chiudi."), bed.Lines.Text);
+
+ // Closed with its X: out of view, the engine may work again.
+ await bed.Ui.InvokeAsync(() =>
+ {
+ window.Close();
+ return true;
+ });
+ await bed.WaitUntilAsync(() => Task.FromResult(!browser.UserIsDriving), TimeSpan.FromSeconds(10), "la fine della guida dopo la chiusura", ct);
+ Assert.IsFalse(await bed.Ui.InvokeAsync(() => window.IsOnScreen));
+ Assert.IsFalse(bed.Lines.Any("ERRORE"), bed.Lines.Text);
+ }
+
+ private static Button Button(DependencyObject root, string text) =>
+ FindOrNull(root, text) ?? throw new AssertFailedException($"Nessun pulsante «{text}» nella finestra.");
+
+ private static Button? FindOrNull(DependencyObject root, string text)
+ {
+ foreach (var child in LogicalTreeHelper.GetChildren(root).OfType())
+ {
+ if (child is Button { Content: string content } button && content == text)
+ {
+ return button;
+ }
+
+ if (FindOrNull(child, text) is { } found)
+ {
+ return found;
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/tests/Febe.Tests.Windows/Support/BrowserBed.cs b/tests/Febe.Tests.Windows/Support/BrowserBed.cs
index 4861f03..bc96fe1 100644
--- a/tests/Febe.Tests.Windows/Support/BrowserBed.cs
+++ b/tests/Febe.Tests.Windows/Support/BrowserBed.cs
@@ -42,7 +42,10 @@ internal sealed class BrowserBed : IAsyncDisposable
public WebView2Browser Browser { get; }
- public static async Task CreateAsync(string name, BrowserHosting hosting = BrowserHosting.Window)
+ /// Prefix of the temporary folder.
+ /// How WebView2 draws (S2).
+ /// Where «Pagina iniziale» goes; null: the login page of the options.
+ public static async Task CreateAsync(string name, BrowserHosting hosting = BrowserHosting.Window, Func? startPage = null)
{
var folder = new TestFolder(name);
var ui = await UiThread.StartAsync();
@@ -53,7 +56,7 @@ internal sealed class BrowserBed : IAsyncDisposable
var database = await FebeDatabase.OpenAsync(data.Root);
var options = new FebeAppOptions { DataFolder = data.Root, LibraryFolder = folder.Combine("libreria") };
var tracker = new BrowserUseTracker();
- var context = new FebePlatformContext(options, data, database, clock, log, tracker);
+ var context = new FebePlatformContext(options, data, database, clock, log, tracker, startPage);
var settings = new WebView2BrowserSettings(data.BrowserProfile, 1280, 900, hosting, BrowserArguments.ForWebView2());
// Built off the UI thread, as DesktopPlatform.CreateBrowserAsync does after its awaits.
diff --git a/tests/Febe.Tests/Browser/RemoteViewDuringNavigationTests.cs b/tests/Febe.Tests/Browser/RemoteViewDuringNavigationTests.cs
index 5dd2d0f..5295d9b 100644
--- a/tests/Febe.Tests/Browser/RemoteViewDuringNavigationTests.cs
+++ b/tests/Febe.Tests/Browser/RemoteViewDuringNavigationTests.cs
@@ -64,7 +64,8 @@ public sealed class RemoteViewDuringNavigationTests
var notes = new ConcurrentQueue();
var log = new DelegateBrowserLog((level, message, _) =>
{
- if (level == BrowserLogLevel.Debug)
+ // The retry note is written at Info since issue #52 (it reaches the registro).
+ if (level is BrowserLogLevel.Debug or BrowserLogLevel.Information)
{
notes.Enqueue(message);
}
diff --git a/tests/Febe.Tests/Browser/RemoteViewFramesTests.cs b/tests/Febe.Tests/Browser/RemoteViewFramesTests.cs
new file mode 100644
index 0000000..0430b94
--- /dev/null
+++ b/tests/Febe.Tests/Browser/RemoteViewFramesTests.cs
@@ -0,0 +1,130 @@
+using System.Diagnostics;
+using Febe.Browser.Cdp;
+using Febe.Browser.RemoteView;
+using Febe.Tests.Browser.TestSupport;
+
+namespace Febe.Tests.Browser;
+
+///
+/// The remote view that stayed white (Gitea issue #52), on a real Chromium on Xvfb and the local test site: a page that
+/// does not move still shows itself, and the frames keep coming when the page changes renderer (another site, the rest
+/// page and back). Only in the Linux CI; never Instagram.
+///
+[TestClass]
+[DoNotParallelize]
+public sealed class RemoteViewFramesTests
+{
+ public TestContext TestContext { get; set; } = null!;
+
+ [TestInitialize]
+ public void RequireBrowser()
+ {
+ if (RealBrowser.UnavailableReason() is { } reason)
+ {
+ Assert.Inconclusive(reason);
+ }
+ }
+
+ [TestMethod]
+ [Timeout(120_000, CooperativeCancellation = true)]
+ public async Task AStillPageAndTheRestPageShowAPictureWithinFiveSeconds()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var browser = await RealBrowser.StartAsync();
+ var cdp = browser.Cdp;
+ var opened = await cdp.NavigateAsync(browser.Site.Url("/accesso"), ct);
+ Assert.IsTrue(opened.Succeeded, opened.ErrorText);
+ await cdp.WaitForLoadAsync(new Febe.Core.Abstractions.SystemClock(), TimeSpan.FromSeconds(15), ct);
+
+ var view = new RemoteViewSession(cdp, browser.Host.UserDriving);
+ try
+ {
+ await view.StartAsync(new ScreencastOptions(Quality: 60, MaxWidth: 1280, MaxHeight: 900, Watchdog: ScreencastWatchdog.Default), ct);
+ Assert.IsTrue(await PictureAfterAsync(view.Screencast, null, TimeSpan.FromSeconds(5), ct), "a picture of the login page");
+
+ var last = view.Screencast.LastFrame;
+ var rest = await cdp.RestAsync(ct);
+ Assert.IsTrue(rest.Succeeded, rest.ErrorText);
+ Assert.IsTrue(await PictureAfterAsync(view.Screencast, last, TimeSpan.FromSeconds(5), ct), "a picture of the rest page too");
+ }
+ finally
+ {
+ await view.DisposeAsync();
+ }
+ }
+
+ [TestMethod]
+ [Timeout(180_000, CooperativeCancellation = true)]
+ public async Task FramesKeepComingWhenThePageChangesRenderer()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var browser = await RealBrowser.StartAsync();
+ var cdp = browser.Cdp;
+ var first = await cdp.NavigateAsync(browser.Site.Url("/animata"), ct);
+ Assert.IsTrue(first.Succeeded, first.ErrorText);
+
+ var view = new RemoteViewSession(cdp, browser.Host.UserDriving);
+ try
+ {
+ await view.StartAsync(new ScreencastOptions(Quality: 60, MaxWidth: 1280, MaxHeight: 900, Watchdog: ScreencastWatchdog.Default), ct);
+ Assert.IsTrue(await FramesAfterAsync(view.Screencast, ct), "frames of the animated page");
+
+ foreach (var (address, moving) in new[]
+ {
+ (browser.Site.LocalhostUrl("/animata"), true),
+ ("about:blank", false),
+ (browser.Site.Url("/animata"), true),
+ })
+ {
+ var last = view.Screencast.LastFrame;
+ var watch = Stopwatch.StartNew();
+ var navigated = await cdp.NavigateAsync(address, ct);
+ Assert.IsTrue(navigated.Succeeded, $"{address}: {navigated.ErrorText}");
+ var shown = moving
+ ? await FramesAfterAsync(view.Screencast, ct)
+ : await PictureAfterAsync(view.Screencast, last, TimeSpan.FromSeconds(5), ct);
+ TestContext.WriteLine($"{address}: {(shown ? "immagini" : "niente")} dopo {watch.ElapsedMilliseconds} ms, riavvii {view.Screencast.Restarts}.");
+ Assert.IsTrue(shown, $"{address}: the view is not white");
+ }
+ }
+ finally
+ {
+ await view.DisposeAsync();
+ }
+ }
+
+ /// A frame or a still picture other than , within .
+ private static async Task PictureAfterAsync(ScreencastSession screencast, ScreencastFrame? last, TimeSpan timeout, CancellationToken ct)
+ {
+ var deadline = Stopwatch.StartNew();
+ while (deadline.Elapsed < timeout)
+ {
+ if (screencast.LastFrame is { Jpeg: [0xFF, 0xD8, ..] } frame && !ReferenceEquals(frame, last))
+ {
+ return true;
+ }
+
+ await Task.Delay(50, ct);
+ }
+
+ return false;
+ }
+
+ /// A few real frames of the screencast (not still pictures) after now, within ten seconds.
+ private static async Task FramesAfterAsync(ScreencastSession screencast, CancellationToken ct)
+ {
+ var before = screencast.FramesReceived;
+ var deadline = Stopwatch.StartNew();
+ while (deadline.Elapsed < TimeSpan.FromSeconds(10))
+ {
+ if (screencast.FramesReceived >= before + 3)
+ {
+ return true;
+ }
+
+ await Task.Delay(50, ct);
+ }
+
+ return false;
+ }
+}
diff --git a/tests/Febe.Tests/Browser/ScreencastWatchdogTests.cs b/tests/Febe.Tests/Browser/ScreencastWatchdogTests.cs
new file mode 100644
index 0000000..dadfa73
--- /dev/null
+++ b/tests/Febe.Tests/Browser/ScreencastWatchdogTests.cs
@@ -0,0 +1,336 @@
+using System.Collections.Concurrent;
+using System.Text.Json.Nodes;
+using Febe.Browser.Cdp;
+using Febe.Browser.Diagnostics;
+using Febe.Browser.RemoteView;
+using Febe.Core.Abstractions;
+using Febe.Tests.Browser.TestSupport;
+
+namespace Febe.Tests.Browser;
+
+///
+/// The frames' watchdog of the remote view (Gitea issue #52), without a browser: a lost acknowledgement, a page that
+/// does not repaint and a new document loaded without frames must never leave the view white and silent. The clock
+/// moves only when the test says so, one look of the watchdog at a time.
+///
+[TestClass]
+public sealed class ScreencastWatchdogTests
+{
+ private static readonly ScreencastWatchdog Watchdog = new(TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(250), TimeSpan.FromSeconds(30));
+
+ public TestContext TestContext { get; set; } = null!;
+
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task ALostAcknowledgementIsFollowedByARestartAndTheFramesComeBack()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed(lostAcks: true);
+ await bed.StartAsync(ct);
+ bed.Frame();
+ Assert.AreEqual(1, bed.Starts);
+
+ // The ack was lost: Chromium sends nothing more. Two seconds later the frames are started again.
+ await bed.StepAsync(TimeSpan.FromSeconds(2.25), ct);
+
+ Assert.AreEqual(1, bed.Session.Restarts);
+ Assert.AreEqual(2, bed.Starts, "a new screencast session");
+ var methods = bed.Cdp.Sent.Select(c => c.Method).Where(m => m is "Page.stopScreencast" or "Page.startScreencast").ToList();
+ CollectionAssert.AreEqual(new[] { "Page.startScreencast", "Page.stopScreencast", "Page.startScreencast" }, methods);
+ Assert.IsTrue(bed.Info.Contains("Vista remota: nessun fotogramma da 2 s, riavvio dei fotogrammi."), bed.AllLines);
+
+ // Frames flow again: said once, at Info.
+ for (var i = 0; i < ScreencastWatchdog.FlowingFrames; i++)
+ {
+ bed.Frame();
+ }
+
+ Assert.IsTrue(bed.Info.Any(l => l.StartsWith("Vista remota: fotogrammi di nuovo in arrivo, dopo ", StringComparison.Ordinal)), bed.AllLines);
+ Assert.AreEqual(1 + ScreencastWatchdog.FlowingFrames, bed.Session.FramesReceived);
+
+ // The stop is the last word: no start after it.
+ await bed.Session.StopAsync(ct);
+ Assert.AreEqual("Page.stopScreencast", bed.Cdp.Sent.Last(c => c.Method.Contains("Screencast", StringComparison.Ordinal) && c.Method != "Page.screencastFrameAck").Method);
+ }
+
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task APageThatNeverSendsAFrameGetsAStillPictureOfItself()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed(screenshot: Jpeg(800, 600));
+ await bed.StartAsync(ct);
+
+ await bed.StepAsync(TimeSpan.FromSeconds(2.25), ct);
+
+ var still = bed.Session.LastFrame;
+ Assert.IsNotNull(still, "something to show");
+ Assert.IsTrue(still.Still);
+ Assert.AreEqual(800, still.DeviceWidth, "the size written in the picture");
+ Assert.AreEqual(600, still.DeviceHeight);
+ Assert.AreEqual(0, bed.Session.FramesReceived, "a still picture is not a frame of the screencast");
+ Assert.AreEqual(1, bed.Cdp.Sent.Count(c => c.Method == "Page.captureScreenshot"));
+
+ using var read = CancellationTokenSource.CreateLinkedTokenSource(ct);
+ read.CancelAfter(TimeSpan.FromSeconds(5));
+ await foreach (var frame in bed.Session.ReadFramesAsync(read.Token))
+ {
+ Assert.IsTrue(frame.Still, "the reader gets it like any frame");
+ break;
+ }
+ }
+
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task ANewDocumentLoadedWithoutFramesStartsThemAgainAtTheNextLook()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed();
+ await bed.StartAsync(ct);
+ bed.Frame();
+
+ // A frame of a page inside the page changes nothing; the main frame does.
+ bed.Cdp.Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F2", ["parentId"] = "F1", ["url"] = "http://127.0.0.1/pubblicita" } });
+ bed.Cdp.Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = "http://127.0.0.1/animata" } });
+ bed.Cdp.Raise("Page.loadEventFired", new JsonObject { ["timestamp"] = 1.0 });
+
+ await bed.StepAsync(Watchdog.Tick, ct);
+
+ Assert.AreEqual(1, bed.Session.Restarts, "no two seconds of white after a new page");
+ Assert.IsTrue(bed.Info.Contains("Vista remota: pagina nuova caricata senza fotogrammi, riavvio dei fotogrammi."), bed.AllLines);
+ }
+
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task ANewDocumentWhoseFramesArriveIsLeftAlone()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed();
+ await bed.StartAsync(ct);
+
+ bed.Cdp.Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = "http://127.0.0.1/animata" } });
+ bed.Frame();
+ bed.Cdp.Raise("Page.loadEventFired", new JsonObject { ["timestamp"] = 1.0 });
+ for (var i = 0; i < 6; i++)
+ {
+ await bed.StepAsync(Watchdog.Tick, ct);
+ bed.Frame();
+ }
+
+ Assert.AreEqual(0, bed.Session.Restarts);
+ Assert.AreEqual(1, bed.Starts);
+ }
+
+ [TestMethod]
+ [Timeout(60_000, CooperativeCancellation = true)]
+ public async Task AStillPageCostsFewerAndFewerRestartsAndOneLineInTheRegistro()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed(screenshot: Jpeg(1280, 900));
+ await bed.StartAsync(ct);
+
+ // Thirty seconds of a page that does not move: restarts after 2, 4, 8 and 16 more seconds, not fifteen.
+ await bed.StepAsync(TimeSpan.FromSeconds(30.25), ct);
+
+ Assert.AreEqual(4, bed.Session.Restarts, bed.AllLines);
+ Assert.AreEqual(1, bed.Info.Count(l => l.Contains("riavvio dei fotogrammi", StringComparison.Ordinal)), "one line for the whole silence, the others at Debug");
+ Assert.IsFalse(bed.AllLines.Contains("http", StringComparison.Ordinal), "no addresses in the registro");
+ }
+
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task WithoutAWatchdogNothingIsStartedAgain()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed(noWatchdog: true);
+ await bed.StartAsync(ct);
+
+ Assert.AreEqual(0, bed.Clock.Waiting, "nobody watches");
+ bed.Clock.Advance(TimeSpan.FromMinutes(1));
+ Assert.AreEqual(1, bed.Starts);
+ Assert.IsFalse(bed.Cdp.Sent.Any(c => c.Method == "Page.captureScreenshot"));
+ }
+
+ [TestMethod]
+ public void TheSizeOfAJpegIsReadFromItsFrameHeader()
+ {
+ Assert.AreEqual((800, 600), ScreencastSession.JpegSize(Jpeg(800, 600)));
+ Assert.AreEqual((1280, 900), ScreencastSession.JpegSize(Jpeg(1280, 900, progressive: true)));
+ Assert.IsNull(ScreencastSession.JpegSize([0xFF, 0xD8, 0xFF, 0xD9]), "no frame header");
+ Assert.IsNull(ScreencastSession.JpegSize([0x89, 0x50, 0x4E, 0x47]), "not a JPEG");
+ Assert.IsNull(ScreencastSession.JpegSize([]));
+ Assert.IsNull(ScreencastSession.JpegSize([0xFF, 0xD8, 0xFF, 0xC0, 0x00, 0x11, 0x08]), "cut short");
+ }
+
+ /// A minimal JPEG header: SOI, an APP0 segment, then a SOF0 (or SOF2) with the size.
+ private static byte[] Jpeg(int width, int height, bool progressive = false) =>
+ [
+ 0xFF, 0xD8,
+ 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
+ 0xFF, progressive ? (byte)0xC2 : (byte)0xC0, 0x00, 0x11, 0x08,
+ (byte)(height >> 8), (byte)height, (byte)(width >> 8), (byte)width,
+ 0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
+ 0xFF, 0xD9,
+ ];
+
+ /// A screencast over a fake page and a clock that moves only when stepped.
+ private sealed class Bed : IAsyncDisposable
+ {
+ private readonly ConcurrentQueue<(BrowserLogLevel Level, string Message)> _lines = new();
+ private readonly ScreencastWatchdog? _watchdog;
+ private int _starts;
+ private int _frameSession;
+
+ public Bed(bool lostAcks = false, byte[]? screenshot = null, bool noWatchdog = false)
+ {
+ _watchdog = noWatchdog ? null : Watchdog;
+ Clock = new SteppingClock();
+ Cdp = new FakeCdpSession(Clock)
+ {
+ Responder = (method, _) =>
+ {
+ switch (method)
+ {
+ case "Page.startScreencast":
+ Interlocked.Increment(ref _starts);
+ return null;
+ case "Page.screencastFrameAck" when lostAcks:
+ throw new CdpCommandException(method, CdpCommandException.ServerErrorCode, "Session is not attached");
+ case "Page.captureScreenshot":
+ return screenshot is null ? null : new JsonObject { ["data"] = Convert.ToBase64String(screenshot) };
+ default:
+ return null;
+ }
+ },
+ };
+ Session = new ScreencastSession(Cdp, new DelegateBrowserLog((level, message, _) => _lines.Enqueue((level, message))), Clock);
+ }
+
+ public SteppingClock Clock { get; }
+
+ public FakeCdpSession Cdp { get; }
+
+ public ScreencastSession Session { get; }
+
+ public int Starts => Volatile.Read(ref _starts);
+
+ public List Info => [.. _lines.Where(l => l.Level == BrowserLogLevel.Information).Select(l => l.Message)];
+
+ public string AllLines => string.Join('\n', _lines.Select(l => $"{l.Level} {l.Message}"));
+
+ public async Task StartAsync(CancellationToken ct)
+ {
+ await Session.StartAsync(new ScreencastOptions(Quality: 60, MaxWidth: 1280, MaxHeight: 900, Watchdog: _watchdog), ct);
+ if (_watchdog is not null)
+ {
+ await Clock.WaitForSleeperAsync(ct);
+ }
+ }
+
+ /// A frame of the screencast, as Chromium sends it.
+ public void Frame() => Cdp.Raise("Page.screencastFrame", new JsonObject
+ {
+ ["sessionId"] = Interlocked.Increment(ref _frameSession),
+ ["data"] = Convert.ToBase64String(Jpeg(1280, 900)),
+ ["metadata"] = new JsonObject { ["deviceWidth"] = 1280, ["deviceHeight"] = 900, ["pageScaleFactor"] = 1 },
+ });
+
+ /// Moves the clock by , one look of the watchdog at a time.
+ public async Task StepAsync(TimeSpan time, CancellationToken ct)
+ {
+ var tick = (_watchdog ?? Watchdog).Tick;
+ for (var moved = TimeSpan.Zero; moved < time; moved += tick)
+ {
+ Clock.Advance(tick);
+ await Clock.WaitForSleeperAsync(ct);
+ }
+ }
+
+ public async ValueTask DisposeAsync() => await Session.DisposeAsync();
+ }
+
+ /// A clock whose delays end only when the test moves it past them.
+ private sealed class SteppingClock : IClock
+ {
+ private readonly Lock _gate = new();
+ private readonly List<(DateTimeOffset Due, TaskCompletionSource Done)> _sleepers = [];
+ private DateTimeOffset _now = new(2026, 11, 16, 9, 0, 0, TimeSpan.Zero);
+
+ public DateTimeOffset Now
+ {
+ get
+ {
+ lock (_gate)
+ {
+ return _now;
+ }
+ }
+ }
+
+ public TimeZoneInfo LocalZone => TimeZoneInfo.Utc;
+
+ public int Waiting
+ {
+ get
+ {
+ lock (_gate)
+ {
+ return _sleepers.Count;
+ }
+ }
+ }
+
+ public Task Delay(TimeSpan time, CancellationToken ct)
+ {
+ ct.ThrowIfCancellationRequested();
+ if (time <= TimeSpan.Zero)
+ {
+ return Task.CompletedTask;
+ }
+
+ var done = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+ lock (_gate)
+ {
+ _sleepers.Add((_now + time, done));
+ }
+
+ ct.Register(() =>
+ {
+ lock (_gate)
+ {
+ _sleepers.RemoveAll(s => s.Done == done);
+ }
+
+ done.TrySetCanceled(ct);
+ });
+ return done.Task;
+ }
+
+ public void Advance(TimeSpan time)
+ {
+ List due;
+ lock (_gate)
+ {
+ _now += time;
+ due = [.. _sleepers.Where(s => s.Due <= _now).Select(s => s.Done)];
+ _sleepers.RemoveAll(s => s.Due <= _now);
+ }
+
+ foreach (var done in due)
+ {
+ done.TrySetResult();
+ }
+ }
+
+ /// Waits (in real time) until someone sleeps on the clock again: the watchdog finished its look.
+ public async Task WaitForSleeperAsync(CancellationToken ct)
+ {
+ using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
+ timeout.CancelAfter(TimeSpan.FromSeconds(10));
+ while (Waiting == 0)
+ {
+ await Task.Delay(1, timeout.Token);
+ }
+ }
+ }
+}
diff --git a/tests/Febe.Tests/Browser/TestSupport/LocalTestSite.cs b/tests/Febe.Tests/Browser/TestSupport/LocalTestSite.cs
index 866285e..2a94fc4 100644
--- a/tests/Febe.Tests/Browser/TestSupport/LocalTestSite.cs
+++ b/tests/Febe.Tests/Browser/TestSupport/LocalTestSite.cs
@@ -44,6 +44,9 @@ public sealed class LocalTestSite : IDisposable
public string Url(string path) => $"http://{SiteHost}{path}";
+ /// The same site under the name «localhost»: another site for Chromium, so another renderer.
+ public string LocalhostUrl(string path) => $"http://localhost:{SitePort}{path}";
+
public string CdnUrl(string path) => $"http://{CdnHost}{path}";
public static int FreePort()
diff --git a/tests/Febe.Tests/Desktop/BrowserStartPageTests.cs b/tests/Febe.Tests/Desktop/BrowserStartPageTests.cs
new file mode 100644
index 0000000..c2d520b
--- /dev/null
+++ b/tests/Febe.Tests/Desktop/BrowserStartPageTests.cs
@@ -0,0 +1,196 @@
+using System.Net;
+using Febe.Core.Abstractions;
+using Febe.Tests.Desktop.Support;
+using Febe.Tests.Support;
+
+namespace Febe.Tests.Desktop;
+
+///
+/// The browser that showed nothing (Gitea issue #52), in the shared composition with the fake window «Browser di Febe»:
+/// opened from the empty rest page it goes to a page of its own, «Apri il browser» of a disconnection opens the login,
+/// leaving a page of Febe leaves the window as it is, and the test site's automatic login raises no false alarm.
+/// Never Instagram: the fake browser answers by itself.
+///
+[TestClass]
+public sealed class BrowserStartPageTests
+{
+ private const string Login = "https://www.instagram.com/accounts/login/";
+ private const string Home = "https://www.instagram.com/";
+
+ public TestContext TestContext { get; set; } = null!;
+
+ [TestMethod]
+ [Timeout(60_000, CooperativeCancellation = true)]
+ public async Task UsaIlBrowserFromTheRestPageOpensTheLoginOrTheHomeAndAnyOtherPageStays()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = await DesktopTestBed.StartAsync();
+ await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
+ var browser = bed.Browser!;
+ Assert.AreEqual("about:blank", browser.FakeCdp.Url);
+
+ // Not connected: never a white window, the login page.
+ await BeginAsync(bed, openLogin: false);
+ Assert.AreEqual(Login, browser.FakeCdp.Url);
+ Assert.AreEqual(1, browser.Shown, "the window came to the front");
+
+ browser.FakeCdp.LoggedIn = true;
+ var finish = await bed.JsonAsync(HttpMethod.Post, "/api/connection/finish");
+ Assert.IsTrue(finish.GetProperty("connected").GetBoolean());
+ await DesktopTestBed.WaitUntilAsync(() => browser.FakeCdp.Url == "about:blank", TimeSpan.FromSeconds(10), "la pagina di riposo dopo «Ho finito»");
+
+ // Connected: the site's home.
+ await BeginAsync(bed, openLogin: false);
+ Assert.AreEqual(Home, browser.FakeCdp.Url);
+
+ // A page he opened stays as it is.
+ browser.FakeCdp.Navigated("https://www.instagram.com/marta.prova/");
+ var navigations = Navigations(browser);
+ await BeginAsync(bed, openLogin: false);
+ Assert.AreEqual("https://www.instagram.com/marta.prova/", browser.FakeCdp.Url);
+ Assert.AreEqual(navigations, Navigations(browser), "no navigation of his page");
+
+ var status = await bed.JsonAsync(HttpMethod.Get, "/api/connection");
+ Assert.IsTrue(status.GetProperty("userIsDriving").GetBoolean());
+ }
+
+ [TestMethod]
+ [Timeout(60_000, CooperativeCancellation = true)]
+ public async Task ApriIlBrowserBringsTheWindowWithItsStartPageAndTheLoginAfterADisconnection()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = await DesktopTestBed.StartAsync();
+ await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
+ var browser = bed.Browser!;
+
+ // Connected, at rest: «Apri il browser» (Attività) opens the home, the window in front.
+ await LoginAsync(bed);
+ await DesktopTestBed.WaitUntilAsync(() => browser.FakeCdp.Url == "about:blank", TimeSpan.FromSeconds(10), "la pagina di riposo dopo «Ho finito»");
+ var shown = browser.Shown;
+ var result = await bed.JsonAsync(HttpMethod.Post, "/api/browser/show");
+ StringAssert.Contains(result.GetProperty("message").GetString(), "primo piano");
+ Assert.AreEqual(Home, browser.FakeCdp.Url);
+ Assert.AreEqual(shown + 1, browser.Shown);
+ Assert.IsTrue(browser.UserIsDriving, "the window on screen holds the engine still");
+
+ // Closed with its X: out of view, the engine puts the page to rest.
+ await browser.HideFromUserAsync(ct);
+ await DesktopTestBed.WaitUntilAsync(() => browser.FakeCdp.Url == "about:blank", TimeSpan.FromSeconds(10), "la pagina di riposo dopo la chiusura");
+
+ // The session goes while nobody looks: a disconnection. The red strip's «Apri il browser» asks for the login.
+ browser.FakeCdp.LoggedIn = false;
+ await bed.App.Connection!.RefreshAsync(ct);
+ var breaker = bed.App.Engine!.Services.Breaker;
+ await breaker.FlushAsync();
+ Assert.AreEqual(BreakerStatus.Disconnected, breaker.State.Status);
+ Assert.AreEqual(Login, bed.App.Connection.StartPageUrl, "disconnected: the start page is the login");
+
+ using (var show = await bed.SendAsync(HttpMethod.Post, "/api/browser/show", """{"openLogin":true}"""))
+ {
+ Assert.AreEqual(HttpStatusCode.OK, show.StatusCode, await show.Content.ReadAsStringAsync(ct));
+ }
+
+ Assert.AreEqual(Login, browser.FakeCdp.Url);
+ }
+
+ [TestMethod]
+ [Timeout(60_000, CooperativeCancellation = true)]
+ public async Task LeavingThePageOfFebeLeavesTheWindowOnScreenButAnnullaPutsItAway()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = await DesktopTestBed.StartAsync();
+ await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
+ var browser = bed.Browser!;
+ await LoginAsync(bed);
+ await DesktopTestBed.WaitUntilAsync(() => browser.FakeCdp.Url == "about:blank", TimeSpan.FromSeconds(10), "la pagina di riposo dopo «Ho finito»");
+
+ await BeginAsync(bed, openLogin: false);
+ Assert.AreEqual(Home, browser.FakeCdp.Url);
+ var hidden = browser.Hidden;
+
+ // Another page of Febe, the tab closed or reloaded: the page's hold ends, the window stays where it is.
+ using (var left = await bed.SendAsync(HttpMethod.Post, "/api/connection/cancel", """{"pageLeft":true}"""))
+ {
+ Assert.AreEqual(HttpStatusCode.NoContent, left.StatusCode);
+ }
+
+ await Task.Delay(TimeSpan.FromSeconds(1), ct);
+ Assert.AreEqual(hidden, browser.Hidden, "not put out of view");
+ Assert.AreEqual(Home, browser.FakeCdp.Url, "not put to rest");
+ Assert.IsTrue(browser.UserIsDriving, "on screen, the window still holds the engine");
+ Assert.IsTrue(bed.App.Engine!.Services.Runtime.UserIsDriving);
+
+ // «Annulla» from the page is still «Annulla»: out of view and at rest.
+ await BeginAsync(bed, openLogin: false);
+ using (var cancel = await bed.SendAsync(HttpMethod.Post, "/api/connection/cancel"))
+ {
+ Assert.AreEqual(HttpStatusCode.NoContent, cancel.StatusCode);
+ }
+
+ Assert.AreEqual(hidden + 1, browser.Hidden);
+ await DesktopTestBed.WaitUntilAsync(() => !browser.UserIsDriving, TimeSpan.FromSeconds(10), "la fine della guida dopo «Annulla»");
+ Assert.AreEqual("about:blank", browser.FakeCdp.Url);
+ }
+
+ [TestMethod]
+ [Timeout(60_000, CooperativeCancellation = true)]
+ public async Task HoFinitoWithoutTheLoginSaysTheSessionIsNotThere()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = await DesktopTestBed.StartAsync();
+ await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
+
+ await BeginAsync(bed, openLogin: true);
+ var finish = await bed.JsonAsync(HttpMethod.Post, "/api/connection/finish");
+
+ Assert.IsFalse(finish.GetProperty("connected").GetBoolean());
+ StringAssert.Contains(finish.GetProperty("message").GetString(), "non trova la sessione");
+ }
+
+ [TestMethod]
+ [Timeout(90_000, CooperativeCancellation = true)]
+ public async Task TheTestSitesAutomaticLoginIsNoDisconnectionAtTheNextStart()
+ {
+ var ct = TestContext.CancellationToken;
+ const string site = "http://127.0.0.1:8481";
+ string[] args = ["--sito-di-prova", site, "--accesso-di-prova"];
+ using var temp = new TempFolder("accesso-di-prova");
+ var locations = new MemoryLocationStore();
+ FakeDesktopShell Shell() => new() { OnCreated = b => b.FakeCdp.LogsInOnVisit = site };
+
+ await using (var bed = await DesktopTestBed.StartAsync(args, Shell(), temp, locations))
+ {
+ await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
+ Assert.IsTrue(bed.App.Connection!.IsConnected, "logged in by the automatic login");
+ await bed.StopAsync();
+ }
+
+ // The next start: the new browser has no session yet (the test site forgot it); the automatic login opens it again.
+ await using (var bed = await DesktopTestBed.StartAsync(args, Shell(), temp, locations))
+ {
+ await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
+ var breaker = bed.App.Engine!.Services.Breaker;
+ await breaker.FlushAsync();
+ Assert.IsTrue(bed.App.Connection!.IsConnected);
+ Assert.AreEqual(BreakerStatus.Closed, breaker.State.Status, "not a disconnection: the session the login was about to open");
+ Assert.IsEmpty(await bed.App.Database.Incidents.ListOpenAsync(ct));
+ await bed.StopAsync();
+ }
+ }
+
+ private static int Navigations(FakeBrowser browser) => browser.FakeCdp.Methods.Count(m => m == "Page.navigate");
+
+ private static async Task BeginAsync(DesktopTestBed bed, bool openLogin)
+ {
+ using var begin = await bed.SendAsync(HttpMethod.Post, "/api/connection/begin", openLogin ? """{"openLogin":true}""" : """{"openLogin":false}""");
+ Assert.AreEqual(HttpStatusCode.NoContent, begin.StatusCode);
+ }
+
+ private static async Task LoginAsync(DesktopTestBed bed)
+ {
+ await BeginAsync(bed, openLogin: true);
+ bed.Browser!.FakeCdp.LoggedIn = true;
+ var finish = await bed.JsonAsync(HttpMethod.Post, "/api/connection/finish");
+ Assert.IsTrue(finish.GetProperty("connected").GetBoolean(), finish.GetProperty("message").GetString());
+ }
+}
diff --git a/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs b/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs
index 5ae8990..49bc08e 100644
--- a/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs
+++ b/tests/Febe.Tests/Desktop/Support/FakeDesktopShell.cs
@@ -28,11 +28,15 @@ internal sealed class FakeDesktopShell : IDesktopShell
public ConcurrentQueue ProcessWindows { get; } = new();
+ /// Called with each browser as it is created, before Febe uses it (to set up the fake page).
+ public Action? OnCreated { get; set; }
+
public string? WebView2Version() => RuntimeVersion;
public IFebeBrowser CreateWebView2Browser(WebView2BrowserSettings settings, FebePlatformContext context)
{
var browser = new FakeBrowser(settings.ProfileDirectory, settings.Width, settings.Height, context);
+ OnCreated?.Invoke(browser);
Created.Enqueue((settings, browser));
return browser;
}
@@ -225,6 +229,12 @@ internal sealed class FakeCdp : ICdpSession
public bool LoggedIn { get; set; }
+ ///
+ /// Like the test site, which sets its session cookie on any visit: a navigation to an address starting with this
+ /// logs in, and the page reports itself loaded. Null: only the test logs in.
+ ///
+ public string? LogsInOnVisit { get; set; }
+
public string Url { get; private set; } = "about:blank";
public ConcurrentQueue Methods { get; } = new();
@@ -244,7 +254,9 @@ internal sealed class FakeCdp : ICdpSession
{
"Page.getFrameTree" => new JsonObject { ["frameTree"] = new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = Url } } },
"Page.navigate" => Navigate(parameters),
- "Network.getCookies" => new JsonObject { ["cookies"] = LoggedIn ? new JsonArray(new JsonObject { ["name"] = "sessionid" }) : new JsonArray() },
+ // The session cookie of Instagram, and the test site's one.
+ "Network.getCookies" => new JsonObject { ["cookies"] = LoggedIn ? new JsonArray(new JsonObject { ["name"] = "sessionid" }, new JsonObject { ["name"] = "sessione_prova" }) : new JsonArray() },
+ "Runtime.evaluate" when LogsInOnVisit is not null => new JsonObject { ["result"] = new JsonObject { ["type"] = "string", ["value"] = "complete" } },
_ => new JsonObject(),
};
return Task.FromResult(JsonDocument.Parse(result.ToJsonString()).RootElement.Clone());
@@ -276,6 +288,11 @@ internal sealed class FakeCdp : ICdpSession
var url = (parameters as JsonObject)?["url"]?.GetValue();
if (url is not null)
{
+ if (LogsInOnVisit is { } site && url.StartsWith(site, StringComparison.Ordinal))
+ {
+ LoggedIn = true;
+ }
+
Navigated(url);
}
diff --git a/tests/Febe.Tests/Server/RemoteViewSocketTests.cs b/tests/Febe.Tests/Server/RemoteViewSocketTests.cs
index e0af551..16f5d39 100644
--- a/tests/Febe.Tests/Server/RemoteViewSocketTests.cs
+++ b/tests/Febe.Tests/Server/RemoteViewSocketTests.cs
@@ -177,6 +177,17 @@ public sealed class RemoteViewSocketTests
Assert.AreEqual("about:blank", BrowserRemoteViewConnection.WithoutQuery("about:blank"));
}
+ [TestMethod]
+ public void TheThreeButtonsOfTheBarAreNavigations()
+ {
+ static object? Parse(string json) => RemoteViewSocket.Parse(Encoding.UTF8.GetBytes(json));
+
+ Assert.AreEqual(RemoteViewNavigation.Back, Parse("""{"type":"navigate","action":"back"}"""));
+ Assert.AreEqual(RemoteViewNavigation.Reload, Parse("""{"type":"navigate","action":"reload"}"""));
+ Assert.AreEqual(RemoteViewNavigation.Home, Parse("""{"type":"navigate","action":"home"}"""), "«Pagina iniziale» (issue #52)");
+ Assert.IsNull(Parse("""{"type":"navigate","action":"https://example.com/"}"""), "never an address from the page");
+ }
+
private static Task StartAsync(FakeRemoteViewHost host) =>
WebTestServer.StartAsync(
new FebeWebOptions { Edition = FebeEdition.Docker, Access = AccessMode.Password, Password = Password },
diff --git a/tests/Febe.Tests/Server/RemoteViewStartTests.cs b/tests/Febe.Tests/Server/RemoteViewStartTests.cs
index 70cdb9a..3022a0e 100644
--- a/tests/Febe.Tests/Server/RemoteViewStartTests.cs
+++ b/tests/Febe.Tests/Server/RemoteViewStartTests.cs
@@ -132,6 +132,65 @@ public sealed class RemoteViewStartTests
}
}
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task PaginaInizialeOpensTheStartPageOfTheMoment()
+ {
+ var ct = TestContext.CancellationToken;
+ var start = "http://127.0.0.1:8481/benvenuto";
+ await using var bed = new Bed(_ => null, () => start);
+ var view = await bed.Host.OpenAsync(ct);
+
+ await view.NavigateAsync(RemoteViewNavigation.Home, ct);
+ Assert.AreEqual(start, bed.LastNavigation, "not connected: the login page");
+
+ // Connected meanwhile: the same button opens the site's home.
+ start = "http://127.0.0.1:8481/";
+ await view.NavigateAsync(RemoteViewNavigation.Home, ct);
+ Assert.AreEqual(start, bed.LastNavigation);
+ Assert.AreEqual(2, bed.Cdp.Sent.Count(c => c.Method == "Page.navigate"), "Alberto's own navigations, one per press");
+
+ await view.DisposeAsync();
+ }
+
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task WithoutAStartPageTheButtonDoesNothing()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed(_ => null);
+ var view = await bed.Host.OpenAsync(ct);
+
+ await view.NavigateAsync(RemoteViewNavigation.Home, ct);
+
+ Assert.IsFalse(bed.Cdp.Sent.Any(c => c.Method == "Page.navigate"));
+ await view.DisposeAsync();
+ }
+
+ [TestMethod]
+ [Timeout(30_000, CooperativeCancellation = true)]
+ public async Task IndietroNeverLandsOnTheEmptyRestPage()
+ {
+ var ct = TestContext.CancellationToken;
+ await using var bed = new Bed(_ => null);
+ var view = await bed.Host.OpenAsync(ct);
+
+ // The view opened on the rest page; then a page, the rest page again (a session of the engine), another page.
+ bed.Navigated("http://127.0.0.1:8481/profilo/marta.prova/");
+ bed.Navigated("about:blank");
+ bed.Navigated("http://127.0.0.1:8481/esplora/");
+
+ await view.NavigateAsync(RemoteViewNavigation.Back, ct);
+ Assert.AreEqual("http://127.0.0.1:8481/profilo/marta.prova/", bed.LastNavigation, "the rest page in between is skipped");
+
+ // Before that only the rest page: «Indietro» stays where it is instead of turning the view white.
+ bed.Cdp.ClearSent();
+ await view.NavigateAsync(RemoteViewNavigation.Back, ct);
+ Assert.IsFalse(bed.Cdp.Sent.Any(c => c.Method == "Page.navigate"));
+
+ await view.DisposeAsync();
+ }
+
private static CdpCommandException InactivePage() =>
new("Page.startScreencast", CdpCommandException.ServerErrorCode, CdpCommandException.InactivePageMessage);
@@ -170,7 +229,8 @@ public sealed class RemoteViewStartTests
private int _starts;
/// For the n-th start (from 1), the exception the browser answers with; null: started.
- public Bed(Func startFailure)
+ /// Where «Pagina iniziale» goes; null: nowhere.
+ public Bed(Func startFailure, Func? startPage = null)
{
Clock = new VirtualClock();
_start = Clock.Now;
@@ -196,7 +256,11 @@ public sealed class RemoteViewStartTests
};
Browser = new PageBrowser(Cdp);
_log = new FebeLog(null, null, Clock);
- Host = new BrowserRemoteViewHost(Browser, new BrowserUseTracker(), Clock, _log, browserClock: Clock);
+ Host = new BrowserRemoteViewHost(Browser, new BrowserUseTracker(), Clock, _log, browserClock: Clock, startPage: startPage)
+ {
+ // The virtual clock moves only in the pauses: a watchdog on it would never wait.
+ Watchdog = null,
+ };
}
public VirtualClock Clock { get; }
@@ -209,6 +273,13 @@ public sealed class RemoteViewStartTests
public int Starts => Volatile.Read(ref _starts);
+ /// The address of the last Page.navigate.
+ public string? LastNavigation => Cdp.Sent.LastOrDefault(c => c.Method == "Page.navigate")?.Parameters?["url"]?.GetValue();
+
+ /// The main frame committed a new document.
+ public void Navigated(string url) =>
+ Cdp.Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = url } });
+
/// Time spent in the host's pauses (the virtual clock moves only there).
public TimeSpan Elapsed => Clock.Now - _start;
diff --git a/tests/Febe.Tests/Server/ServerEndToEndTests.cs b/tests/Febe.Tests/Server/ServerEndToEndTests.cs
index bf04f7c..a7f065f 100644
--- a/tests/Febe.Tests/Server/ServerEndToEndTests.cs
+++ b/tests/Febe.Tests/Server/ServerEndToEndTests.cs
@@ -227,12 +227,15 @@ public sealed partial class ServerEndToEndTests
TimeSpan.FromSeconds(60),
"il motore di nuovo in funzione, in attesa del collegamento");
- // «Ho finito» without having logged in: Febe says it does not find the session.
+ // «Usa il browser» on the rest page, not connected (issue #52): never the white page, the login page. (The test
+ // site sets its session on any visit, so «Ho finito» without a login is proved with the fake browser of
+ // BrowserStartPageTests.)
await connection.BeginUserDrivingAsync(openLogin: false, ct);
Assert.IsTrue(server.Browser.UserIsDriving);
- var finish = await connection.FinishAsync(ct);
- Assert.IsFalse(finish.Connected);
- StringAssert.Contains(finish.Message, "non trova la sessione");
+ var opened = (await connection.GetStatusAsync(ct)).CurrentUrl;
+ Assert.IsNotNull(opened);
+ StringAssert.Contains(opened, "/benvenuto", "the login page of the test site");
+ await connection.CancelAsync(ct);
Assert.IsFalse(server.Browser.UserIsDriving);
// «Annulla» ends the driving and leaves the browser on the rest page.
diff --git a/tests/Febe.Tests/Web/ConnectionApiTests.cs b/tests/Febe.Tests/Web/ConnectionApiTests.cs
index 8dff6e2..7ee9db3 100644
--- a/tests/Febe.Tests/Web/ConnectionApiTests.cs
+++ b/tests/Febe.Tests/Web/ConnectionApiTests.cs
@@ -62,6 +62,38 @@ public sealed class ConnectionApiTests
CollectionAssert.AreEqual(new[] { "begin:True", "finish", "cancel", "disconnect" }, connection.Calls);
}
+ [TestMethod]
+ public async Task LeavingThePageIsAnnullaInDockerAndOnlyTheEndOfTheHoldOnWindows()
+ {
+ // Docker: the remote view is the page, leaving it gives the browser back to rest.
+ var docker = new RecordingConnection();
+ await using (var server = await Part2.StartAsync(services: s => s.AddSingleton(docker)))
+ {
+ var (status, _) = await server.SendJsonAsync(HttpMethod.Post, "/api/connection/cancel", new { pageLeft = true });
+ Assert.AreEqual(HttpStatusCode.NoContent, status);
+ var (showStatus, _) = await server.SendJsonAsync(HttpMethod.Post, "/api/browser/show");
+ Assert.AreEqual(HttpStatusCode.BadRequest, showStatus, "in Docker the browser is the Browser page");
+ }
+
+ CollectionAssert.AreEqual(new[] { "cancel" }, docker.Calls);
+
+ // Windows (issue #52): the window stays as it is; «Annulla» is still «Annulla»; «Apri il browser» says which page.
+ var windows = new RecordingConnection();
+ await using (var server = await Part2.StartAsync(services: s => s
+ .AddSingleton(windows)
+ .AddSingleton(new SeparateWindow())))
+ {
+ await server.SendJsonAsync(HttpMethod.Post, "/api/connection/cancel", new { pageLeft = true });
+ await server.SendJsonAsync(HttpMethod.Post, "/api/connection/cancel");
+ var (shown, message) = await server.SendJsonAsync(HttpMethod.Post, "/api/browser/show");
+ Assert.AreEqual(HttpStatusCode.OK, shown);
+ StringAssert.Contains(message.Str("message"), "primo piano");
+ await server.SendJsonAsync(HttpMethod.Post, "/api/browser/show", new { openLogin = true });
+ }
+
+ CollectionAssert.AreEqual(new[] { "release", "cancel", "show:False", "show:True" }, windows.Calls);
+ }
+
[TestMethod]
public async Task CommandsFromAnotherPageAreRefused()
{
@@ -99,4 +131,10 @@ public sealed class ConnectionApiTests
Assert.AreEqual(problem.Message, listed[0].Str("message"));
Assert.AreEqual(problem.Remedy, listed[0].Str("remedy"));
}
+
+ /// The browser as a window of its own, as on Windows.
+ private sealed class SeparateWindow : Febe.Web.Native.IBrowserWindow
+ {
+ public bool IsSeparateWindow => true;
+ }
}
diff --git a/tests/Febe.Tests/Web/Part2Support/Part2Helpers.cs b/tests/Febe.Tests/Web/Part2Support/Part2Helpers.cs
index b8b198d..f268362 100644
--- a/tests/Febe.Tests/Web/Part2Support/Part2Helpers.cs
+++ b/tests/Febe.Tests/Web/Part2Support/Part2Helpers.cs
@@ -109,6 +109,20 @@ internal sealed class RecordingConnection : IConnectionService
return Task.CompletedTask;
}
+ public Task ShowBrowserAsync(bool openLogin, CancellationToken ct)
+ {
+ Record("show:" + openLogin);
+ Status = Status with { UserIsDriving = true };
+ return Task.CompletedTask;
+ }
+
+ public Task ReleaseAsync(CancellationToken ct)
+ {
+ Record("release");
+ Status = Status with { UserIsDriving = false };
+ return Task.CompletedTask;
+ }
+
public Task DisconnectAsync(CancellationToken ct)
{
Record("disconnect");