Browser mai bianco né muto (#52) #54

Merged
Alby96 merged 5 commits from correzione/browser-vuoto into main 2026-11-16 17:16:33 +01:00
54 changed files with 2853 additions and 201 deletions

No files matched your search

+17
View File
@@ -361,3 +361,20 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15).
| 2026-11-16 | I rifiuti del catalogo delle richieste (`RequestCatalog`) stanno nel codice, non nel JSON: ogni nome che contiene `Mutation`, le famiglie GraphQL di chat, messaggi, presenza, promozioni, pubblicità e telemetria, i percorsi di telemetria e navigazione (`/logging_client_events`, `/ajax/…`, `/ws/`, `/api/v1/web/`, `/api/v1/discover/web/`…), ogni percorso con un host, una query o un valore come primo segmento; GraphQL solo verso `/api/graphql` e `/graphql/query` con POST, gli indirizzi semplici solo con GET; niente intestazione `cookie` nel modello | Una copia di `richieste.<sito>.json` modificata nella cartella dei dati non deve poter togliere un divieto (regole 3, 6) |
| 2026-11-16 | `richieste.<sito>.json` ha chiavi in inglese come gli altri file di configurazione; per ogni intestazione e campo dice la fonte del valore (`constant:`, `cookie:csrftoken`, `session:` user_agent, lsd, fb_dtsg, app_id, claim, account_id, doc_id, `operation`, `variables`, `computed`, `pending` se ancora da stabilire nella tappa S4). Un'operazione con un nome o un valore tolto dalla sonda nelle variabili resta «non configurata» e il client la rifiuta; nessun `doc_id` nel repository. Le categorie del Governatore sono quelle che ci sono già, fino ai tetti per richiesta della tappa S3 | Regola 9: le forme non mostrano tutto, e ciò che manca non si indovina |
| 2026-11-16 | Il contratto del client del sito (S1 di #36) si chiude nel codice: un'operazione con un'intestazione o un campo `pending` (o col nome tolto dalla sonda) non può essere configurata, quindi oggi nessuna operazione di Instagram lo è; un permesso vale per una sola richiesta, contato per riferimento (`SpentPermits`) e speso anche se la richiesta è poi rifiutata; i valori del caso hanno una forma (cifre per gli identificativi, i caratteri di un nome utente, di un codice o di una raccolta) e quelli che finiscono nel percorso non portano `/ ? # %` né punti soli; i percorsi del catalogo non hanno segmenti vuoti, `.` o `..` né caratteri fuori da lettere, cifre e `/_.-{}`; un indirizzo semplice non può puntare a GraphQL; la categoria «ricerca» è solo di un'operazione che porta `{search_text}` e nessun account o contenuto, e viceversa; `SiteAnswer` prende l'operazione del catalogo, non un percorso | Revisione della tappa S1: altrimenti una copia modificata nella cartella dei dati (`/./ajax/bz`, che `System.Uri` riduce a `/ajax/bz`), un valore come `..` o un permesso riusato aggirerebbero i divieti delle regole 4, 8, 9 e 10; il tetto della ricerca è fuori dalle sessioni (§7.4) |
| 2026-11-16 | Vista remota: watchdog dei fotogrammi facoltativo (`ScreencastOptions.Watchdog`, default dell'host 2 s / 250 ms / 30 s), con riavvio stop+start dopo silenzio o `loadEventFired` senza fotogrammi e attesa che raddoppia fino a 30 s; immagine ferma con `Page.captureScreenshot` se il riavvio non porta nulla | Un ack perso o un cambio di renderer lasciavano la vista bianca per sempre; il raddoppio evita un riavvio ogni 2 s sulle pagine ferme. Nessun comando CDP nuovo |
| 2026-11-16 | Dopo un riavvio dei fotogrammi la vista aspetta il primo fotogramma per mezzo secondo (`ScreencastWatchdog.FirstFrameWait`, sull'orologio) prima di mandare l'immagine ferma, e la scarta se durante la cattura arriva un fotogramma vero; il silenzio si conta dall'avvio e l'attesa raddoppia prima dell'avvio | Chromium manda il primo fotogramma solo dopo aver risposto a `Page.startScreencast`: il controllo subito dopo la risposta mandava una cattura a quasi ogni riavvio, e l'immagine ferma poteva sostituire un fotogramma più recente |
| 2026-11-16 | Finestra «Browser di Febe» troppo grande per lo schermo: si restringe all'area di lavoro e la pagina si mostra con `ZoomFactor` uguale al rapporto (minimo 0,4) | La pagina tiene le stesse misure CSS (1280×900) per Instagram e per le ricette |
| 2026-11-16 | Fuori vista la finestra torna sempre a `Fit` 1 (pagina e `ZoomFactor` al 100%); il rapporto si ricalcola solo quando viene sullo schermo | Su uno schermo piccolo il rapporto restava per le sessioni del motore: le pagine vedevano un `devicePixelRatio` e media query diversi, un browser diverso da quello di sempre (regola 4) |
| 2026-11-16 | Su Windows lasciare una pagina di Febe non nasconde né mette a riposo la finestra del browser (cancel con `pageLeft` → `IConnectionService.ReleaseAsync`); resta finché Alberto non la chiude o preme «Ho finito» | La finestra spariva sotto gli occhi di Alberto quando cambiava pagina in Febe |
| 2026-11-16 | Finestra ridotta a icona: non vale più come «ho finito»; ha il pulsante nella barra delle applicazioni e dopo 2 minuti torna fuori vista | Ridurla la faceva sparire; S2 vieta di lasciarla ridotta a lungo |
| 2026-11-16 | Il pulsante della barra delle applicazioni cambia solo mentre la finestra è fuori vista (aggiunto prima di portarla sullo schermo, tolto dopo averla spostata); sullo schermo la finestra chiede di ridisegnarsi (`RedrawWindow` con i figli, niente che la pagina veda) | WPF cambia `ShowInTaskbar` di una finestra mostrata nascondendola e mostrandola di nuovo (visto con un aggancio a `WM_WINDOWPOSCHANGED`: `SWP_HIDEWINDOW`, poi `SWP_SHOWWINDOW`); S2 vieta di nasconderla sotto gli occhi di Alberto. `ITaskbarList` avrebbe evitato il nascondere, ma il suo comportamento con la finestra fuori vista non si può provare qui |
| 2026-11-16 | Ridotta a icona troppo a lungo, la finestra si ripristina coperta (`DWMWA_CLOAK`) e senza fuoco (`SW_SHOWNOACTIVATE`), si sposta fuori vista e solo allora si scopre | Windows ripristina una finestra dove stava sullo schermo: spostare prima la posizione di ripristino non basta, Windows la riporta su uno schermo (provato); senza copertura la finestra appariva e prendeva il fuoco per un attimo |
| 2026-11-16 | Dopo un riavvio del processo GPU la finestra riceve bordi di un pixel più bassi e poi quelli veri, e una richiesta di ridisegno | Gli stessi bordi di nuovo possono non essere un cambiamento per WebView2; il ridisegno senza cambio di misura non è provato con un arresto vero della GPU |
| 2026-11-16 | «Pagina iniziale» della finestra di Windows e della vista remota passa da `BrowserConnectionService.OpenStartPageAsync`: aspetta la fine della sessione del motore e il turno della pagina, e agisce solo mentre Alberto guida | Come l'apertura dal riposo: un passo di una sessione che finisce o della ricerca dei profili (#37) non deve trovarsi la pagina cambiata a metà |
| 2026-11-16 | I corpi facoltativi delle richieste (`begin`, `cancel`, `browser/show`) si leggono con `ApiHttp.OptionalBodyAsync`: senza lunghezza dichiarata, un byte dice se il corpo c'è | Un POST vuoto a pezzi (o in HTTP/2) arriva senza `Content-Length` e finiva in 400 «Richiesta non leggibile» |
| 2026-11-16 | La pagina Browser toglie `?accesso=1` dall'indirizzo appena l'ha usato | Ricaricare la pagina, o riaprire la scheda, riapriva la pagina di accesso anche da collegati |
| 2026-11-16 | `IBrowserWindow.ShowAsync` tolto: «Apri il browser» passa da `IConnectionService.ShowBrowserAsync(openLogin)` | Aprire la pagina iniziale richiede il permesso di guida e il turno della pagina, che tiene il servizio di collegamento |
| 2026-11-16 | Con `--accesso-di-prova` il primo controllo della sessione all'avvio non segnala nulla (`RefreshAsync` con `mayReport: false`) | La sessione mancante è quella che l'accesso automatico sta per aprire, non una disconnessione |
| 2026-11-16 | «Pagina iniziale» vale finché dura il permesso di chi l'ha premuta: la finestra di Windows e la vista remota passano un gettone che si annulla con il loro permesso, e la connessione guarda di nuovo, con il turno della pagina in mano, che Alberto guidi ancora; senza turno rinuncia invece di prendere la pagina. Nella vista remota la pressione corre a parte, una per volta, e intanto clic e tasti si scartano | L'attesa (fine della sessione, turno della pagina) può durare mezzo minuto: Alberto poteva aver chiuso la finestra e Febe navigava senza permesso e fuori dal Governatore (regole 7 e 8); nella vista l'attesa nel ciclo di ricezione bloccava i comandi e poi li riversava sulla pagina nuova |
| 2026-11-16 | `Repaint` della finestra «Browser di Febe» chiede solo di ridisegnare (`RDW_INVALIDATE \| RDW_ALLCHILDREN`), senza `RDW_UPDATENOW` | Le finestre figlie sono del processo del browser di WebView2: un processo bloccato avrebbe fermato il thread dell'interfaccia in un ridisegno sincrono |
| 2026-11-16 | Le porte libere delle prove (`LocalTestSite.FreePort`) vengono da 20000–29999, ciascuna una volta sola per processo e provata prima di darla, non più dalla porta 0 del sistema | Nella CI 350 (#52) Chromium non è partito perché la porta di debug, presa dall'intervallo effimero di Linux e chiusa prima di usarla, era stata nel frattempo occupata (come per #46: la causa, non un tempo più lungo) |
+2 -1
View File
@@ -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.
+8
View File
@@ -19,6 +19,14 @@
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; fuori vista, quando la usa il motore, la pagina torna al
100%. 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.
+17 -4
View File
@@ -64,10 +64,23 @@ 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 Febe sta finendo un
lavoro nel browser, «Pagina iniziale» aspetta che finisca: può volerci qualche secondo (nella vista remota, intanto,
clic e tasti non arrivano al browser). Se nel frattempo chiudi il browser, o se il lavoro dura troppo, non succede
nulla: premilo di nuovo.
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
+2
View File
@@ -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)) |
+16 -1
View File
@@ -23,7 +23,22 @@ fra le sessioni; ciò che è da fare si legge nelle issue aperte.
viste. Le tappe S0–S7 stanno in #36.
- **Il browser che a volte restava vuoto** (#52): nove cause trovate e ordinate (la pagina di riposo `about:blank`
mostrata all'apertura, «Apri il browser» dopo una disconnessione, la finestra nascosta su Windows quando si lascia
la pagina, lo schermo remoto senza controllo dei fotogrammi in Docker, e altre); correzione su un ramo a parte.
la pagina, lo schermo remoto senza controllo dei fotogrammi in Docker, e altre). Corretto:
- aperto dal riposo, il browser va alla home se collegato, altrimenti all'accesso, come azione di Alberto; pulsante
«Pagina iniziale» nella finestra e nella vista remota, che aspetta la fine della sessione del motore e il turno
della pagina e vale solo finché dura il permesso di guida di chi l'ha premuto; avviso «a riposo su una pagina
vuota»; «Indietro» salta la pagina di riposo;
- «Apri il browser» della striscia rossa apre l'accesso; con `--accesso-di-prova` niente falso allarme all'avvio;
- Windows: lasciare una pagina di Febe non nasconde più la finestra; pulsante nella barra delle applicazioni solo
mentre è sullo schermo (cambiarlo con la finestra visibile la nasconde per un attimo); ridotta a icona non vale
più «Ho finito» e dopo 2 minuti torna fuori vista senza lampeggiare (DWM cloak); su uno schermo piccolo la finestra
si restringe con lo zoom della pagina, che torna a 1 fuori vista; ridisegno dopo il riavvio del processo GPU;
- Docker: controllo dei fotogrammi della vista remota (riavvio dopo 2 s di silenzio o un caricamento senza
fotogrammi, attesa che raddoppia fino a 30 s, immagine ferma con `Page.captureScreenshot` se il riavvio non porta
nulla in 500 ms), «Nessuna immagine dal browser» con «Riprova» dopo 8 s, registro della vista; nessun comando CDP
nuovo. 16 righe in `docs/decisioni.md`, due giri di revisione indipendente (14 punti, tutti chiusi).
- **Non verificato**: il disegno vero dopo un crash della GPU, uno schermo piccolo vero, la vista remota con Chromium
vero (solo nella CI Linux), le schermate nuove contro il mockup.
- **Tappa S1, il giunto senza cambiare comportamento**: `ResponseDelivery` (in Core) consegna ai lettori le risposte
catturate e, da S2, quelle chieste, nello stesso modo; `ResponseTap` la usa con gli stessi conteggi e messaggi.
Contratti `SiteRequest`, `SiteAnswer` (che non stampa mai corpi, cookie o percorsi concreti) e `ISiteRequester`,
+212 -25
View File
@@ -17,9 +17,10 @@ namespace Febe.App;
/// means that the session cookie exists in the browser profile: only its existence is checked
/// (<c>Network.getCookies</c>, 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).
/// </summary>
/// <remarks>
/// <para>
@@ -29,6 +30,11 @@ namespace Febe.App;
/// must not stay still for ever.
/// </para>
/// <para>
/// 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 <see cref="StartPageUrl"/> — the site's home when connected, the login
/// page when not connected or after a disconnection.
/// </para>
/// <para>
/// 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)
/// <param name="browser">The browser of Febe.</param>
/// <param name="storage">The database (first connection, «Scollega»).</param>
/// <param name="tracker">When Alberto last used the browser.</param>
/// <param name="clock">The composition's clock.</param>
/// <param name="log">Febe's log.</param>
/// <param name="loginUrl">The page «Accedi a Instagram» opens.</param>
/// <param name="homeUrl">The site's home, the start page once connected.</param>
/// <param name="cookie">The session cookie looked for (its name only).</param>
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
}
}
/// <summary>
/// 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.
/// </summary>
public string StartPageUrl =>
IsConnected == true && _engine?.Services.Breaker.State.Status != BreakerStatus.Disconnected ? _homeUrl : _loginUrl;
/// <summary>
/// Hook for the readers (hypothesis H10): when the data of the page tell which account is connected, the composition
/// marks it as «Tu» (<see cref="Account.IsMine"/>); the status shows that account. Raised after every change of the
@@ -104,6 +128,12 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
/// </summary>
public TimeSpan DrivingGrace { get; set; } = TimeSpan.FromMinutes(2);
/// <summary>
/// How long Alberto's page waits for its turn while a step of the profile search holds it (real time). Read at every
/// wait; tests shorten it.
/// </summary>
public TimeSpan PageTurnWait { get; set; } = TimeSpan.FromSeconds(15);
/// <summary>The engine, once it exists (it is built after the browser).</summary>
public void AttachEngine(EngineHost engine) => _engine = engine ?? throw new ArgumentNullException(nameof(engine));
@@ -150,21 +180,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 +191,116 @@ 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();
}
}
/// <summary>
/// «Pagina iniziale» of the window's bar and of the remote view (issue #52): Alberto's own navigation (rule 7) to
/// <see cref="StartPageUrl"/>, as when he takes the browser from the rest page — after the engine's session ended and
/// with the page's turn, so that no step of a session or of the profile search has its page swapped under it. Only
/// while he is at the browser: otherwise the page is the engine's and nothing happens.
/// </summary>
/// <param name="ct">
/// Cancelled when the lease of whoever pressed the button ends (the window closed, the remote view closed): the press
/// is then forgotten, whatever it was waiting for.
/// </param>
/// <remarks>
/// The waits can last up to <see cref="PageTurnWait"/> and more: Alberto may have let go of the browser meanwhile, and
/// then the page is the engine's again (rules 7 and 8: no navigation without his lease, outside the Governor). So
/// right before navigating, with the page's turn in hand, it looks again: he still drives and the caller's lease still
/// holds. Without the page's turn (a step of the search kept it) nothing happens either: the page is not taken from
/// under the step.
/// </remarks>
public async Task OpenStartPageAsync(CancellationToken ct)
{
if (!_browser.IsAvailable)
{
return;
}
try
{
await _commands.WaitAsync(ct).ConfigureAwait(false);
}
catch (OperationCanceledException) when (ct.IsCancellationRequested)
{
return;
}
try
{
if (!_browser.UserIsDriving)
{
return;
}
await WaitForSessionEndAsync(ct).ConfigureAwait(false);
using var turn = await TakePageAsync(ct).ConfigureAwait(false);
if (_engine is not null && turn is null)
{
_log.Info("collegamento", "«Pagina iniziale» non aperta: la pagina è ancora occupata dalla ricerca dei profili. Riprova fra poco.");
return;
}
// The last look, with the page's turn in hand (no recipe and no search step can open a page until it is given
// back): Alberto still drives and the caller's lease still holds.
if (ct.IsCancellationRequested || !_browser.UserIsDriving)
{
_log.Info("collegamento", "«Pagina iniziale» non aperta: nel frattempo hai lasciato il browser.");
return;
}
var target = StartPageUrl;
var what = target == _loginUrl ? "pagina di accesso" : "pagina iniziale del sito";
var result = await _browser.Cdp.NavigateAsync(target, ct).ConfigureAwait(false);
_log.Info("collegamento", result.Succeeded
? $"«Pagina iniziale»: {what} aperta."
: $"«Pagina iniziale»: {what} non aperta (errore di rete del browser).");
}
catch (OperationCanceledException) when (ct.IsCancellationRequested)
{
_log.Info("collegamento", "«Pagina iniziale» non aperta: nel frattempo hai lasciato il browser.");
}
finally
{
_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<FinishResult> FinishAsync(CancellationToken ct)
{
await _commands.WaitAsync(ct).ConfigureAwait(false);
@@ -305,16 +431,18 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
/// <summary>
/// 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 <paramref name="mayReport"/> 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).
/// </summary>
public async Task<bool?> RefreshAsync(CancellationToken ct)
public async Task<bool?> 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 +656,64 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
return true;
}
/// <summary>
/// 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.
/// </summary>
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).");
}
/// <summary>The empty rest page (or no document at all): never what Alberto should be shown.</summary>
private static bool IsRest(string? url) => url is "" or CdpPageExtensions.RestUrl;
/// <summary>The address of the main frame, in full (never logged); null when the browser does not answer.</summary>
private async Task<string?> 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)
@@ -543,8 +729,9 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
}
/// <summary>
/// The page turn for Alberto's login page, so that no step of the profile search runs under it; after 15 seconds
/// the page is taken anyway (Alberto asked for it), and null comes back.
/// The page turn for Alberto's own navigation, so that no step of the profile search runs under it; null after
/// <see cref="PageTurnWait"/> (and always without an engine). The login and the start page from the rest page then
/// take the page anyway (Alberto asked for it, under his lease); «Pagina iniziale» gives up.
/// </summary>
private async Task<PageTurn?> TakePageAsync(CancellationToken ct)
{
@@ -554,7 +741,7 @@ public sealed class BrowserConnectionService : IConnectionService, IAsyncDisposa
}
using var limit = CancellationTokenSource.CreateLinkedTokenSource(ct);
limit.CancelAfter(TimeSpan.FromSeconds(15));
limit.CancelAfter(PageTurnWait);
try
{
return await engine.Services.PageTurns.TakeAsync(PageUser.Engine, limit.Token).ConfigureAwait(false);
+11 -3
View File
@@ -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);
// «Pagina iniziale» (issue #52) is the connection's, which exists only after the browser: looked up when pressed.
var context = new FebePlatformContext(o, data, Database, Clock, Log, Tracker, ct => Connection?.OpenStartPageAsync(ct) ?? Task.CompletedTask);
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
}
}
/// <summary>The site's home page as the browser writes it (with its final slash), for «Pagina iniziale».</summary>
private static string HomeUrl(string baseUrl) =>
Uri.TryCreate(baseUrl, UriKind.Absolute, out var home) ? home.AbsoluteUri : baseUrl;
/// <summary>
/// Development with the test site only (<c>--accesso-di-prova</c>): what Alberto does by hand on Instagram — open
/// the site once, so that its session cookie exists — then back to the rest page.
+3 -2
View File
@@ -101,7 +101,8 @@ public sealed partial class FebeLog : IDisposable
}
/// <summary>The adapter for the browser layer (it logs only CDP command names, states and counts).</summary>
public IBrowserLog ForBrowser() => new DelegateBrowserLog((level, message, exception) => Write(
/// <param name="category">The category of the lines (the remote view writes as «vista»).</param>
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));
+6 -1
View File
@@ -55,7 +55,12 @@ public interface IFebePlatform
/// <param name="Clock">The clock of the engine.</param>
/// <param name="Log">The log.</param>
/// <param name="Tracker">When Alberto last used the browser: the desktop window marks it when he uses and closes it.</param>
public sealed record FebePlatformContext(FebeAppOptions Options, DataFolderLayout Data, IFebeStorage Storage, IClock Clock, FebeLog Log, BrowserUseTracker Tracker);
/// <param name="OpenStartPage">
/// What «Pagina iniziale» of the browser window does (issue #52): the connection opens the site's home when connected,
/// the login page otherwise, once the engine's session ended and with the page's turn
/// (<c>BrowserConnectionService.OpenStartPageAsync</c>). Null: the button does nothing.
/// </param>
public sealed record FebePlatformContext(FebeAppOptions Options, DataFolderLayout Data, IFebeStorage Storage, IClock Clock, FebeLog Log, BrowserUseTracker Tracker, Func<CancellationToken, Task>? OpenStartPage = null);
/// <summary>Options of the shared composition, filled by each shell from its own configuration.</summary>
public sealed record FebeAppOptions
+4
View File
@@ -47,6 +47,10 @@ public sealed class ProblemConnectionService(IReadOnlyList<ConfigurationProblem>
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() =>
@@ -66,7 +66,7 @@ public sealed class RemoteViewSession : IAsyncDisposable
/// <param name="cdp">The page session.</param>
/// <param name="gate">Where the «Alberto is driving» lease is taken.</param>
/// <param name="log">Where opening and closing are noted (never keys).</param>
/// <param name="log">Where the frames' starts, restarts and silences are noted (never keys).</param>
/// <param name="clock">Wall-clock time for the screencast's start attempts; null: the system clock.</param>
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()
+462 -27
View File
@@ -1,3 +1,4 @@
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Text.Json;
using System.Text.Json.Nodes;
@@ -13,7 +14,37 @@ namespace Febe.Browser.RemoteView;
/// <param name="MaxWidth">Largest frame width in pixels.</param>
/// <param name="MaxHeight">Largest frame height in pixels.</param>
/// <param name="EveryNthFrame">Send one frame out of this many.</param>
public sealed record ScreencastOptions(int Quality = 70, int MaxWidth = 1280, int MaxHeight = 900, int EveryNthFrame = 1);
/// <param name="Watchdog">How missing frames are noticed and the frames started again; null: never (issue #52).</param>
public sealed record ScreencastOptions(int Quality = 70, int MaxWidth = 1280, int MaxHeight = 900, int EveryNthFrame = 1, ScreencastWatchdog? Watchdog = null);
/// <summary>
/// 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 <see cref="Silence"/> 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 no frame came within
/// <see cref="FirstFrameWait"/> of the start (Chromium sends the first frame only after answering the start). Each restart
/// doubles the wait, up to <see cref="LongestSilence"/>: 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 (<see cref="FlowingFrames"/> after a
/// restart) or a new document bring the wait back to <see cref="Silence"/>.
/// </summary>
/// <param name="Silence">Time without frames before the first restart.</param>
/// <param name="Tick">How often the watchdog looks.</param>
/// <param name="LongestSilence">The longest wait between two restarts without frames.</param>
public sealed record ScreencastWatchdog(TimeSpan Silence, TimeSpan Tick, TimeSpan LongestSilence)
{
/// <summary>
/// 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.
/// </summary>
public const int FlowingFrames = 3;
/// <summary>How long a restart waits for its first frame before it sends a still picture instead.</summary>
public static readonly TimeSpan FirstFrameWait = TimeSpan.FromMilliseconds(500);
/// <summary>About two seconds, looked at four times a second, at most half a minute between restarts.</summary>
public static ScreencastWatchdog Default { get; } = new(TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(250), TimeSpan.FromSeconds(30));
}
/// <summary>One frame of the remote view.</summary>
/// <param name="Jpeg">The image.</param>
@@ -24,6 +55,7 @@ public sealed record ScreencastOptions(int Quality = 70, int MaxWidth = 1280, in
/// <param name="ScrollOffsetX">Horizontal scroll position.</param>
/// <param name="ScrollOffsetY">Vertical scroll position.</param>
/// <param name="Timestamp">Browser timestamp (seconds), when given.</param>
/// <param name="Still">True for a still picture (<c>Page.captureScreenshot</c>) sent because no frame came.</param>
public sealed record ScreencastFrame(
byte[] Jpeg,
double DeviceWidth,
@@ -32,7 +64,8 @@ public sealed record ScreencastFrame(
double OffsetTop,
double ScrollOffsetX,
double ScrollOffsetY,
double? Timestamp);
double? Timestamp,
bool Still = false);
/// <summary>
/// The remote view's video (spec §4.1, §11): <c>Page.startScreencast</c> in JPEG, every frame acknowledged with
@@ -40,9 +73,16 @@ public sealed record ScreencastFrame(
/// <see cref="ReadFramesAsync"/> (only the latest ones are kept when the reader is slow) and <see cref="FrameReceived"/>.
/// </summary>
/// <remarks>
/// <para>
/// 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 <see cref="InactivePageBudget"/>. Any other failure is reported at once.
/// </para>
/// <para>
/// With a <see cref="ScreencastWatchdog"/> the frames are started again when they stop coming (issue #52): after a
/// silence, and when the main frame finished loading a new document (<c>Page.loadEventFired</c>) 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.
/// </para>
/// </remarks>
public sealed class ScreencastSession : IAsyncDisposable
{
@@ -60,15 +100,33 @@ public sealed class ScreencastSession : IAsyncDisposable
private readonly Channel<int> _acks = Channel.CreateUnbounded<int>(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<IDisposable> _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;
private TaskCompletionSource? _nextFrame;
/// <param name="cdp">The page session.</param>
/// <param name="log">Where the start and stop are noted (never parameters or frames).</param>
/// <param name="clock">Wall-clock time for the pauses between start attempts; null: the system clock.</param>
/// <param name="log">Where starts, restarts and silences are noted (never parameters or frames).</param>
/// <param name="clock">Wall-clock time for the pauses between start attempts and the watchdog; null: the system clock.</param>
public ScreencastSession(ICdpSession cdp, IBrowserLog? log = null, IClock? clock = null)
{
_cdp = cdp ?? throw new ArgumentNullException(nameof(cdp));
@@ -79,11 +137,15 @@ public sealed class ScreencastSession : IAsyncDisposable
/// <summary>Raised on the browser event thread for every frame: handlers must be quick.</summary>
public event EventHandler<ScreencastFrame>? FrameReceived;
/// <summary>The last frame received, for mapping input coordinates.</summary>
/// <summary>The last frame received (or still picture sent), for mapping input coordinates.</summary>
public ScreencastFrame? LastFrame { get; private set; }
/// <summary>Frames of the screencast received so far (still pictures not counted).</summary>
public long FramesReceived => Interlocked.Read(ref _framesReceived);
/// <summary>How many times the watchdog started the frames again.</summary>
public long Restarts => Interlocked.Read(ref _restarts);
public async Task StartAsync(ScreencastOptions? options = null, CancellationToken ct = default)
{
if (_subscription is not null)
@@ -100,7 +162,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.");
}
/// <summary>Frames as they arrive; the oldest are dropped if the reader falls behind. Ends when the session stops.</summary>
@@ -124,31 +199,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 +246,55 @@ public sealed class ScreencastSession : IAsyncDisposable
{
await StopAsync().ConfigureAwait(false);
_lifetime.Dispose();
_starts.Dispose();
}
/// <summary>The width and height written in a JPEG's frame header (SOFn), or null when the data has none.</summary>
internal static (int Width, int Height)? JpegSize(ReadOnlySpan<byte> 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 +319,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 +343,274 @@ public sealed class ScreencastSession : IAsyncDisposable
private void OnReconnected(object? sender, EventArgs e) =>
_ = Task.Run(async () =>
{
// Read inside the try: a browser restart that races the dispose finds the source disposed.
var ct = CancellationToken.None;
try
{
await SendStartAsync(_lifetime.Token).ConfigureAwait(false);
ct = _lifetime.Token;
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);
}
});
/// <summary>
/// The watchdog: every <see cref="ScreencastWatchdog.Tick"/> it looks how long no frame came; past the allowed
/// silence (or when a new document loaded without frames) it starts the frames again.
/// </summary>
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}).");
}
}
}
/// <summary>
/// Stop and start again (a new screencast session), then one still picture when no frame came within
/// <see cref="ScreencastWatchdog.FirstFrameWait"/>. The silence counts from the start; the wait for the next restart
/// doubles here, before the start, so that frames flowing meanwhile bring it back to the short one.
/// </summary>
private async Task RestartAsync(ScreencastWatchdog watchdog, TimeSpan silence, bool afterLoad, CancellationToken ct)
{
await _starts.WaitAsync(ct).ConfigureAwait(false);
var started = false;
TaskCompletionSource? nextFrame = null;
try
{
bool first;
lock (_watch)
{
first = !_silent;
if (first)
{
_silent = true;
_silentSince = _clock.Now - silence;
}
_restartWanted = false;
_framesSinceRestart = 0;
var longer = _silenceLimit + _silenceLimit;
_silenceLimit = longer < watchdog.LongestSilence ? longer : watchdog.LongestSilence;
}
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);
}
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.
}
// Ready before the start: its first frame may come as soon as Chromium has answered.
nextFrame = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
lock (_watch)
{
_nextFrame = nextFrame;
}
await SendStartAsync(ct).ConfigureAwait(false);
lock (_watch)
{
_watchFrom = _clock.Now;
}
started = true;
Interlocked.Increment(ref _restarts);
if (!await FrameWithinAsync(nextFrame.Task, ScreencastWatchdog.FirstFrameWait, ct).ConfigureAwait(false))
{
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)
{
if (!started)
{
_watchFrom = _clock.Now; // a failed restart: the next one after a whole silence, not at the next look
}
if (ReferenceEquals(_nextFrame, nextFrame))
{
_nextFrame = null;
}
}
_starts.Release();
}
}
/// <summary>True when <paramref name="frame"/> completes within <paramref name="wait"/> (on the clock).</summary>
private async Task<bool> FrameWithinAsync(Task frame, TimeSpan wait, CancellationToken ct)
{
if (frame.IsCompleted)
{
return true;
}
using var stopWaiting = CancellationTokenSource.CreateLinkedTokenSource(ct);
var delay = _clock.Delay(wait, stopWaiting.Token);
await Task.WhenAny(frame, delay).ConfigureAwait(false);
// Asked of the frame itself, not of which task woke the wait: both may be done by now, and a frame is a frame.
if (frame.IsCompleted)
{
// The pause ends here (a clock that moves only when asked keeps no sleeper behind).
await stopWaiting.CancelAsync().ConfigureAwait(false);
return true;
}
await delay.ConfigureAwait(false); // cancelled with ct: the restart ends there
return false;
}
/// <summary>
/// One picture of the page as it is (<c>Page.captureScreenshot</c>, already allowed for the preview): a page that
/// does not repaint shows something, and the pointer can be placed on it.
/// </summary>
private async Task SendStillAsync(CancellationToken ct)
{
var before = FramesReceived;
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;
}
if (FramesReceived != before)
{
// A real frame came during the capture: it is newer and carries the page's scroll and zoom.
_log.Debug("Vista remota: immagine ferma scartata, è arrivato un fotogramma.");
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 +637,37 @@ 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;
_nextFrame?.TrySetResult();
_nextFrame = null;
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 +682,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;
}
+6 -21
View File
@@ -152,7 +152,7 @@ public sealed class DesktopPlatform : IFebePlatform
ArgumentNullException.ThrowIfNull(services);
ArgumentNullException.ThrowIfNull(app);
services.AddSingleton(_shell.Native);
services.AddSingleton<IBrowserWindow>(new DesktopBrowserWindow(() => app.Browser));
services.AddSingleton<IBrowserWindow>(new DesktopBrowserWindow());
services.AddSingleton<IDataFolderChange>(new DesktopDataFolderChange(_locations, app.Options.DataFolder, _dataFolderFixed));
}
@@ -200,29 +200,14 @@ public sealed class DesktopPlatform : IFebePlatform
}
/// <summary>
/// «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 (<c>IConnectionService.ShowBrowserAsync</c>, 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).
/// </summary>
public sealed class DesktopBrowserWindow(Func<IFebeBrowser?> 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);
}
}
/// <summary>
+177 -20
View File
@@ -3,21 +3,47 @@ using System.Windows;
using System.Windows.Controls;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Threading;
using Febe.Desktop.Native;
namespace Febe.Desktop.Browser;
/// <summary>
/// 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.
/// </summary>
/// <remarks>
/// <para>
/// 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 <see cref="MinimizedLimit"/> it is put out of view as if
/// he had closed it, restored there without coming on screen. 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
/// (<see cref="Fit"/>), always with the same size in CSS pixels; out of view the page is at 100% again, so that the
/// engine's pages always see the same browser. While the page is the empty rest page the bar says so.
/// </para>
/// <para>
/// WPF changes the taskbar button of a shown window by hiding it and showing it again (seen in WM_WINDOWPOSCHANGED:
/// SWP_HIDEWINDOW, then SWP_SHOWWINDOW). The button is therefore changed only while the window is out of view: before it
/// comes on screen, after it left.
/// </para>
/// </remarks>
internal sealed class BrowserWindow : Window
{
/// <summary>Height of the bar under the page, in device-independent pixels.</summary>
public const double BarHeight = 40;
/// <summary>The smallest zoom the page is shown at when the screen is small.</summary>
public const double SmallestFit = 0.4;
/// <summary>What the bar says while the page is the empty rest page.</summary>
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 +57,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 +67,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 +86,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();
}
/// <summary>Width of the page in device-independent pixels (CSS pixels of the page at zoom 100%).</summary>
@@ -82,15 +117,30 @@ internal sealed class BrowserWindow : Window
public int PageHeight { get; }
/// <summary>
/// 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).
/// </summary>
public double Fit { get; private set; } = 1;
/// <summary>How long the window may stay minimised before it is put out of view as «ho finito» (S2).</summary>
public TimeSpan MinimizedLimit { get; set; } = TimeSpan.FromMinutes(2);
/// <summary>Raised by «Indietro».</summary>
public event EventHandler? BackRequested;
/// <summary>Raised by «Ricarica».</summary>
public event EventHandler? ReloadRequested;
/// <summary>Raised when Alberto closes or minimises the window: the owner puts it out of view.</summary>
/// <summary>Raised by «Pagina iniziale».</summary>
public event EventHandler? HomeRequested;
/// <summary>Raised when Alberto closes the window, or leaves it minimised too long: the owner puts it out of view.</summary>
public event EventHandler? DoneRequested;
/// <summary>Raised when the page area changed size (a new fit): the owner sizes WebView2 again.</summary>
public event EventHandler? PageAreaChanged;
/// <summary>The window handle (created on first use).</summary>
public IntPtr Handle => new WindowInteropHelper(this).EnsureHandle();
@@ -98,40 +148,102 @@ internal sealed class BrowserWindow : Window
public double Scale => VisualTreeHelper.GetDpi(this).DpiScaleX;
/// <summary>Where WebView2 draws, in physical pixels of the client area.</summary>
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));
/// <summary>True while the window is on a screen, false while it is parked out of view.</summary>
public bool IsOnScreen =>
Left < SystemParameters.VirtualScreenLeft + SystemParameters.VirtualScreenWidth
&& Left + ActualWidth > SystemParameters.VirtualScreenLeft;
/// <summary>Shows the address of the page, without query string or fragment (they may carry tokens).</summary>
public void ShowAddress(string? address) => _address.Text = address ?? string.Empty;
/// <summary>The text the bar shows now (the address, or <see cref="RestNotice"/>).</summary>
public string AddressText => _address.Text;
/// <summary>Centres the window on the work area of the primary screen.</summary>
/// <summary>
/// The zoom at which a page of <paramref name="pageWidth"/>×<paramref name="pageHeight"/> plus its bar and the
/// window's frame fits in an area of <paramref name="areaWidth"/>×<paramref name="areaHeight"/> (all in
/// device-independent pixels): 1 when it fits, never below <see cref="SmallestFit"/>.
/// </summary>
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);
}
/// <summary>
/// Shows the address of the page, without query string or fragment (they may carry tokens); on the empty rest page,
/// <see cref="RestNotice"/>.
/// </summary>
public void ShowAddress(string? address) =>
_address.Text = address is null or "" or "about:blank" ? RestNotice : address;
/// <summary>
/// Centres the window on the work area of the primary screen, shrunk to fit it when needed, with its taskbar button.
/// </summary>
public void MoveOnScreen()
{
var area = SystemParameters.WorkArea;
var width = ActualWidth > 0 ? ActualWidth : PageWidth;
var height = ActualHeight > 0 ? ActualHeight : PageHeight + BarHeight;
FitTo(area);
// Still out of view: the hide and show with which WPF adds the button happen where nobody sees them.
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);
}
/// <summary>
/// Parks the window just right of every screen: open, «visible» for Windows and for WebView2, out of Alberto's view
/// (S2). Never <c>Hide()</c> and never minimised.
/// (S2), without its taskbar button and with the page at 100% (<see cref="Fit"/> 1). Never <c>Hide()</c>, never
/// left minimised: a minimised window is restored without taking the focus and cloaked meanwhile, because Windows
/// restores it where it was on screen (a restore position off every screen is moved back onto one).
/// </summary>
public void MoveOffScreen()
{
Left = SystemParameters.VirtualScreenLeft + SystemParameters.VirtualScreenWidth + 64;
Top = SystemParameters.VirtualScreenTop;
_minimized.Stop();
var restoring = WindowState == WindowState.Minimized;
var cloaked = restoring && Cloak(true);
try
{
if (restoring)
{
Win32.ShowWindow(Handle, Win32.SwShowNoActivate);
if (WindowState == WindowState.Minimized)
{
WindowState = WindowState.Normal;
}
}
Left = SystemParameters.VirtualScreenLeft + SystemParameters.VirtualScreenWidth + 64;
Top = SystemParameters.VirtualScreenTop;
// Out of view first: the hide and show with which WPF removes the button happen where nobody sees them.
ShowInTaskbar = false;
}
finally
{
if (cloaked)
{
Cloak(false);
}
}
// The engine's pages see the browser as it is, at 100%, whatever the size of Alberto's screen (rule 4).
SetFit(1);
}
/// <summary>Lets the window really close (Febe is stopping).</summary>
public void CloseForGood()
{
_allowClose = true;
_minimized.Stop();
Close();
}
@@ -151,14 +263,59 @@ 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)
{
// Restored out of view by the owner (MoveOffScreen), never first on screen where it was.
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;
SetFit(FitFor(area.Width, area.Height, PageWidth, PageHeight, frame.Left + frame.Right + resize.Left + resize.Right, frame.Top + frame.Bottom + resize.Top + resize.Bottom));
}
private void SetFit(double fit)
{
if (Math.Abs(fit - Fit) < 0.001)
{
return;
}
Fit = fit;
_page.Width = PageWidth * fit;
_page.Height = PageHeight * fit;
UpdateLayout();
PageAreaChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary>Cloaks or uncloaks the window (DWM); false when DWM refused.</summary>
private bool Cloak(bool on)
{
var value = on ? 1 : 0;
return Win32.DwmSetWindowAttribute(Handle, Win32.DwmCloak, ref value, sizeof(int)) == 0;
}
private static Button BarButton(string text, string tip) => new()
{
Content = text,
+1 -1
View File
@@ -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.OpenStartPage),
context.Log);
Host.BrowserProcessFailed += (_, _) => RequestRestart(null);
}
+195 -19
View File
@@ -9,6 +9,7 @@ using Febe.Browser.Hosting;
using Febe.Browser.WebView2;
using Febe.Core.Abstractions;
using Febe.Desktop.Core;
using Febe.Desktop.Native;
using Microsoft.Web.WebView2.Core;
namespace Febe.Desktop.Browser;
@@ -18,7 +19,27 @@ namespace Febe.Desktop.Browser;
/// <param name="AdditionalBrowserArguments">The switches of S2 (<see cref="BrowserArguments.ForWebView2"/>).</param>
/// <param name="Icon">The icon of the window.</param>
/// <param name="MarkUsed">Called when Alberto uses the browser and when he is done with it («Riprendi»).</param>
internal sealed record WebView2HostOptions(BrowserHosting Hosting, string AdditionalBrowserArguments, ImageSource? Icon, Action MarkUsed);
/// <param name="OpenStartPage">
/// What «Pagina iniziale» does (issue #52): the connection opens the site's home when connected, the login page otherwise,
/// once the engine's session ended and with the page's turn. Null: the button does nothing.
/// </param>
internal sealed record WebView2HostOptions(BrowserHosting Hosting, string AdditionalBrowserArguments, ImageSource? Icon, Action MarkUsed, Func<CancellationToken, Task>? OpenStartPage = null);
/// <summary>What the host does when a process of WebView2 fails (issue #52).</summary>
internal enum ProcessFailureResponse
{
/// <summary>Nothing: WebView2 recovers by itself (an unresponsive page while Alberto looks at it, a helper process).</summary>
None,
/// <summary>The whole browser is gone: the owner starts it again.</summary>
Restart,
/// <summary>The page crashed (or hangs while nobody looks): back to the rest page (spec §6.1).</summary>
Rest,
/// <summary>The GPU process restarted: the page is resized by a pixel and back, or the window may stay blank or black.</summary>
Redraw,
}
/// <summary>
/// The browser host of the Windows edition (spec §5, §6.1, §12): WebView2 in the window «Browser di Febe», with its own
@@ -36,6 +57,9 @@ internal sealed record WebView2HostOptions(BrowserHosting Hosting, string Additi
/// «Ho finito»; using and closing it marks the browser as used for «Riprendi».</item>
/// <item>Stopping closes the WebView and waits for its browser process to exit, so the session is on disk (S3);
/// <see cref="RestartAsync"/> («Scollega») does the same before deleting the profile.</item>
/// <item>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.</item>
/// <item>Threads: every WebView2 object (environment, controller, <c>CoreWebView2</c>, 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
@@ -71,6 +95,7 @@ internal sealed class WebView2Host : IBrowserHost
private CoreWebView2DevTools? _devTools;
private TaskCompletionSource? _exited;
private IDisposable? _lease;
private CancellationTokenSource? _leaseEnded;
private int _generation;
private bool _starting;
private bool _crashedWhileStarting;
@@ -147,12 +172,22 @@ 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, and paints
// again (WPF hid and showed the window, out of view, to give it its taskbar button).
UpdateBounds();
Repaint();
try
{
_controller?.MoveFocus(CoreWebView2MoveFocusReason.Programmatic);
@@ -169,9 +204,24 @@ internal sealed class WebView2Host : IBrowserHost
{
_window?.MoveOffScreen();
ReleaseLease();
NotifyPositionChanged();
return Task.CompletedTask;
});
/// <summary>
/// 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.
/// </summary>
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,
};
/// <summary>
/// Closes the WebView, waits for its browser process to exit (the profile is free and written), runs
/// <paramref name="whileStopped"/> — «Scollega» deletes the profile there — and starts it again. <see cref="Cdp"/>
@@ -302,7 +352,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 += (_, _) => OpenStartPage();
window.DpiChanged += (_, _) => UpdateBounds();
window.PageAreaChanged += (_, _) => UpdateBounds();
// The raw controller does not follow its parent by itself: popups (lists of a <select>, menus, suggestions)
// would open where the window was, out of view.
window.LocationChanged += (_, _) => NotifyPositionChanged();
window.ShowAddress(null);
_window = window;
}
@@ -336,6 +393,7 @@ internal sealed class WebView2Host : IBrowserHost
controller.BoundsMode = CoreWebView2BoundsMode.UseRawPixels;
controller.Bounds = _window.PageBounds;
controller.ZoomFactor = _window.Fit;
// WebView2 stops painting when IsVisible is false (S2): it stays true for the whole life of the browser.
controller.IsVisible = true;
@@ -436,24 +494,39 @@ internal sealed class WebView2Host : IBrowserHost
return;
}
if (kind == CoreWebView2ProcessFailedKind.BrowserProcessExited)
switch (ResponseTo(kind, UserIsDriving))
{
// The whole browser is gone: commands fail from now on, and the owner starts it again (same profile), as
// the supervisor does with Chromium — once this handler has returned (threading model of WebView2).
_session.Detach();
_ = _ui.InvokeAsync(() => BrowserProcessFailed?.Invoke(this, EventArgs.Empty), DispatcherPriority.Background);
}
else if (kind is CoreWebView2ProcessFailedKind.RenderProcessExited or CoreWebView2ProcessFailedKind.RenderProcessUnresponsive)
{
// The page crashed: back to the rest page (spec §6.1); a running recipe ends on its own errors.
try
{
(sender as CoreWebView2)?.Navigate(CdpPageExtensions.RestUrl);
}
catch (Exception ex) when (ex is COMException or InvalidOperationException)
{
// The browser went with the page: its own ProcessFailed follows.
}
case ProcessFailureResponse.Restart:
// The whole browser is gone: commands fail from now on, and the owner starts it again (same profile), as
// the supervisor does with Chromium — once this handler has returned (threading model of WebView2).
_session.Detach();
_ = _ui.InvokeAsync(() => BrowserProcessFailed?.Invoke(this, EventArgs.Empty), DispatcherPriority.Background);
break;
case ProcessFailureResponse.Rest:
// The page crashed: back to the rest page (spec §6.1); a running recipe ends on its own errors.
try
{
(sender as CoreWebView2)?.Navigate(CdpPageExtensions.RestUrl);
}
catch (Exception ex) when (ex is COMException or InvalidOperationException)
{
// The browser went with the page: its own ProcessFailed follows.
}
break;
case ProcessFailureResponse.Redraw:
// A windowed WebView can stay blank or black after the GPU process restarted until its size changes: the
// same bounds again may be no change at all, so one pixel less and then the real ones (never
// IsVisible = false, S2), once this handler has returned.
_ = _ui.InvokeAsync(Redraw, DispatcherPriority.Background);
break;
default:
if (kind == CoreWebView2ProcessFailedKind.RenderProcessUnresponsive)
{
_log.Info("browser", "WebView2: la pagina non risponde mentre usi il browser; Febe la lascia com'è (Ricarica, se non si riprende).");
}
break;
}
}
@@ -481,11 +554,12 @@ internal sealed class WebView2Host : IBrowserHost
TakeLease();
}
/// <summary>Alberto closed or minimised the window: done, out of view.</summary>
/// <summary>Alberto closed the window (or left it minimised too long): done, out of view.</summary>
private void Done()
{
_window?.MoveOffScreen();
ReleaseLease();
NotifyPositionChanged();
}
private void UserNavigation(Action<CoreWebView2> action, Func<CoreWebView2, bool> allowed)
@@ -510,6 +584,82 @@ internal sealed class WebView2Host : IBrowserHost
}
}
/// <summary>
/// «Pagina iniziale»: Alberto's own navigation (rule 7), done by the connection, which first waits for the engine's
/// session to end and takes the page's turn (issue #52).
/// </summary>
private void OpenStartPage()
{
if (_settings.OpenStartPage is not { } open || _core is null)
{
return;
}
TakeLease();
// The press lasts as long as this lease: closed meanwhile, the window gives the page back to the engine and the
// connection forgets the press (rules 7 and 8).
_ = OpenStartPageQuietlyAsync(open, _leaseEnded!.Token);
}
private async Task OpenStartPageQuietlyAsync(Func<CancellationToken, Task> open, CancellationToken whileLeased)
{
try
{
await open(whileLeased).ConfigureAwait(true);
}
catch (OperationCanceledException) when (whileLeased.IsCancellationRequested)
{
// The window went out of view before the start page could open: nothing to say.
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
_log.Warn("browser", $"«Pagina iniziale» non aperta ({ex.GetType().Name}).");
}
}
/// <summary>After a GPU restart: a real change of size (one pixel less), then the real bounds and a repaint.</summary>
private void Redraw()
{
if (_controller is not { } controller || _window is not { } window)
{
return;
}
try
{
var bounds = window.PageBounds;
if (bounds.Height > 1)
{
controller.Bounds = bounds with { Height = bounds.Height - 1 };
}
}
catch (Exception ex) when (ex is COMException or InvalidOperationException)
{
// The browser process is gone: the next start sizes the new WebView.
return;
}
_ = _ui.InvokeAsync(
() =>
{
UpdateBounds();
Repaint();
},
DispatcherPriority.Background);
}
/// <summary>Asks the window and WebView2's child windows to paint again; nothing the page can see changes.</summary>
private void Repaint()
{
if (_window is { } window)
{
// Only invalidated, never painted at once (RDW_UPDATENOW): the children belong to WebView2's browser process,
// and a hung one would hold the UI thread in a synchronous paint.
Win32.RedrawWindow(window.Handle, IntPtr.Zero, IntPtr.Zero, Win32.RdwInvalidate | Win32.RdwAllChildren);
}
}
private void UpdateBounds()
{
if (_controller is not { } controller || _window is not { } window)
@@ -520,6 +670,10 @@ internal sealed class WebView2Host : IBrowserHost
try
{
controller.Bounds = window.PageBounds;
// Shrunk to fit a small screen, the page is zoomed out by as much: its size in CSS pixels stays the same.
controller.ZoomFactor = window.Fit;
controller.NotifyParentWindowPositionChanged();
}
catch (Exception ex) when (ex is COMException or InvalidOperationException)
{
@@ -527,11 +681,24 @@ internal sealed class WebView2Host : IBrowserHost
}
}
private void NotifyPositionChanged()
{
try
{
_controller?.NotifyParentWindowPositionChanged();
}
catch (Exception ex) when (ex is COMException or InvalidOperationException)
{
// The browser process is gone: the next start places the new WebView.
}
}
private void TakeLease()
{
if (_lease is null)
{
_lease = UserDriving.Begin();
_leaseEnded = new CancellationTokenSource();
_log.Info("browser", "Alberto usa il browser di Febe: il motore resta fermo.");
}
@@ -545,6 +712,15 @@ internal sealed class WebView2Host : IBrowserHost
_lease = null;
_settings.MarkUsed();
lease.Dispose();
// Off the UI thread: whatever waited on this lease (a «Pagina iniziale» in progress) gives up there. The source
// has no timer and is never disposed, so a late look at its token is still safe.
if (_leaseEnded is { } ended)
{
_leaseEnded = null;
_ = ended.CancelAsync();
}
_log.Info("browser", "Browser di Febe fuori vista.");
}
}
+14
View File
@@ -66,6 +66,20 @@ internal static class Win32
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsIconic(IntPtr window);
public const uint RdwInvalidate = 0x0001;
public const uint RdwAllChildren = 0x0080;
/// <summary>DWMWA_CLOAK: the window stays shown for Windows but DWM does not put it on screen.</summary>
public const int DwmCloak = 13;
/// <summary>Asks a window and its children (WebView2's own) to paint again, without changing anything else.</summary>
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool RedrawWindow(IntPtr window, IntPtr updateRect, IntPtr updateRegion, uint flags);
[DllImport("dwmapi.dll")]
public static extern int DwmSetWindowAttribute(IntPtr window, int attribute, ref int value, int size);
[DllImport("user32.dll")]
public static extern IntPtr SetCursor(IntPtr cursor);
+116 -11
View File
@@ -2,6 +2,7 @@ using System.Runtime.CompilerServices;
using System.Text.Json;
using Febe.App;
using Febe.Browser.Cdp;
using Febe.Browser.Diagnostics;
using Febe.Browser.Gestures;
using Febe.Browser.RemoteView;
using Febe.Core.Abstractions;
@@ -24,6 +25,7 @@ internal sealed class BrowserRemoteViewHost : IRemoteViewHost
private readonly IClock _clock;
private readonly IClock _browserClock;
private readonly FebeLog _log;
private readonly Func<CancellationToken, Task>? _openStartPage;
private readonly Lock _gate = new();
private readonly SemaphoreSlim _opening = new(1, 1);
private BrowserRemoteViewConnection? _current;
@@ -34,18 +36,29 @@ internal sealed class BrowserRemoteViewHost : IRemoteViewHost
/// <param name="clock">The composition's clock (the time of that note).</param>
/// <param name="log">Febe's log.</param>
/// <param name="browserClock">
/// Time for the waits on the browser itself; null: the wall clock, because the browser commits a navigation in real
/// time whatever clock the engine runs on (the tests compress it).
/// Time for the waits on the browser itself and for the frames' watchdog; null: the wall clock, because the browser
/// commits a navigation and paints in real time whatever clock the engine runs on (the tests compress it).
/// </param>
public BrowserRemoteViewHost(IFebeBrowser browser, BrowserUseTracker tracker, IClock clock, FebeLog log, IClock? browserClock = null)
/// <param name="openStartPage">
/// What «Pagina iniziale» does (issue #52): the connection opens the start page once the engine's session ended and
/// with the page's turn; null: the button does nothing.
/// </param>
public BrowserRemoteViewHost(IFebeBrowser browser, BrowserUseTracker tracker, IClock clock, FebeLog log, IClock? browserClock = null, Func<CancellationToken, Task>? openStartPage = null)
{
_browser = browser ?? throw new ArgumentNullException(nameof(browser));
_tracker = tracker ?? throw new ArgumentNullException(nameof(tracker));
_clock = clock ?? throw new ArgumentNullException(nameof(clock));
_log = log ?? throw new ArgumentNullException(nameof(log));
_browserClock = browserClock ?? new SystemClock(clock.LocalZone);
_openStartPage = openStartPage;
}
/// <summary>
/// How an open view notices that frames stopped coming and starts them again (issue #52); null: never (tests whose
/// clock moves only when asked).
/// </summary>
public ScreencastWatchdog? Watchdog { get; set; } = ScreencastWatchdog.Default;
public async Task<IRemoteViewConnection> OpenAsync(CancellationToken ct)
{
if (!_browser.IsAvailable)
@@ -83,7 +96,7 @@ internal sealed class BrowserRemoteViewHost : IRemoteViewHost
await previous.EndAsync(RemoteViewEnd.Replaced).ConfigureAwait(false);
}
var connection = new BrowserRemoteViewConnection(this, _browser, _tracker, _clock, _browserClock);
var connection = new BrowserRemoteViewConnection(this, _browser, _tracker, _clock, _browserClock, _log.ForBrowser("vista"), _openStartPage, Watchdog);
try
{
await connection.StartAsync(_browser.WindowWidth, _browser.WindowHeight, ct).ConfigureAwait(false);
@@ -167,6 +180,9 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
private readonly BrowserUseTracker _tracker;
private readonly IClock _clock;
private readonly RemoteViewSession _session;
private readonly Func<CancellationToken, Task>? _openStartPage;
private readonly ScreencastWatchdog? _watchdog;
private readonly IBrowserLog _log;
private readonly Lock _gate = new();
private readonly Queue<RemoteViewMeta> _meta = new();
private readonly SemaphoreSlim _signal = new(0, int.MaxValue);
@@ -183,20 +199,42 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
private int _height;
private int _disposed;
private bool _used;
private int _startPagePending;
private Task _startPage = Task.CompletedTask;
public BrowserRemoteViewConnection(BrowserRemoteViewHost owner, IFebeBrowser browser, BrowserUseTracker tracker, IClock clock, IClock browserClock)
public BrowserRemoteViewConnection(BrowserRemoteViewHost owner, IFebeBrowser browser, BrowserUseTracker tracker, IClock clock, IClock browserClock, IBrowserLog log, Func<CancellationToken, Task>? openStartPage, ScreencastWatchdog? watchdog)
{
_owner = owner;
_browser = browser;
_tracker = tracker;
_clock = clock;
_session = new RemoteViewSession(browser.Cdp, browser.UserDriving, clock: browserClock);
_openStartPage = openStartPage;
_watchdog = watchdog;
_log = log;
// A real log (issue #52): the starts, restarts and silences of the frames reach the registro.
_session = new RemoteViewSession(browser.Cdp, browser.UserDriving, log, browserClock);
}
public RemoteViewEnd? Ended { get; private set; }
private ICdpSession Cdp => _browser.Cdp;
/// <summary>True while a «Pagina iniziale» waits or loads: the input of the view is dropped meanwhile.</summary>
internal bool StartPagePending => Volatile.Read(ref _startPagePending) != 0;
/// <summary>The last «Pagina iniziale» of this view (a completed task before the first): tests wait on it.</summary>
internal Task StartPageOpening
{
get
{
lock (_gate)
{
return _startPage;
}
}
}
public async Task StartAsync(int width, int height, CancellationToken ct)
{
_width = width;
@@ -216,7 +254,7 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
_signal.Release();
_session.Screencast.FrameReceived += OnFrame;
await _session.StartAsync(new ScreencastOptions(Quality: 70, MaxWidth: width, MaxHeight: height), ct).ConfigureAwait(false);
await _session.StartAsync(new ScreencastOptions(Quality: 70, MaxWidth: width, MaxHeight: height, Watchdog: _watchdog), ct).ConfigureAwait(false);
}
public async IAsyncEnumerable<RemoteViewOutput> ReadAsync([EnumeratorCancellation] CancellationToken ct)
@@ -262,9 +300,11 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
public Task MouseAsync(RemoteViewMouse input, CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(input);
if (_session.Screencast.LastFrame is null)
if (_session.Screencast.LastFrame is null || StartPagePending)
{
return Task.CompletedTask; // no frame yet: nothing on screen to point at
// No frame yet: nothing on screen to point at. «Pagina iniziale» in progress: a click would land on the page
// about to go, or on the start page while it loads.
return Task.CompletedTask;
}
MarkUsed();
@@ -288,6 +328,11 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
public Task KeyAsync(RemoteViewKey input, CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(input);
if (StartPagePending)
{
return Task.CompletedTask; // as for the mouse: not typed into a page about to change
}
MarkUsed();
if (input.Action == RemoteViewKeyAction.Char)
{
@@ -300,17 +345,35 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
public async Task NavigateAsync(RemoteViewNavigation action, CancellationToken ct)
{
MarkUsed();
if (action == RemoteViewNavigation.Home)
{
OpenStartPage();
return;
}
if (StartPagePending)
{
return; // the start page is about to replace the page anyway
}
string? target;
lock (_gate)
{
if (action == RemoteViewNavigation.Back)
{
if (_history.Count < 2)
// Back never lands on the empty rest page (issue #52): it skips it, and with nothing before it stays.
var previous = _history.Count - 2;
while (previous >= 0 && IsRest(_history[previous]))
{
previous--;
}
if (previous < 0)
{
return;
}
_history.RemoveAt(_history.Count - 1);
_history.RemoveRange(previous + 1, _history.Count - previous - 1);
target = _history[^1];
}
else
@@ -328,6 +391,46 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
await _session.NavigateAsync(target, ct).ConfigureAwait(false);
}
/// <summary>
/// «Pagina iniziale»: Alberto's own navigation (rule 7), done by the connection — like the start page opened from the
/// rest page, it waits for the engine's session to end and takes the page's turn first, up to half a minute. So it runs
/// beside the view, not in its receive loop (the view would freeze meanwhile), for as long as the view and its lease
/// last; one at a time, and until it is done the view's input is dropped.
/// </summary>
private void OpenStartPage()
{
if (_openStartPage is not { } open || Interlocked.CompareExchange(ref _startPagePending, 1, 0) != 0)
{
return;
}
var task = Task.Run(() => OpenStartPageAsync(open), CancellationToken.None);
lock (_gate)
{
_startPage = task;
}
}
private async Task OpenStartPageAsync(Func<CancellationToken, Task> open)
{
try
{
await open(_ended.Token).ConfigureAwait(false);
}
catch (OperationCanceledException) when (_ended.IsCancellationRequested)
{
// The view closed first: its lease is gone, the page is the engine's.
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
_log.Write(BrowserLogLevel.Warning, $"«Pagina iniziale» non aperta ({ex.GetType().Name}).");
}
finally
{
Volatile.Write(ref _startPagePending, 0);
}
}
/// <summary>Ends the view from the server side (another tab, shutdown): the page is told why.</summary>
public async Task EndAsync(RemoteViewEnd reason)
{
@@ -452,6 +555,8 @@ internal sealed class BrowserRemoteViewConnection : IRemoteViewConnection
/// <summary>The address without query string or fragment (they may carry tokens).</summary>
internal static string WithoutQuery(string url) => Addresses.WithoutQuery(url);
private static bool IsRest(string url) => url is "" or CdpPageExtensions.RestUrl;
}
/// <summary>Turns the DOM key of the page into what <c>Input.dispatchKeyEvent</c> needs (virtual key codes).</summary>
+1 -1
View File
@@ -53,7 +53,7 @@ internal sealed class DockerPlatform(ServerOptions options) : IFebePlatform
{
ArgumentNullException.ThrowIfNull(services);
ArgumentNullException.ThrowIfNull(app);
RemoteView = new BrowserRemoteViewHost(app.Browser!, app.Tracker, app.Clock, app.Log);
RemoteView = new BrowserRemoteViewHost(app.Browser!, app.Tracker, app.Clock, app.Log, openStartPage: ct => app.Connection?.OpenStartPageAsync(ct) ?? Task.CompletedTask);
services.AddSingleton<IRemoteViewHost>(RemoteView);
}
+35
View File
@@ -2,6 +2,7 @@ using System.Text.Json;
using System.Text.Json.Serialization.Metadata;
using Febe.Core.Storage;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.Extensions.Logging;
namespace Febe.Web.Api;
@@ -86,6 +87,40 @@ public static class ApiHttp
}
}
/// <summary>
/// Reads an optional JSON body: <paramref name="empty"/> when there is none — no length and nothing to read, as an
/// empty POST may come chunked or over HTTP/2 — and the body otherwise (a 400 when it is not readable).
/// </summary>
public static async Task<T> OptionalBodyAsync<T>(HttpContext context, JsonTypeInfo<T> type, T empty)
{
ArgumentNullException.ThrowIfNull(context);
var request = context.Request;
if (request.ContentLength == 0)
{
return empty;
}
if (request.ContentLength is null)
{
if (context.Features.Get<IHttpRequestBodyDetectionFeature>() is { CanHaveBody: false })
{
return empty;
}
// A body without a declared length may still be empty: one byte tells, then it is read from the start.
request.EnableBuffering();
var probe = new byte[1];
if (await request.Body.ReadAsync(probe, context.RequestAborted).ConfigureAwait(false) == 0)
{
return empty;
}
request.Body.Position = 0;
}
return await BodyAsync(context, type).ConfigureAwait(false);
}
/// <summary>A JSON answer with its source-generated metadata.</summary>
public static IResult Json<T>(T value, JsonTypeInfo<T> type, int status = StatusCodes.Status200OK) =>
Results.Json(value, type, statusCode: status);
+15 -5
View File
@@ -1,6 +1,7 @@
using Febe.Core.Abstractions;
using Febe.Web.Connection;
using Febe.Web.Engine;
using Febe.Web.Native;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
@@ -21,9 +22,7 @@ public static class ConnectionApi
endpoints.MapPost("/api/connection/begin", async (HttpContext context, IConnectionService connection, CancellationToken ct) =>
{
var body = context.Request.ContentLength is null or > 0
? await ApiHttp.BodyAsync(context, FebeJsonContext.Default.BeginDrivingRequest).ConfigureAwait(false)
: new BeginDrivingRequest(false);
var body = await ApiHttp.OptionalBodyAsync(context, FebeJsonContext.Default.BeginDrivingRequest, new BeginDrivingRequest(false)).ConfigureAwait(false);
await connection.BeginUserDrivingAsync(body.OpenLogin, ct).ConfigureAwait(false);
return Results.NoContent();
});
@@ -36,9 +35,20 @@ public static class ConnectionApi
return ApiHttp.Json(new FinishDto(result.Connected, result.Message), FebeJsonContext.Default.FinishDto);
});
endpoints.MapPost("/api/connection/cancel", async (IConnectionService connection, CancellationToken ct) =>
// «Annulla», or a page left without either button ({ pageLeft: true }). On Windows the browser is a window of its
// own: leaving a page of Febe leaves it as it is, on screen until Alberto closes it (issue #52).
endpoints.MapPost("/api/connection/cancel", async (HttpContext context, IConnectionService connection, IBrowserWindow window, CancellationToken ct) =>
{
await connection.CancelAsync(ct).ConfigureAwait(false);
var body = await ApiHttp.OptionalBodyAsync(context, FebeJsonContext.Default.CancelDrivingRequest, new CancelDrivingRequest(false)).ConfigureAwait(false);
if (body.PageLeft && window.IsSeparateWindow)
{
await connection.ReleaseAsync(ct).ConfigureAwait(false);
}
else
{
await connection.CancelAsync(ct).ConfigureAwait(false);
}
return Results.NoContent();
});
+5 -3
View File
@@ -56,15 +56,17 @@ public static class EngineApi
FebeJsonContext.Default.ResumeDto);
});
// «Apri il browser» on Windows: the window of the browser comes to the front.
endpoints.MapPost("/api/browser/show", async (IBrowserWindow browser, BrowserUseTracker tracker, IClock clock, CancellationToken ct) =>
// «Apri il browser» on Windows: the window of the browser comes to the front, on the start page when it was at rest
// and on the login page with { openLogin: true } (the red strip of a disconnection; issue #52).
endpoints.MapPost("/api/browser/show", async (HttpContext context, IBrowserWindow browser, IConnectionService connection, BrowserUseTracker tracker, IClock clock, CancellationToken ct) =>
{
if (!browser.IsSeparateWindow)
{
throw new BadRequestException("Qui il browser di Febe si usa dalla pagina Browser.");
}
await browser.ShowAsync(ct).ConfigureAwait(false);
var body = await ApiHttp.OptionalBodyAsync(context, FebeJsonContext.Default.BeginDrivingRequest, new BeginDrivingRequest(false)).ConfigureAwait(false);
await connection.ShowBrowserAsync(body.OpenLogin, ct).ConfigureAwait(false);
tracker.MarkUsed(clock.Now);
return ApiHttp.Message("Il browser di Febe è in primo piano.");
});
+1
View File
@@ -49,6 +49,7 @@ namespace Febe.Web.Api;
[JsonSerializable(typeof(Library.LibraryChange))]
[JsonSerializable(typeof(ConnectionStatusDto))]
[JsonSerializable(typeof(BeginDrivingRequest))]
[JsonSerializable(typeof(CancelDrivingRequest))]
[JsonSerializable(typeof(FinishDto))]
[JsonSerializable(typeof(IncidentListDto))]
[JsonSerializable(typeof(AlertListDto))]
+6
View File
@@ -11,6 +11,12 @@ public sealed record ConnectionStatusDto(string State, string? Username, string?
/// <summary><c>POST /api/connection/begin</c>.</summary>
public sealed record BeginDrivingRequest(bool OpenLogin);
/// <summary>
/// «Annulla», or the page that held the browser was left (<paramref name="PageLeft"/>): on Windows the window then
/// stays as it is (issue #52).
/// </summary>
public sealed record CancelDrivingRequest(bool PageLeft);
/// <summary><c>POST /api/connection/finish</c>.</summary>
public sealed record FinishDto(bool Connected, string Message);
@@ -55,6 +55,21 @@ public interface IConnectionService
/// <summary>«Annulla»: ends user driving and puts the browser on the empty rest page.</summary>
Task CancelAsync(CancellationToken ct);
/// <summary>
/// «Apri il browser» on Windows (spec §10.3, issue #52): the window comes to the front and holds the engine still
/// while it is on screen. A browser resting on the empty page first opens the start page (the site's home when
/// connected, the login page otherwise); with <paramref name="openLogin"/> the login page in any case (the red strip
/// of a disconnection).
/// </summary>
Task ShowBrowserAsync(bool openLogin, CancellationToken ct);
/// <summary>
/// The Febe page that took the browser was left (another page, a reload, the tab closed) while the browser is a
/// window of its own (Windows, issue #52): only the page's hold ends. The window stays as it is, on screen and with
/// its page, until Alberto closes it or presses «Ho finito».
/// </summary>
Task ReleaseAsync(CancellationToken ct);
/// <summary>«Scollega» (after confirmation in the UI): stops the engine and deletes the browser profile.</summary>
Task DisconnectAsync(CancellationToken ct);
}
+32 -6
View File
@@ -8,16 +8,31 @@ Lo usano due parti scritte in parallelo: non cambiarlo senza aggiornare entrambe
| Endpoint | Corpo e risposta |
|---|---|
| `GET /api/connection` | `{ state: "notConnected"\|"connected"\|"verificationRequired"\|"browserUnavailable", username, displayName, userIsDriving, currentUrl }` |
| `POST /api/connection/begin` | `{ openLogin: bool }` → 204. Alberto usa il browser; con `openLogin` il browser carica la pagina di accesso vera |
| `POST /api/connection/begin` | `{ openLogin: bool }` → 204. Alberto usa il browser; con `openLogin` il browser carica la pagina di accesso vera; senza, se il browser è a riposo (`about:blank`) apre la pagina iniziale (sotto) |
| `POST /api/connection/finish` | → `{ connected: bool, message }` («Ho finito») |
| `POST /api/connection/cancel` | → 204 («Annulla») |
| `POST /api/connection/cancel` | corpo facoltativo `{ pageLeft: bool }` → 204 («Annulla»; con `pageLeft` la pagina è stata lasciata, sotto) |
| `POST /api/connection/disconnect` | → 204 («Scollega», dopo la conferma nell'interfaccia) |
| `POST /api/browser/show` | corpo facoltativo `{ openLogin: bool }` → `{ message }`. Solo Windows: porta in primo piano la finestra «Browser di Febe»; come `begin` apre la pagina di accesso (`openLogin`) o, se era a riposo, la pagina iniziale |
**Pagina iniziale** (issue #52): la home del sito se Febe è collegato e non scollegato da Instagram, altrimenti la
pagina di accesso. Aprirla, dal riposo o con il pulsante «Pagina iniziale» (barra della finestra di Windows, vista
remota), è un'azione di Alberto, sotto il suo permesso di guida (`UserIsDriving`), non del motore: Febe aspetta che la
sessione del motore finisca, prende il turno della pagina (un passo della ricerca dei profili finisce prima) e solo
dopo naviga. La pressione del pulsante vale finché resta aperto chi l'ha premuta (la finestra sullo schermo, la vista
remota): se nel frattempo Alberto l'ha chiusa, o non guida più, o il turno della pagina non arriva entro 15 s, non
succede nulla. Nella vista remota l'attesa non ferma la vista: una pressione per volta, e finché non è finita i clic,
i tasti, «Indietro» e «Ricarica» si scartano (finirebbero sulla pagina che sta per cambiare). Fuori da quell'attesa
«Indietro», «Ricarica» e i clic nella pagina agiscono subito, come nel browser. La striscia rossa
di una disconnessione apre il browser con `openLogin: true` (in Docker la pagina Browser con `?accesso=1`).
In modalità dimostrativa la scena `scollegato` dà `notConnected`, la scena `fermo` dà `verificationRequired`.
L'interfaccia manda `cancel` anche quando Alberto lascia la pagina Browser, o la pagina Collegamento mentre accede,
senza «Ho finito» né «Annulla»: un'altra pagina, la scheda chiusa o ricaricata (`fetch` con `keepalive`, che porta
l'`Origin` dell'interfaccia). Dopo un «Ho finito» riuscito la pagina chiude la vista remota e non manda un nuovo `begin`.
L'interfaccia manda `cancel` con `{ "pageLeft": true }` anche quando Alberto lascia la pagina Browser, o la pagina
Collegamento mentre accede, senza «Ho finito» né «Annulla»: un'altra pagina, la scheda chiusa o ricaricata (`fetch`
con `keepalive`, che porta l'`Origin` dell'interfaccia). In Docker vale come «Annulla» (il browser torna a riposo).
Su Windows, dove il browser è una finestra a parte, finisce solo il permesso tenuto dalla pagina: la finestra resta
com'è, sullo schermo e con la sua pagina, finché Alberto non la chiude (e finché è sullo schermo il motore resta
fermo). Dopo un «Ho finito» riuscito la pagina chiude la vista remota e non manda un nuovo `begin`.
## Vista remota (`/api/vista`, solo veste Docker)
@@ -30,13 +45,24 @@ Dal server al browser di Alberto:
all'apertura e a ogni cambio di indirizzo o dimensione (l'indirizzo senza parametri di ricerca);
- messaggi binari: un fotogramma JPEG ciascuno (da `Page.startScreencast`), da disegnare su un `<canvas>`.
I fotogrammi non devono fermarsi in silenzio (issue #52). Il server li riavvia (`Page.stopScreencast` e
`Page.startScreencast`) quando una pagina nuova si è caricata (`Page.loadEventFired`) senza che ne sia arrivato
uno, e quando non ne arrivano da circa 2 s; l'attesa raddoppia a ogni riavvio senza esito, fino a 30 s, e torna a
2 s quando i fotogrammi scorrono di nuovo o cambia la pagina. Se entro mezzo secondo dal riavvio non arriva nessun
fotogramma, manda un'immagine ferma della pagina (`Page.captureScreenshot`) come messaggio binario come gli altri;
se durante la cattura arriva un fotogramma vero, l'immagine ferma non si manda. Avvii, riavvii e silenzi vanno
nel registro (livello Info, categoria `vista`), senza indirizzi né contenuti. L'interfaccia, se dopo 8 s
dall'apertura non ha ancora un fotogramma, mostra «Nessuna immagine dal browser» con «Riprova», che riapre la vista.
Sul riposo (`about:blank`) la barra dice «Il browser è a riposo su una pagina vuota» invece dell'indirizzo.
Dal browser di Alberto al server, solo messaggi di testo JSON:
- `{ "type": "mouse", "action": "move"|"down"|"up"|"wheel", "x": 0..1, "y": 0..1, "button": "left"|"right"|"middle", "deltaX": n, "deltaY": n, "clickCount": n }`
con coordinate relative al fotogramma;
- `{ "type": "key", "action": "down"|"up"|"char", "key": "a", "code": "KeyA", "text": "a", "modifiers": n }`
(i tasti non si registrano mai, né sul server né nel browser di Alberto);
- `{ "type": "navigate", "action": "back"|"reload" }`.
- `{ "type": "navigate", "action": "back"|"reload"|"home" }`: «Indietro» (salta la pagina di riposo), «Ricarica»,
«Pagina iniziale» (la pagina iniziale descritta sopra).
## Problemi di configurazione
+6
View File
@@ -114,6 +114,12 @@ public enum RemoteViewNavigation
/// <summary>Reload the current page.</summary>
Reload,
/// <summary>
/// «Pagina iniziale» (issue #52): the site's home when connected, the login page when not connected or after a
/// disconnection. Alberto's own navigation while he drives (rule 7), like the other two.
/// </summary>
Home,
}
/// <summary>The browser is not available (starting, restarting, missing, or Febe stopped by a configuration problem).</summary>
@@ -321,6 +321,7 @@ public static class RemoteViewSocket
{
"back" => RemoteViewNavigation.Back,
"reload" => RemoteViewNavigation.Reload,
"home" => RemoteViewNavigation.Home,
_ => null,
};
@@ -19,5 +19,9 @@ public sealed class UnavailableConnectionService : IConnectionService
public Task CancelAsync(CancellationToken ct) => Task.CompletedTask;
public Task ShowBrowserAsync(bool openLogin, CancellationToken ct) => throw new BadRequestException(Message);
public Task ReleaseAsync(CancellationToken ct) => Task.CompletedTask;
public Task DisconnectAsync(CancellationToken ct) => throw new BadRequestException(Message);
}
-2
View File
@@ -385,8 +385,6 @@ public sealed class DemoShell(IHttpContextAccessor accessor, string root) : INat
public Task<bool> GetAutostartAsync(CancellationToken ct) => Task.FromResult(true);
public Task SetAutostartAsync(bool enabled, CancellationToken ct) => Task.CompletedTask;
public Task ShowAsync(CancellationToken ct) => Task.CompletedTask;
}
/// <summary>Files of the demo: the shared sample pictures. Videos have only their cover.</summary>
+4
View File
@@ -57,6 +57,10 @@ public sealed class DemoConnectionService(IHttpContextAccessor accessor, DemoWor
public Task CancelAsync(CancellationToken ct) => Task.CompletedTask;
public Task ShowBrowserAsync(bool openLogin, CancellationToken ct) => Task.CompletedTask;
public Task ReleaseAsync(CancellationToken ct) => Task.CompletedTask;
public Task DisconnectAsync(CancellationToken ct) =>
throw new BadRequestException("Dimostrazione: Febe non si scollega davvero. Nella versione vera ferma il motore e cancella il profilo del browser con la sessione.");
}
+4 -6
View File
@@ -75,17 +75,15 @@ public sealed class BrowserShell : INativeShell
/// </summary>
public interface IBrowserWindow
{
/// <summary>True when the browser is a window of its own (Windows): «Apri il browser» calls <see cref="ShowAsync"/>.</summary>
/// <summary>
/// True when the browser is a window of its own (Windows): «Apri il browser» asks the connection to bring it to the
/// front (<c>IConnectionService.ShowBrowserAsync</c>), and leaving a Febe page leaves the window as it is.
/// </summary>
bool IsSeparateWindow { get; }
/// <summary>Brings the browser window to the front (Windows). The engine stays still while Alberto uses it.</summary>
Task ShowAsync(CancellationToken ct);
}
/// <summary>No browser window (Docker uses the Browser page; the demo has no browser).</summary>
public sealed class NoBrowserWindow : IBrowserWindow
{
public bool IsSeparateWindow => false;
public Task ShowAsync(CancellationToken ct) => Task.CompletedTask;
}
+16
View File
@@ -0,0 +1,16 @@
<!-- @license lucide-static v1.56.0 - ISC -->
<svg
class="lucide lucide-house"
xmlns="http://www.w3.org/2000/svg"
width="24"
height="24"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
stroke-width="2"
stroke-linecap="round"
stroke-linejoin="round"
>
<path d="M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8" />
<path d="M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" />
</svg>

After

Width:  |  Height:  |  Size: 459 B

+11 -5
View File
@@ -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');
}
}
+1 -1
View File
@@ -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(),
);
}
+9 -4
View File
@@ -1,12 +1,14 @@
// 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, once: the parameter leaves the address straight away.
import { api } from '../core/api.js';
import { caps } from '../core/context.js';
import { h, icon, fill } from '../core/dom.js';
import { navigate } from '../core/shell.js';
import { navigate, setQuery } from '../core/shell.js';
import { t } from '../core/text.js';
import { toast } from '../core/ui.js';
import { drivingLease, finishDriving, passwordNote, windowPanel } from './connection.js';
@@ -24,7 +26,10 @@ 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);
// Asked once: a reload of the page, or the tab restored later, must not open the login page again.
if (login) setQuery({ accesso: null });
const message = h('div', { 'aria-live': 'polite' });
const done = async () => {
const result = await finishDriving();
@@ -40,7 +45,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)));
},
};
+4 -3
View File
@@ -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);
+50 -3
View File
@@ -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();
+4
View File
@@ -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.",
@@ -0,0 +1,248 @@
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Interop;
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;
/// <summary>
/// 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.
/// </summary>
[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");
}
}
/// <summary>
/// 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, the window is never hidden while on screen
/// (WPF hides it to change its taskbar button) and out of view the page is at 100%, and a minimised window keeps Alberto
/// at the wheel until it has been minimised too long. The window comes on screen for a moment.
/// </summary>
[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");
// Every hide of the window (SWP_HIDEWINDOW), and those while it is on screen, where Alberto would see it go.
var hides = 0;
var hidesOnScreen = 0;
await bed.OnUiAsync(() =>
{
var source = (HwndSource)PresentationSource.FromVisual(window);
source.AddHook((IntPtr _, int message, IntPtr _, IntPtr data, ref bool _) =>
{
const int WindowPosChanged = 0x0047;
const int HideWindow = 0x0080;
if (message == WindowPosChanged && (System.Runtime.InteropServices.Marshal.ReadInt32(data, (IntPtr.Size * 2) + 16) & HideWindow) != 0)
{
hides++;
if (window.IsOnScreen)
{
hidesOnScreen++;
}
}
return IntPtr.Zero;
});
return true;
});
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");
Assert.AreEqual(1.0, await bed.OnUiAsync(() => window.Fit), "out of view the page is at 100%, whatever the screen");
Assert.AreEqual(0, await bed.OnUiAsync(() => hidesOnScreen), $"never hidden on screen ({await bed.OnUiAsync(() => hides)} hides out of view)");
TestContext.WriteLine($"Nascosta fuori vista {await bed.OnUiAsync(() => hides)} volte per il pulsante nella barra delle applicazioni.");
}
[TestMethod]
[Timeout(120_000, CooperativeCancellation = true)]
public async Task PaginaInizialeLastsAsLongAsTheWindowsLease()
{
var ct = TestContext.CancellationToken;
var pressedWith = new TaskCompletionSource<CancellationToken>(TaskCreationOptions.RunContinuationsAsynchronously);
// As the connection while a session ends or a search step holds the page: it waits, here until the press is over.
await using var bed = await BrowserBed.CreateAsync("finestra-pagina-iniziale-chiusa", openStartPage: async token =>
{
pressedWith.TrySetResult(token);
await Task.Delay(Timeout.Infinite, token);
});
await bed.StartAsync(ct);
var window = await bed.OnUiAsync(() => bed.Browser.Host.Window) ?? throw new AssertFailedException("nessuna finestra");
await Task.Run(() => bed.Browser.ShowToUserAsync(ct), ct);
await bed.OnUiAsync(() =>
{
Button(window, "Pagina iniziale").RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
return true;
});
var token = await pressedWith.Task.WaitAsync(TimeSpan.FromSeconds(30), ct);
Assert.IsFalse(token.IsCancellationRequested, "the window is still on screen");
// Alberto closes the window before the start page opened: the press is over with the window's lease.
await bed.OnUiAsync(() =>
{
window.Close();
return true;
});
Assert.IsFalse(bed.Browser.UserIsDriving);
await bed.WaitUntilAsync(() => token.IsCancellationRequested, TimeSpan.FromSeconds(10), "la fine della «Pagina iniziale» con la finestra", ct);
Assert.IsFalse(bed.Lines.Any("non aperta"), "a press given up is no failure: " + bed.Lines.Text);
}
[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<DependencyObject>())
{
if (child is Button { Content: string content } button && content == text)
{
return button;
}
if (FindOrNull(child, text) is { } found)
{
return found;
}
}
return null;
}
}
+13 -2
View File
@@ -1,4 +1,5 @@
using Febe.App;
using Febe.Browser.Cdp;
using Febe.Core.Abstractions;
using Febe.Core.Library;
using Febe.Data;
@@ -42,7 +43,14 @@ internal sealed class BrowserBed : IAsyncDisposable
public WebView2Browser Browser { get; }
public static async Task<BrowserBed> CreateAsync(string name, BrowserHosting hosting = BrowserHosting.Window)
/// <param name="name">Prefix of the temporary folder.</param>
/// <param name="hosting">How WebView2 draws (S2).</param>
/// <param name="startPage">
/// Where «Pagina iniziale» goes, opened as the connection would (here without an engine to wait for); null: the button
/// does nothing (never the default login page of the options, which is Instagram's).
/// </param>
/// <param name="openStartPage">What «Pagina iniziale» does instead (it wins over <paramref name="startPage"/>).</param>
public static async Task<BrowserBed> CreateAsync(string name, BrowserHosting hosting = BrowserHosting.Window, Func<string>? startPage = null, Func<CancellationToken, Task>? openStartPage = null)
{
var folder = new TestFolder(name);
var ui = await UiThread.StartAsync();
@@ -53,11 +61,14 @@ 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);
WebView2Browser? built = null;
openStartPage ??= startPage is null ? null : async ct => await built!.Cdp.NavigateAsync(startPage(), ct);
var context = new FebePlatformContext(options, data, database, clock, log, tracker, openStartPage);
var settings = new WebView2BrowserSettings(data.BrowserProfile, 1280, 900, hosting, BrowserArguments.ForWebView2());
// Built off the UI thread, as DesktopPlatform.CreateBrowserAsync does after its awaits.
var browser = new WebView2Browser(ui.Dispatcher, settings, context, icon: null);
built = browser;
return new BrowserBed(folder, ui, lines, log, database, tracker, browser);
}
@@ -64,7 +64,8 @@ public sealed class RemoteViewDuringNavigationTests
var notes = new ConcurrentQueue<string>();
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);
}
@@ -0,0 +1,139 @@
using System.Diagnostics;
using Febe.Browser.Cdp;
using Febe.Browser.RemoteView;
using Febe.Tests.Browser.TestSupport;
namespace Febe.Tests.Browser;
/// <summary>
/// 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. The tests ask that a picture arrives, not how fast: the waits are
/// generous for a busy runner (issue #46), and the time it took goes to the test's output (about two seconds, the
/// watchdog's silence, at most five on a calm machine).
/// </summary>
[TestClass]
[DoNotParallelize]
public sealed class RemoteViewFramesTests
{
/// <summary>How long a picture may take on a busy runner before the view counts as white.</summary>
private static readonly TimeSpan Patience = TimeSpan.FromSeconds(20);
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 AStillPageAndTheRestPageShowAPicture()
{
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);
var watch = Stopwatch.StartNew();
Assert.IsTrue(await PictureAfterAsync(view.Screencast, null, Patience, ct), "a picture of the login page");
TestContext.WriteLine($"pagina di accesso: immagine dopo {watch.ElapsedMilliseconds} ms.");
var last = view.Screencast.LastFrame;
var rest = await cdp.RestAsync(ct);
Assert.IsTrue(rest.Succeeded, rest.ErrorText);
watch.Restart();
Assert.IsTrue(await PictureAfterAsync(view.Screencast, last, Patience, ct), "a picture of the rest page too");
TestContext.WriteLine($"pagina di riposo: immagine dopo {watch.ElapsedMilliseconds} ms, riavvii {view.Screencast.Restarts}.");
}
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, Patience, 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();
}
}
/// <summary>A frame or a still picture other than <paramref name="last"/>, within <paramref name="timeout"/>.</summary>
private static async Task<bool> 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;
}
/// <summary>A few real frames of the screencast (not still pictures) after now, within <see cref="Patience"/>.</summary>
private static async Task<bool> FramesAfterAsync(ScreencastSession screencast, CancellationToken ct)
{
var before = screencast.FramesReceived;
var deadline = Stopwatch.StartNew();
while (deadline.Elapsed < Patience)
{
if (screencast.FramesReceived >= before + 3)
{
return true;
}
await Task.Delay(50, ct);
}
return false;
}
}
@@ -0,0 +1,356 @@
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;
/// <summary>
/// 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.
/// </summary>
[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);
// The restart after two seconds, then its wait for a first frame.
await bed.StepAsync(TimeSpan.FromSeconds(2.25) + ScreencastWatchdog.FirstFrameWait, 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 AFrameSoonAfterARestartNeedsNoStillPicture()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(screenshot: Jpeg(800, 600));
await bed.StartAsync(ct);
// Restarted after two seconds: Chromium answers the start first and sends its frame a moment later.
await bed.StepAsync(TimeSpan.FromSeconds(2.25), ct);
Assert.AreEqual(1, bed.Session.Restarts);
bed.Frame();
await bed.StepAsync(TimeSpan.FromSeconds(1), ct);
Assert.IsFalse(bed.Cdp.Sent.Any(c => c.Method == "Page.captureScreenshot"), "the frame came: no picture taken. " + string.Join(", ", bed.Cdp.Sent.Where(c => c.Method != "Page.screencastFrameAck").Select(c => $"{c.Method}@{c.At:ss.fff}")) + " | " + bed.AllLines);
Assert.IsNotNull(bed.Session.LastFrame);
Assert.IsFalse(bed.Session.LastFrame.Still);
}
[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");
}
/// <summary>A minimal JPEG header: SOI, an APP0 segment, then a SOF0 (or SOF2) with the size.</summary>
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,
];
/// <summary>A screencast over a fake page and a clock that moves only when stepped.</summary>
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<string> 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);
}
}
/// <summary>A frame of the screencast, as Chromium sends it.</summary>
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 },
});
/// <summary>Moves the clock by <paramref name="time"/>, one look of the watchdog at a time.</summary>
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();
}
/// <summary>A clock whose delays end only when the test moves it past them.</summary>
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<TaskCompletionSource> 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();
}
}
/// <summary>Waits (in real time) until someone sleeps on the clock again: the watchdog finished its look.</summary>
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);
}
}
}
}
@@ -44,15 +44,47 @@ public sealed class LocalTestSite : IDisposable
public string Url(string path) => $"http://{SiteHost}{path}";
/// <summary>The same site under the name «localhost»: another site for Chromium, so another renderer.</summary>
public string LocalhostUrl(string path) => $"http://localhost:{SitePort}{path}";
public string CdnUrl(string path) => $"http://{CdnHost}{path}";
// Ports handed out by FreePort come from 20000-29999: below the ephemeral ranges of Linux (32768-60999) and Windows
// (49152-65535), so an outgoing connection of another test cannot take one between the probe and the moment the
// test binds it (a port handed out by the system's port 0 could, CI run 350 of #52). Each port is handed out once
// per process; the start depends on the process id, so two test processes on one machine rarely meet.
private const int FirstTestPort = 20000;
private const int TestPorts = 10000;
private static int _nextPort = Environment.ProcessId * 7919 % TestPorts;
/// <summary>
/// A port of 127.0.0.1 that is free now, never handed out before in this process and outside the system's ephemeral
/// range. The caller binds it soon after; nothing can reserve it in between, but no other test of this process gets
/// it and no outgoing connection is given it.
/// </summary>
public static int FreePort()
{
var probe = new TcpListener(IPAddress.Loopback, 0);
probe.Start();
var port = ((IPEndPoint)probe.LocalEndpoint).Port;
probe.Stop();
return port;
for (var attempt = 0; attempt < TestPorts; attempt++)
{
var port = FirstTestPort + (int)((uint)Interlocked.Increment(ref _nextPort) % TestPorts);
var probe = new TcpListener(IPAddress.Loopback, port);
try
{
probe.Start();
}
catch (SocketException)
{
continue;
}
finally
{
probe.Stop();
}
return port;
}
throw new InvalidOperationException("Nessuna porta libera fra 20000 e 29999.");
}
private int _disposed;
@@ -0,0 +1,297 @@
using System.Net;
using Febe.Core.Abstractions;
using Febe.Tests.Desktop.Support;
using Febe.Tests.Support;
namespace Febe.Tests.Desktop;
/// <summary>
/// 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.
/// </summary>
[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();
}
}
[TestMethod]
[Timeout(60_000, CooperativeCancellation = true)]
public async Task PaginaInizialeWaitsForThePageTurnAndActsOnlyWhileAlbertoIsAtTheBrowser()
{
var ct = TestContext.CancellationToken;
await using var bed = await DesktopTestBed.StartAsync();
await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
var browser = bed.Browser!;
var connection = bed.App.Connection!;
// Nobody at the browser: the page is the engine's, the button does nothing.
var navigations = Navigations(browser);
await connection.OpenStartPageAsync(ct);
Assert.AreEqual(navigations, Navigations(browser));
// At the browser, on a page of his: the start page — but only once a step of the profile search let go of the page.
await BeginAsync(bed, openLogin: false);
browser.FakeCdp.Navigated("https://www.instagram.com/marta.prova/");
var turns = bed.App.Engine!.Services.PageTurns;
var turn = await turns.TakeAsync(Febe.Core.Engine.PageUser.Search, ct);
var home = connection.OpenStartPageAsync(ct);
await DesktopTestBed.WaitUntilAsync(() => turns.IsWaiting(Febe.Core.Engine.PageUser.Engine), TimeSpan.FromSeconds(10), "«Pagina iniziale» in attesa del turno della pagina");
Assert.IsFalse(home.IsCompleted, "the search step still has the page");
Assert.AreEqual("https://www.instagram.com/marta.prova/", browser.FakeCdp.Url);
turn.Dispose();
await home.WaitAsync(TimeSpan.FromSeconds(10), ct);
Assert.AreEqual(Login, browser.FakeCdp.Url, "not connected: the login page");
}
[TestMethod]
[Timeout(60_000, CooperativeCancellation = true)]
public async Task PaginaInizialeIsForgottenWhenAlbertoLetGoOfTheBrowserWhileItWaited()
{
var ct = TestContext.CancellationToken;
await using var bed = await DesktopTestBed.StartAsync();
await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
var browser = bed.Browser!;
var connection = bed.App.Connection!;
var turns = bed.App.Engine!.Services.PageTurns;
// The window on screen (its lease), a step of the profile search on the page: «Pagina iniziale» waits for its turn.
var window = browser.UserDriving.Begin();
browser.FakeCdp.Navigated("https://www.instagram.com/marta.prova/");
var turn = await turns.TakeAsync(Febe.Core.Engine.PageUser.Search, ct);
var home = connection.OpenStartPageAsync(ct);
await DesktopTestBed.WaitUntilAsync(() => turns.IsWaiting(Febe.Core.Engine.PageUser.Engine), TimeSpan.FromSeconds(10), "«Pagina iniziale» in attesa del turno della pagina");
// Alberto closes the window meanwhile: the page is the engine's again, and the press is forgotten (rules 7 and 8).
window.Dispose();
Assert.IsFalse(browser.UserIsDriving);
turn.Dispose();
await home.WaitAsync(TimeSpan.FromSeconds(10), ct);
Assert.DoesNotContain(Login, browser.FakeCdp.Visited, "no navigation of Alberto's without his lease");
Assert.DoesNotContain(Home, browser.FakeCdp.Visited);
}
[TestMethod]
[Timeout(60_000, CooperativeCancellation = true)]
public async Task PaginaInizialeEndsWithTheLeaseOfWhoPressedIt()
{
var ct = TestContext.CancellationToken;
await using var bed = await DesktopTestBed.StartAsync();
await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
var browser = bed.Browser!;
var connection = bed.App.Connection!;
var turns = bed.App.Engine!.Services.PageTurns;
// Someone else still drives (Febe's page with «Usa il browser»), but the window that pressed the button closed.
using var other = browser.UserDriving.Begin();
using var pressedBy = new CancellationTokenSource();
var turn = await turns.TakeAsync(Febe.Core.Engine.PageUser.Search, ct);
var home = connection.OpenStartPageAsync(pressedBy.Token);
await DesktopTestBed.WaitUntilAsync(() => turns.IsWaiting(Febe.Core.Engine.PageUser.Engine), TimeSpan.FromSeconds(10), "«Pagina iniziale» in attesa del turno della pagina");
await pressedBy.CancelAsync();
await home.WaitAsync(TimeSpan.FromSeconds(10), ct);
Assert.IsFalse(turns.IsWaiting(Febe.Core.Engine.PageUser.Engine), "no longer in the queue");
turn.Dispose();
Assert.DoesNotContain(Login, browser.FakeCdp.Visited);
}
[TestMethod]
[Timeout(60_000, CooperativeCancellation = true)]
public async Task PaginaInizialeNeverTakesThePageFromUnderASearchStep()
{
var ct = TestContext.CancellationToken;
await using var bed = await DesktopTestBed.StartAsync();
await bed.App.Running.WaitAsync(TimeSpan.FromSeconds(20), ct);
var browser = bed.Browser!;
var connection = bed.App.Connection!;
connection.PageTurnWait = TimeSpan.FromMilliseconds(300);
var turns = bed.App.Engine!.Services.PageTurns;
using var window = browser.UserDriving.Begin();
browser.FakeCdp.Navigated("https://www.instagram.com/marta.prova/");
using var turn = await turns.TakeAsync(Febe.Core.Engine.PageUser.Search, ct);
await connection.OpenStartPageAsync(ct).WaitAsync(TimeSpan.FromSeconds(10), ct);
Assert.AreEqual("https://www.instagram.com/marta.prova/", browser.FakeCdp.Url, "the step keeps its page");
Assert.DoesNotContain(Login, browser.FakeCdp.Visited);
}
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());
}
}
@@ -336,12 +336,5 @@ public sealed class DesktopCompositionTests
StringAssert.Contains(log, "Windows non ha legato Edge a Febe");
}
private static int FreePort()
{
var listener = new System.Net.Sockets.TcpListener(IPAddress.Loopback, 0);
listener.Start();
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
listener.Stop();
return port;
}
private static int FreePort() => Febe.Tests.Browser.TestSupport.LocalTestSite.FreePort();
}
@@ -28,11 +28,15 @@ internal sealed class FakeDesktopShell : IDesktopShell
public ConcurrentQueue<string> ProcessWindows { get; } = new();
/// <summary>Called with each browser as it is created, before Febe uses it (to set up the fake page).</summary>
public Action<FakeBrowser>? 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,10 +229,19 @@ internal sealed class FakeCdp : ICdpSession
public bool LoggedIn { get; set; }
/// <summary>
/// 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.
/// </summary>
public string? LogsInOnVisit { get; set; }
public string Url { get; private set; } = "about:blank";
public ConcurrentQueue<string> Methods { get; } = new();
/// <summary>Every address a <c>Page.navigate</c> asked for, in order.</summary>
public ConcurrentQueue<string> Visited { get; } = new();
/// <summary>The main frame moved to <paramref name="url"/> by itself (a redirect of the site), not by a command.</summary>
public void Navigated(string url)
{
@@ -244,7 +257,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 +291,12 @@ internal sealed class FakeCdp : ICdpSession
var url = (parameters as JsonObject)?["url"]?.GetValue<string>();
if (url is not null)
{
Visited.Enqueue(url);
if (LogsInOnVisit is { } site && url.StartsWith(site, StringComparison.Ordinal))
{
LoggedIn = true;
}
Navigated(url);
}
@@ -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<WebTestServer> StartAsync(FakeRemoteViewHost host) =>
WebTestServer.StartAsync(
new FebeWebOptions { Edition = FebeEdition.Docker, Access = AccessMode.Password, Password = Password },
+143 -2
View File
@@ -132,6 +132,131 @@ 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);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), 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);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), 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 PaginaInizialeWaitsBesideTheViewDroppingItsInputAndEndsWithIt()
{
var ct = TestContext.CancellationToken;
var presses = 0;
var pressedWith = new TaskCompletionSource<CancellationToken>(TaskCreationOptions.RunContinuationsAsynchronously);
await using var bed = new Bed(_ => null, open: async token =>
{
Interlocked.Increment(ref presses);
pressedWith.TrySetResult(token);
// As the connection while a session ends or a search step holds the page: up to half a minute.
await Task.Delay(Timeout.Infinite, token);
});
var view = await bed.Host.OpenAsync(ct);
bed.Cdp.Raise("Page.screencastFrame", Frame());
await ReadUntilFrameAsync(view, ct);
bed.Cdp.ClearSent();
// The receive loop goes on at once: the press waits beside it.
await view.NavigateAsync(RemoteViewNavigation.Home, ct).WaitAsync(TimeSpan.FromSeconds(5), ct);
var token = await pressedWith.Task.WaitAsync(TimeSpan.FromSeconds(10), ct);
Assert.IsFalse(StartPageOf(view).IsCompleted, "still waiting for its turn");
// Meanwhile clicks, keys and the other buttons are dropped (they would land on the start page as it loads), and a
// second press waits for the first.
await view.MouseAsync(new RemoteViewMouse(RemoteViewMouseAction.Down, 0.5, 0.5, RemoteViewButton.Left, 1, 0, 0), ct);
await view.KeyAsync(new RemoteViewKey(RemoteViewKeyAction.Char, "a", "KeyA", "a", 0), ct);
await view.NavigateAsync(RemoteViewNavigation.Reload, ct);
await view.NavigateAsync(RemoteViewNavigation.Home, ct);
Assert.IsFalse(bed.Cdp.Sent.Any(c => IsInputOrNavigation(c.Method)), "nothing reached the browser: " + string.Join(", ", bed.Cdp.Sent.Select(c => c.Method)));
Assert.AreEqual(1, Volatile.Read(ref presses));
// The view closes: its lease is gone, and so is the press.
Assert.IsFalse(token.IsCancellationRequested);
await view.DisposeAsync();
Assert.IsTrue(token.IsCancellationRequested, "the press lasts as long as the view");
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), ct);
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task AfterPaginaInizialeTheInputReachesTheBrowserAgain()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => null, () => "http://127.0.0.1:8481/benvenuto");
var view = await bed.Host.OpenAsync(ct);
await view.NavigateAsync(RemoteViewNavigation.Home, ct);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), ct);
bed.Cdp.ClearSent();
await view.KeyAsync(new RemoteViewKey(RemoteViewKeyAction.Char, "a", "KeyA", "a", 0), ct);
Assert.IsTrue(bed.Cdp.Sent.Any(c => c.Method.StartsWith("Input.", StringComparison.Ordinal)), string.Join(", ", bed.Cdp.Sent.Select(c => c.Method)));
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);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), 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 bool IsInputOrNavigation(string method) =>
method.StartsWith("Input.", StringComparison.Ordinal) || method is "Page.navigate" or "Page.reload";
private static Task StartPageOf(IRemoteViewConnection view) => ((BrowserRemoteViewConnection)view).StartPageOpening;
private static CdpCommandException InactivePage() =>
new("Page.startScreencast", CdpCommandException.ServerErrorCode, CdpCommandException.InactivePageMessage);
@@ -170,7 +295,12 @@ public sealed class RemoteViewStartTests
private int _starts;
/// <param name="startFailure">For the n-th start (from 1), the exception the browser answers with; null: started.</param>
public Bed(Func<int, Exception?> startFailure)
/// <param name="startPage">
/// Where «Pagina iniziale» goes, as the connection would open it (BrowserConnectionService.OpenStartPageAsync,
/// tested in BrowserStartPageTests); null: nowhere.
/// </param>
/// <param name="open">What «Pagina iniziale» does instead (it wins over <paramref name="startPage"/>).</param>
public Bed(Func<int, Exception?> startFailure, Func<string>? startPage = null, Func<CancellationToken, Task>? open = null)
{
Clock = new VirtualClock();
_start = Clock.Now;
@@ -196,7 +326,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, openStartPage: open ?? (startPage is null ? null : async ct => await Cdp.NavigateAsync(startPage(), ct)))
{
// The virtual clock moves only in the pauses: a watchdog on it would never wait.
Watchdog = null,
};
}
public VirtualClock Clock { get; }
@@ -209,6 +343,13 @@ public sealed class RemoteViewStartTests
public int Starts => Volatile.Read(ref _starts);
/// <summary>The address of the last <c>Page.navigate</c>.</summary>
public string? LastNavigation => Cdp.Sent.LastOrDefault(c => c.Method == "Page.navigate")?.Parameters?["url"]?.GetValue<string>();
/// <summary>The main frame committed a new document.</summary>
public void Navigated(string url) =>
Cdp.Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = url } });
/// <summary>Time spent in the host's pauses (the virtual clock moves only there).</summary>
public TimeSpan Elapsed => Clock.Now - _start;
@@ -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.
@@ -62,6 +62,66 @@ 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<IConnectionService>(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<IConnectionService>(windows)
.AddSingleton<Febe.Web.Native.IBrowserWindow>(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 ABodyWithoutALengthIsReadAndAnEmptyOneIsNoBody()
{
// Chunked, as a body without Content-Length may come (HTTP/2 too): empty is the default, not a 400.
var windows = new RecordingConnection();
await using var server = await Part2.StartAsync(services: s => s
.AddSingleton<IConnectionService>(windows)
.AddSingleton<Febe.Web.Native.IBrowserWindow>(new SeparateWindow()));
foreach (var (path, body) in new[]
{
("/api/connection/begin", ""),
("/api/connection/cancel", ""),
("/api/browser/show", ""),
("/api/connection/cancel", """{"pageLeft":true}"""),
("/api/browser/show", """{"openLogin":true}"""),
})
{
using var request = server.Request(HttpMethod.Post, path);
request.Content = new StreamContent(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(body)));
request.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
request.Headers.TransferEncodingChunked = true;
using var response = await server.Client.SendAsync(request);
Assert.IsTrue(response.IsSuccessStatusCode, $"{path} «{body}»: {(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");
}
CollectionAssert.AreEqual(new[] { "begin:False", "cancel", "show:False", "release", "show:True" }, windows.Calls);
}
[TestMethod]
public async Task CommandsFromAnotherPageAreRefused()
{
@@ -99,4 +159,10 @@ public sealed class ConnectionApiTests
Assert.AreEqual(problem.Message, listed[0].Str("message"));
Assert.AreEqual(problem.Remedy, listed[0].Str("remedy"));
}
/// <summary>The browser as a window of its own, as on Windows.</summary>
private sealed class SeparateWindow : Febe.Web.Native.IBrowserWindow
{
public bool IsSeparateWindow => true;
}
}
@@ -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");