diff --git a/.forgejo/workflows/buildAndTest.yml b/.forgejo/workflows/buildAndTest.yml index 6106f11f9..12e4d8147 100644 --- a/.forgejo/workflows/buildAndTest.yml +++ b/.forgejo/workflows/buildAndTest.yml @@ -69,10 +69,7 @@ jobs: YAVSC_API_TEST_NPGSQL_ADMIN_CONNECTION: Host=127.0.0.1;Port=55432;Database=postgres;Username=postgres;Password=postgres;Include Error Detail=true run: | echo "🚀 Lancement des tests..." - cd /src/_src && dotnet test \ - --report-xunit \ - --report-xunit-html \ - --report-xunit-html-filename "test-results.html" + cd /src/_src && make test TEST_EXIT_CODE=$? echo "Test exit code: $TEST_EXIT_CODE" if [ $TEST_EXIT_CODE -ne 0 ]; then diff --git a/CHANGELOG.md b/CHANGELOG.md index 7df6ba171..04d0e3902 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,19 @@ # Changelog + +## [1.0.8-rc36] - unstable + +### Added + +* [PostIt/Administration] Add an administrator-only consumption relief page reachable from Administration: select a user at their limit, preview and confirm an arbitrary point erasure up to current consumption. Protect the quota-exempt API with the Administrator policy, serialize adjustments with accounting, reject stale confirmations, preserve technical counters and disk quotas, and audit the actor. Add API, service, client and responsive-page regressions. + +* [PostIt] Upgrade Avalonia to 12.1.6 and align the headless and native Skia test rendering packages. + +* [PostIt/Calls] Replace the chat's direct VLC/SRTP call panel with native WebRTC on Android and Linux: official libwebrtc/Camera2 and GStreamer webrtcbin, existing consent/SignalR signaling, ICE/STUN/coturn, and fail-closed relay-only IP masking. Cancel pending startup and release media on hangup, navigation, interruption and backgrounding. Add privacy/lifecycle, real Linux media/rendering and debug Android interoperability regressions, coturn deployment instructions and a protected-server-secret configuration example. + +* [PostIt/PayPal] Add a native subscription page reachable from Home, profile and About: load server-priced Discovery/Premium offers, prepare or resume checkout with the current bearer session, open only PayPal for approval, reconcile confirmed payments and balances, and cancel with confirmation. Add quota-exempt bearer-only endpoints on Yavsc.Org, sharing checkout/cancellation logic with the existing web flow, and regression coverage. Browser return never confirms payment. + ## [1.0.8-rc35] - unstable ### Added diff --git a/INSTALL.md b/INSTALL.md index 696f3924f..f9dc3f123 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -28,6 +28,61 @@ dotnet publish -c Release and then, install the app, from the `src/PostIt/PostIt.Android/bin/Release/net10.0/PostIt.apk` +## PostIt native WebRTC calls (Android and Linux) + +Calls are opt-in on the HTTPS chat host. Configure `AudioVideoCalls` there: + +```json +{ + "AudioVideoCalls": { + "Enabled": true, + "EnableLanCalls": false, + "StunUrls": ["stun:turn.example.org:3478"], + "TurnUrls": [ + "turn:turn.example.org:3478?transport=udp", + "turn:turn.example.org:3478?transport=tcp", + "turns:turn.example.org:5349?transport=tcp" + ] + } +} +``` + +Set `AudioVideoCalls__TurnSharedSecret` through the host's protected environment +or secret store, **not** in a committed settings file or in PostIt. Generate +a strong random secret (for example `openssl rand -hex 32`), install coturn and +adapt [coturn.conf.example](contrib/coturn.conf.example) outside the repository. +Set its `static-auth-secret` to the same value. The server issues separate, +short-lived REST/HMAC credentials only after invitation acceptance; clients +never receive the shared secret. Keep clocks synchronized. + +Expose TURN on UDP/TCP 3478, TLS/TCP 5349, and the configured **UDP relay range** +(49160–49200 in the example). Use a publicly trusted certificate matching the +TURN hostname and ensure coturn can read its key. TURN is not an HTTP reverse +proxy route. If behind NAT, configure coturn's `external-ip=PUBLIC/PRIVATE`, +`listening-ip` and `relay-ip` for the actual deployment and forward the relay +range without changing port numbers. Restrict relay access to private services, +set bandwidth/capacity limits appropriate to the host, and avoid logging SDP, +credentials or candidates. Do not copy the loopback permissions used by tests. + +Android 8+ bundles native libwebrtc from the official Maven AAR. Linux needs +Python 3 GI and GStreamer with `webrtcbin`, libnice, VP8, Opus, JPEG, V4L2 and +PulseAudio/PipeWire support. On Debian/Ubuntu: + +```bash +sudo apt install python3-gi python3-gst-1.0 gir1.2-gst-plugins-bad-1.0 \ + gstreamer1.0-plugins-base gstreamer1.0-plugins-good \ + gstreamer1.0-plugins-bad gstreamer1.0-nice gstreamer1.0-pulseaudio +``` + +Join the same chat room, refresh/select camera and microphone, invite a peer, +then accept on the other client. Capture starts only after acceptance. +The profile's IP-masking setting forces **both participants** through TURN; +missing/unreachable TURN fails the call, never falls back to direct media. +Without masking, explicit IP-disclosure consent is required. +TURN still sees each client's address, and masking does not hide addresses +from the signaling host or local network. See the +[architecture and native regression commands](doc/architecture/audio-video-calls.md). + ## PostIt.Desktop on Windows (per-user installer) @@ -187,6 +242,21 @@ footer and PostIt's **About** page, using the configured authentication authority. PostIt displays consumption and remaining points in **My profile** and the administration usage views. +PostIt **Administration > Effacer des points de consommation** lets an +`Administrator` select an account whose consumption limit is reached, enter +a positive amount (up to eight decimal places), preview the remaining +consumption and explicitly confirm. An amount exceeding current consumption +is rejected: this action grants neither future credit nor additional disk +space, and preserves the technical counters and payment history. +`POST /api/v1/resource-usage/admin/{userId}/erase` accepts `points` and +`expectedCredits` (the displayed `AppliedCredits + CreditBalance`). The +Administrator-only endpoint is quota-exempt, rechecks eligibility under the +shared accounting lock and rejects stale credit snapshots with HTTP 409. +Refresh and confirm again after a conflict or uncertain request outcome. +Successful adjustments record the administrator as the modifying actor and +log the target, amount and remaining consumption. No new migration is needed +beyond the existing resource-subscription credit column. + ### Monthly resource subscriptions (PayPal REST) The free registration keeps the configured cumulative quota without a @@ -227,6 +297,22 @@ any still-paid Discovery period applies. Configure only **Yavsc.Org** for PayPal subscriptions. API and Blogs need the migrated shared database and matching resource weights, not PayPal credentials. Existing Classic donation settings remain unchanged. + +PostIt's **Mon abonnement PayPal** page (Home, profile or About) loads offers +and creates/resumes checkout through `api/v1/resource-subscriptions` on the +configured OIDC **authority**, not the business API host. These routes require +the current bearer token, reject cookie-only requests, and remain accessible +at the resource-consumption limit. Prices, VAT, monthly points and plan IDs +are controlled by the server; no PayPal credentials are shipped to PostIt. +Only approval opens in the browser. The anonymous `/api/v1/resource-subscriptions/return` +landing page asks the user to return to PostIt and press **Actualiser**: +it does not reconcile or grant credit, and requires no second web login. +The authenticated `POST refresh` reconciles verified PayPal transactions; +`POST {id}/cancel` cancels only the caller's subscription. Existing web +checkout and verified webhooks remain supported. Deploy Yavsc.Org with the +new routes before distributing the updated client. Example requests are in +[`resource-subscriptions.http`](src/Yavsc.Org/resource-subscriptions.http). + Use the existing `PayPal:Mode`, `PayPal:ClientId` and `PayPal:ClientSecret` REST settings; keep credentials in user-secrets or environment variables. diff --git a/Makefile b/Makefile index 04efba0be..e3fb5b686 100644 --- a/Makefile +++ b/Makefile @@ -4,6 +4,7 @@ FRAMEWORK=net9.0 DESTDIR=/tmp/yavsc APP_PATH=srv/www/yavsc APP_FULL_PATH=$(DESTDIR)/$(APP_PATH) +UNITTESTEXTRA= --long-running 8 --filter-trait Category=non-reg --filter-not-trait Speed=Slow --filter-not-trait DependsOn=Native all: dotnet build --nologo @@ -19,29 +20,36 @@ src/Yavsc/bin/output/wwwroot: dotnet --project src/Yavsc.Org/Yavsc.Org.csproj publish test: - ASPNETCORE_ENVIRONMENT=Development dotnet test --report-xunit \ - --report-xunit-html \ - --results-directory "test-reports" + ASPNETCORE_ENVIRONMENT=Development \ + TESTINGPLATFORM_EXITCODE_IGNORE="110;1" \ + dotnet test yavsc.sln \ + -- --report-xunit \ + --report-xunit-html \ + --results-directory "test-reports" \ + $(UNITTESTEXTRA) || EXITCODE=$$? && echo "🗱💻 Tests failed, exited with code $$EXITCODE"; test-postit: - ASPNETCORE_ENVIRONMENT=Development dotnet test \ - --report-xunit \ - --report-xunit-html \ - --results-directory "test-reports" \ - --report-xunit-html-filename "postit-test-results.html" \ - --project src/PostIt/PostIt.Tests/PostIt.Tests.csproj + ASPNETCORE_ENVIRONMENT=Development \ + TESTINGPLATFORM_EXITCODE_IGNORE="110;1" \ + dotnet test \ + src/PostIt/PostIt.Tests/PostIt.Tests.csproj \ + -- --report-xunit \ + --report-xunit-html \ + --results-directory "test-reports" \ + --report-xunit-html-filename "postit-test-results.html" \ + $(UNITTESTEXTRA) || EXITCODE=$$? && echo "🗱📱 Tests failed, exited with code $$EXITCODE"; backend-tests: Blogs-backend-test Org-backend-test Api-backend-test Api-backend-test: Blogs-backend-test: Org-backend-test: %-backend-test: - ASPNETCORE_ENVIRONMENT=Development dotnet test \ + ASPNETCORE_ENVIRONMENT=Development dotnet test + src/test/Yavsc.$*.Tests/Yavsc.$*.Tests.csproj \ --report-xunit \ --report-xunit-html \ --results-directory "test-reports" \ - --report-xunit-html-filename "$*-backend-test-results.html" \ - --project src/test/Yavsc.$*.Tests/Yavsc.$*.Tests.csproj + --report-xunit-html-filename "$*-backend-test-results.html" watch: dotnet watch -p:Configuration=$(CONFIG) --project src/Yavsc/Yavsc.csproj diff --git a/contrib/coturn.conf.example b/contrib/coturn.conf.example new file mode 100644 index 000000000..0c70978ae --- /dev/null +++ b/contrib/coturn.conf.example @@ -0,0 +1,32 @@ +# Copy outside the repository; replace the realm, secret and certificate paths. +# Use the same randomly generated secret in AudioVideoCalls:TurnSharedSecret. +realm=turn.example.org +fingerprint +use-auth-secret +static-auth-secret=REPLACE_WITH_A_RANDOM_SERVER_ONLY_SECRET +listening-port=3478 +tls-listening-port=5349 +cert=/etc/letsencrypt/live/turn.example.org/fullchain.pem +pkey=/etc/letsencrypt/live/turn.example.org/privkey.pem +min-port=49160 +max-port=49200 +no-cli +no-multicast-peers +no-tcp-relay +user-quota=4 +total-quota=512 +stale-nonce=600 + +# Do not allow the relay to reach private infrastructure or loopback services. +denied-peer-ip=0.0.0.0-0.255.255.255 +denied-peer-ip=10.0.0.0-10.255.255.255 +denied-peer-ip=100.64.0.0-100.127.255.255 +denied-peer-ip=127.0.0.0-127.255.255.255 +denied-peer-ip=169.254.0.0-169.254.255.255 +denied-peer-ip=172.16.0.0-172.31.255.255 +denied-peer-ip=192.168.0.0-192.168.255.255 +denied-peer-ip=224.0.0.0-255.255.255.255 +denied-peer-ip=:: +denied-peer-ip=::1 +denied-peer-ip=fc00::-fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff +denied-peer-ip=fe80::-febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff diff --git a/doc/architecture/audio-video-calls.md b/doc/architecture/audio-video-calls.md index 1fb9fc7ef..7b9affd29 100644 --- a/doc/architecture/audio-video-calls.md +++ b/doc/architecture/audio-video-calls.md @@ -2,12 +2,14 @@ ## Statut et périmètre -Ce document décrit l'architecture cible et l'implémentation commencée. +Ce document décrit l'architecture cible, l'implementation native actuelle et +l'historique du transport direct. La préférence de confidentialité est persistée et éditable dans le profil. -La signalisation est intégrée au chat, désactivée par défaut. Un premier -transport natif **Android et Desktop Linux en IPv4/IPv6 directe (LAN/VPN ou IP publique)** est raccordé : -captures Podcast existantes et SRTP direct, sans libwebrtc ni nouvelle -couche JNI WebRTC. Il ne réalise pas encore la cible Internet, TURN ou groupe. +La signalisation est intégrée au chat, désactivée par défaut. La page du chat +utilise maintenant **WebRTC natif sur Android et Desktop Linux**, avec +ICE/STUN/TURN et masquage IP impose par la politique serveur. L'ancien +transport VLC/SRTP n'est plus raccorde a cette page. Les groupes et les +clients navigateur ne sont pas implementes. Il complète la [topologie de PostIt](postit.md) et les [mécanismes de notification existants](notifications.md). La cible couvre : @@ -18,7 +20,105 @@ La cible couvre : - les appels de groupe ; - les clients Browser, Android et Desktop. -## Première implémentation Android et Desktop Linux : SRTP direct IPv4/IPv6 +## Implementation actuelle : WebRTC natif Android et Linux + +- [WebRtcCallViewModel](../../src/PostIt/PostIt/ViewModels/Chat/WebRtcCallViewModel.cs) + conserve invitation/acceptation/fin via SignalR, sans demarrer la capture + avant consentement. Les SDP et candidats ICE utilisent les contrats existants. +- [AndroidWebRtcMedia](../../src/PostIt/PostIt.Android/Services/AndroidWebRtcMedia.cs) + heberge deux surfaces natives. Le pont Java + [WebRtcPeer](../../src/PostIt/PostIt.Android/Services/WebRtcPeer.java) utilise + l'AAR officiel `io.github.webrtc-sdk:android:150.7871.04`, Camera2, + l'audio natif et DTLS-SRTP. Les commandes et callbacks SDP/ICE restent en + Java sur un executeur unique ; pas de WebView ni de binding C# complet du SDK. +- [LinuxWebRtcMedia](../../src/PostIt/PostIt/Services/LinuxWebRtcMedia.cs) + pilote un processus Python GI prive utilisant GStreamer `webrtcbin`, + VP8/Opus, la camera V4L2 et le microphone PulseAudio/PipeWire. + Les trames decodees sont affichees dans Avalonia, l'audio sur la sortie native. + Le protocole JSON utilise uniquement stdin/stdout, pas de serveur local. +- Le serveur impose `RelayOnly` aux deux clients si l'un des comptes masque + son IP. Le client configure la politique native avant capture/negociation, + valide les SDP/candidats sortants et confirme le type du candidat local + de la paire ICE selectionnee. Aucun repli direct ni transport SRTP historique + n'est tente en cas d'echec TURN. +- Avec libnice, les metadonnees ICE `raddr`/`rport` des candidats relais sont + neutralisees a la frontiere de signalisation (RFC 8828), sans modifier + l'adresse du relais ni reecrire le SDP. UPnP est desactive. Les politiques + `relay` de webrtcbin et `force-relay` de libnice sont toutes deux activees. + Un SDP qui expose une adresse non relayee est refuse, pas corrige. +- Raccrocher, sortir de la page/salle, se deconnecter ou passer l'application + en arriere-plan annule aussi un demarrage natif en cours et libere les medias. + Un echec natif, une perte ICE ou 30 secondes sans progression audio/video + terminent l'appel explicitement. Il n'y a pas d'ICE restart/renegociation + automatique ni de migration transparente d'un appel existant. + +Le panneau ne demande plus d'adresse ni de port RTP manuel. Sans masquage, +un consentement explicite au partage IP reste requis. Activer le masquage +dans le profil pendant un appel fait terminer cet appel par le serveur : +il faut rappeler pour appliquer la nouvelle politique. + +Configuration coturn, certificats, ports et dependances Linux : +[INSTALL](../../INSTALL.md#postit-native-webrtc-calls-android-and-linux). +Les moteurs d'appel sont independants des captures/encodeurs Podcast ; +les Podcasts conservent leur chemin existant. + +### Regressions natives + +Tests Linux reels, sans compte ni camera, avec sources video/audio synthetiques, +decodage bidirectionnel, selection effective d'un relais coturn, controle des +adresses signalees et panne TURN sans repli : + +```bash +python3 src/PostIt/PostIt.Tests/Native/webrtc_media_test.py -v +``` + +Installer coturn pour ces tests (ou definir `POSTIT_TURN_SERVER` vers son +executable). Ils demarrent un processus local prive, avec secret REST aleatoire +temporaire, et l'arretent en fin de test ; ils ne changent aucun service systeme. + +Tests du consentement, de la politique, des interruptions et du rendu de vraies +trames dans Avalonia/Skia : + +```bash +XDG_CONFIG_HOME="$(mktemp -d)" POSTIT_TEST_NATIVE_WEBRTC=1 \ + dotnet test --project src/PostIt/PostIt.Tests \ + --filter-class 'PostIt.Tests.WebRtcCallViewModelTests' \ + --filter-class 'PostIt.Tests.LanCallViewModelTests' +``` + +Le test de rendu natif est ignore sans `POSTIT_TEST_NATIVE_WEBRTC=1`. +Les tests headless ordinaires conservent leur moteur de dessin simule. +Utiliser un dossier de configuration de test sans comptes reels et le supprimer +apres execution. + +Le test Android physique est reserve a l'APK **Debug** installe : camera avant, +microphone, deux surfaces natives, pair Linux synthetique et coturn local, +aucun compte ni enregistrement. Il utilise `adb reverse` pour des ports TCP +temporaires et retire uniquement ses propres redirections : + +```bash +POSTIT_TEST_ANDROID_WEBRTC=1 POSTIT_ANDROID_SERIAL=SERIAL \ + python3 src/PostIt/PostIt.Tests/Native/webrtc_media_test.py \ + NativeWebRtcTests.test_android_linux_relay_bidirectional_media -v +``` + +Ce controle local ne remplace pas un essai sur deux reseaux Internet distincts, +avec DNS/certificats publics et pare-feu de production. + +Validation effectuee : 37 tests PostIt (dont rendu Linux avec Skia), 76 tests +serveur de signalisation et 5 regressions natives reussis. Sur le telephone +Android arm64, les deux roles appelant/appele ont recu plus de 100 trames +video et 500 paquets audio pendant au moins 10 secondes, avec deux rendus +natifs confirmes et un candidat local `relay` des deux cotes. La panne TURN +ne produit aucun candidat direct sur Android ou Linux. Les essais utilisent +la camera avant et le microphone Android reels, des sources Linux synthetiques +et un coturn TCP local via USB ; la camera et la sortie audio Linux materielles, +TURN/TLS et les reseaux Internet distincts restent a verifier. + +## Historique : premiere implementation SRTP direct IPv4/IPv6 + +Les paragraphes suivants decrivent le transport precedent, conserve dans le +code et ses tests mais non propose par le panneau d'appel actuel. Les adresses IPv4 publiques directement assignees a une interface locale active sont egalement disponibles, avec la meme validation unicast cote client, @@ -508,45 +608,37 @@ les redémarrages ICE et renégociations restent à implémenter. Configuration serveur, section `AudioVideoCalls` : -- `Enabled` : `false` par défaut, à conserver tant que les moteurs ne sont - pas validés ; +- `Enabled` : `false` par défaut, a activer apres configuration et validation + du deploiement ICE/TURN ; - `StunUrls` : tableau d'URI `stun:` ou `stuns:` ; - `TurnUrls` : tableau d'URI `turn:` ou `turns:`, avec transport optionnel ; - `TurnSharedSecret` : secret REST coturn, **uniquement côté serveur**, à fournir par le gestionnaire de secrets ou la variable d'environnement `AudioVideoCalls__TurnSharedSecret`, jamais dans le dépôt. +Linux GStreamer prend en charge `stun:`, mais pas `stuns:` : utiliser TURN/TLS +pour ce dernier besoin. + Les credentials TURN temporaires sont calculés côté serveur avec le format REST coturn (expiration, nonce aléatoire et HMAC-SHA1). Aucun secret -de longue durée n'est envoyé aux clients. Aucun service TURN n'a été -déployé ou configuré par cette tranche. +de longue durée n'est envoyé aux clients. Aucun service TURN de production +n'est deploye automatiquement ; seuls les tests lancent un coturn isole. Le [transport PostIt](../../src/PostIt/PostIt/Services/CallSignalingClient.cs) utilise la connexion authentifiée du `ChatViewModel`, sans seconde connexion ni interrogation HTTP. Il expose les commandes et événements typés et -signale les interruptions ; il ne capture aucun média. L'interface ne -propose pas encore de bouton d'appel ; une éventuelle invitation est -signalée comme non utilisable faute de moteur natif, sans acceptation -automatique. +signale les interruptions ; il ne capture aucun média. +Le panneau WebRTC de la page du chat et les deux adaptateurs natifs +consomment maintenant cette signalisation, toujours sans acceptation automatique. ### Travail restant pour la cible Internet multi-plateforme -- Android : l'approche Java/JNI libwebrtc a été écartée à la demande du - projet ; aucun adaptateur libwebrtc expérimental n'est conservé. - L'adaptateur SRTP LAN réutilise désormais la capture Podcast ; la solution - compatible avec la cible Internet reste à choisir. -- Desktop Linux : le transport SRTP LAN est raccordé, mais ne remplace pas - les validations matérielles ni une solution de connectivité Internet. -- Côté partagé : relier consentement, états réels du moteur, mise en - sourdine, arrêt et libération des ressources à la signalisation. -- Valider un appel Android ↔ Desktop Linux avec caméra avant et microphone - réels, rendu et audio distants, VP8/Opus, puis transport TURN sélectionné - dans les statistiques, sans repli direct lorsque le masquage est demandé. - -Les tests de cette tranche portent sur les contrats, autorisations, courses -d'acceptation, expirations, limites, interruption et préférence persistée. -La compilation des applications Android et Desktop ne prouve pas le -fonctionnement de WebRTC natif : le crash antérieur n'est pas résolu. +- Valider les cameras, microphones et sorties audio Linux materiels. +- Valider les appels sur deux reseaux Internet distincts, UDP/TCP/TLS, + DNS, certificats et politiques de pare-feu de production. +- Ajouter si necessaire les commandes de sourdine, renegociation/ICE restart + et renouvellement des credentials pour les appels longs. +- Les groupes/SFU, Browser et les autres plateformes restent hors perimetre. ## Retour sur l'essai Android du 25 octobre 2026 @@ -584,4 +676,9 @@ impossibilité de WebRTC sur Android ou une défaillance du ChatHub. Les essais Browser/GStreamer réussis utilisaient des sources synthétiques et un décodage sans affichage côté GStreamer : ils ne valident pas PostIt.Desktop Linux, ses périphériques réels ou son rendu Avalonia. -La validation multi-plateforme demeure incomplète. \ No newline at end of file +Ces limites de l'ancien laboratoire ne constituent plus le bilan du moteur +actuel : les nouvelles regressions Android/GStreamer ci-dessus verifient +des medias bidirectionnels et des rendus reels via TURN. La cause precise +du crash de cet ancien prototype reste inconnue ; aucun crash natif n'a +ete reproduit pendant les nouveaux essais. Cela ne remplace pas les +validations Internet et materielles encore indiquees. \ No newline at end of file diff --git a/doc/architecture/postit.md b/doc/architecture/postit.md index baa2331e8..b32832559 100644 --- a/doc/architecture/postit.md +++ b/doc/architecture/postit.md @@ -47,6 +47,21 @@ spécifiques (IntentFilter Android, `app.manifest` Desktop). Toute la logique (VM, services, navigation, settings, OIDC) est dans le code-base partagé. +## Abonnements PayPal + +La page native **Mon abonnement PayPal** est accessible depuis l'accueil, +le profil et « À propos ». Elle utilise `ResourceSubscriptionsApiClient` +avec l'autorité OIDC configurée pour charger les offres, l'abonnement en +cours et le solde. Les prix HT/TTC, la TVA et les droits proviennent du serveur. +La création ou reprise de souscription utilise la session bearer de PostIt ; +seule l'approbation est ouverte dans le navigateur, sur un domaine PayPal HTTPS. +Après approbation ou abandon, l'utilisateur revient dans PostIt et utilise +**Actualiser les paiements et mon solde**. Ni l'ouverture du navigateur ni +la page de retour ne prouvent un paiement : seul le rapprochement serveur +des transactions vérifiées accorde les droits. La résiliation demande une +confirmation explicite et conserve les droits des périodes déjà payées. +La configuration serveur et les routes sont décrites dans [INSTALL.md](../../INSTALL.md). + ## Reprise Android `IActivityApplicationLifetime.MainViewFactory` crée une nouvelle `MainView` diff --git a/doc/plan-test-cleanup.md b/doc/plan-test-cleanup.md new file mode 100644 index 000000000..00bab1aac --- /dev/null +++ b/doc/plan-test-cleanup.md @@ -0,0 +1,173 @@ +# Plan de nettoyage de la suite PostIt + +## Objectif + +Rendre la suite PostIt plus rapide, plus fiable et plus lisible, sans bloquer le développement quotidien par des tests dépendants d’un matériel, d’un binaire externe ou d’un environnement local spécifique. + +## Problème actuel + +La suite a grossi sans vraie séparation entre : + +- tests rapides et déterministes, +- tests UI headless, +- tests d’intégration, +- tests dépendants de l’environnement, +- tests Android / native / device-specific. + +Résultat : la routine par défaut devient bruitée et peu fiable, et les sujets de fond (comportement métier) sont noyés dans des tests exigeants en dépendances système. + +## Plan proposé + +### 1. Séparer la suite par catégorie de dépendance + +Les tests doivent être classés selon leur coût et leur dépendance externe, avec des annotations de classe xUnit du type : + +```csharp +[Trait("Category", "Native")] +[Trait("Category", "Slow")] +public sealed class PodcastNativeCaptureTests +``` + +Et pour les tests Android : + +```csharp +[Trait("Category", "Android")] +public class AndroidAppLaunchTests +``` + + +- Fast unit tests +- Headless UI tests +- Integration tests +- Native / environment-dependent tests +- Android-only tests + +La règle doit être simple : un test ne doit entrer dans la routine par défaut que s’il est exécutable sans matériel, binaire externe ni fichier de test local spécifique. + +### 2. Garder la routine par défaut “portable” + +La suite standard de développement doit couvrir uniquement : + +- les comportements métier, +- les flux UI sans environnement spécifique, +- les tests reproductibles sans dépendances natives. + +Les tests qui exigent : + +- LibVLC, +- ffprobe / codecs, +- fichiers médias locaux, +- Android emulator / adb, +- services device-bound, + +doivent être exclus de la routine standard. + +### 3. Isoler les tests non-portables + +Les tests dépendants de l’environnement doivent être déplacés ou séparés dans une catégorie spécifique, par exemple : + +- `Native` +- `Android` +- `Slow` + +Cela permet de conserver la signalisation de leur objectif sans polluer la suite principale. + +### 4. Nettoyer les doublons fonctionnels + +Les tests qui vérifient le même comportement avec seulement de légères variantes doivent être regroupés, fusionnés ou simplifiés. + +Règle de qualité : + +- 1 test = 1 comportement clair, +- 1 titre = 1 intention claire, +- 1 appel de fonction = 1 vérification utile. + +### 5. Structurer les tests par feature et par niveau + +Exemple de structure suggérée : + +- `PostIt.Tests/Fast/` +- `PostIt.Tests/Headless/` +- `PostIt.Tests/Integration/` +- `PostIt.Tests/Native/` +- `PostIt.Tests/Android/` + +Cette structure permet de distinguer immédiatement les tests de comportement des tests d’infrastructure. + +### 6. Séparer la CI en deux niveaux + +- CI standard / PR : tests rapides + headless +- CI nocturne / full : tests native + Android + integration lourde + +Cela permet d’avoir un cycle de développement rapide sans sacrifier une vraie validation dans les scénarios spécifiques. + +## Catégorisation cible des tests + +Important : les catégories xUnit ne doivent être appliquées qu’aux vraies classes de test. Les `Activity` Android utilisées comme harness de test ne sont pas des classes de test et ne doivent pas porter de `[Trait("Category", ...)]`. + +### Native + +Classes de test xUnit qui dépendent de LibVLC, de fichiers multimédia locaux, de codecs ou d’un support natif Linux/OS spécifique. + +- `LinuxLanCallMediaTests` +- `PodcastNativeCaptureTests` +- `PodcastReplayTests` +- `WebRtcCallViewModelTests` — sous-cas natif activé avec `POSTIT_TEST_NATIVE_WEBRTC=1` + +### Android + +Classes de test xUnit qui tournent sur un contexte Android spécifique, sur `adb`, sur un émulateur ou sur un device Android réel. + +- `AndroidAppLaunchTests` + +### Slow + +Classes de test xUnit lourdes ou lentes, souvent partielles sur le flux média, la capture ou la lecture de données. Elles doivent être explicitement marquées comme `Slow` pour ne pas polluer la suite standard. + +- `PodcastNativeCaptureTests` +- `PodcastReplayTests` +- `LinuxLanCallMediaTests` +- `WebRtcCallViewModelTests` — variante native / réseau / media-heavy + +### Harness Android de support (non test classes) + +Ces classes servent à déclencher un test Android dans un `Activity` dédié, mais elles ne sont pas des classes xUnit de test et ne portent pas de trait de catégorie. + +- `AndroidCameraFrameRotationTestActivity` +- `AndroidChatServiceTestActivity` +- `AndroidLanCallTestActivity` +- `AndroidMarkdownEditorTestActivity` +- `AndroidPodcastBlurTestActivity` +- `AndroidPodcastCaptureTestActivity` +- `AndroidScreenAwakeTestActivity` +- `AndroidWebRtcTestActivity` + +### Tests non-portables à sortir de la routine par défaut + +Les classes de test ci-dessous dépendent d’un environnement local spécifique, d’un binaire externe ou d’un matériel Android / native. Elles ne devraient pas faire partie de la routine quotidienne standard. + +- `AndroidAppLaunchTests` +- `LinuxLanCallMediaTests` +- `PodcastNativeCaptureTests` +- `PodcastReplayTests` +- `WebRtcCallViewModelTests` — cas native spécifique avec `POSTIT_TEST_NATIVE_WEBRTC=1` + +## Exemples de dépendances qui rendent ces tests non-portables + +- `POSTIT_TEST_MEDIA` +- `POSTIT_TEST_TS` +- `POSTIT_TEST_REPLAY` +- `POSTIT_TEST_NATIVE_WEBRTC` +- `adb` / appareil Android connecté +- LibVLC installé avec les codecs nécessaires +- fichiers vidéo/audio locaux +- machines Linux spécifiques + +## État souhaité + +Une suite PostIt propre doit avoir : + +- une routine standard courte et stable, +- des tests natifs clairement isolés, +- une séparation nette des responsabilités, +- un signal de qualité lisible pour les contributeurs. diff --git a/package.json b/package.json index c8d376253..4acd90a5d 100644 --- a/package.json +++ b/package.json @@ -10,22 +10,13 @@ "clean:js": "node esbuild.config.mjs --clean" }, "dependencies": { - "@aspnet/signalr": "^1.0.27", "bootstrap": "^4.6.2", - "dropzone": "^5.9.3", - "eonasdan-bootstrap-datetimepicker": "^4.17.49", - "hls.js": "1.6.13", "jquery": "^3.7.1", - "jquery-timepicker": "^1.3.3", "jquery-ui": "^1.13.3", "jquery-validation": "^1.20.0", - "jquery-validation-unobtrusive": "^4.0.0", - "moment": "^2.30.1", - "quill": "^1.3.7", - "showdown": "^2.1.0", - "to-markdown": "^3.1.1" + "jquery-validation-unobtrusive": "^4.0.0" }, "devDependencies": { - "esbuild": "^0.24.0" + "esbuild": "^0.28.2" } } diff --git a/src/PostIt/Directory.Packages.props b/src/PostIt/Directory.Packages.props index b1be58760..41ff905e5 100644 --- a/src/PostIt/Directory.Packages.props +++ b/src/PostIt/Directory.Packages.props @@ -4,18 +4,19 @@ true - 12.1.4 + 12.1.6 - - + + + diff --git a/src/PostIt/PostIt.Android/Icon.png b/src/PostIt/PostIt.Android/Icon.png index 3c3984593..d928a2c12 100644 Binary files a/src/PostIt/PostIt.Android/Icon.png and b/src/PostIt/PostIt.Android/Icon.png differ diff --git a/src/PostIt/PostIt.Android/MainActivity.cs b/src/PostIt/PostIt.Android/MainActivity.cs index f962761c2..46b386454 100644 --- a/src/PostIt/PostIt.Android/MainActivity.cs +++ b/src/PostIt/PostIt.Android/MainActivity.cs @@ -16,8 +16,8 @@ namespace PostIt.Android; Theme = "@style/MyTheme.NoActionBar", Icon = "@drawable/icon", MainLauncher = true, - WindowSoftInputMode = SoftInput.AdjustResize, - ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize | ConfigChanges.UiMode) + ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize | ConfigChanges.UiMode + ) ] public class MainActivity : AvaloniaMainActivity { diff --git a/src/PostIt/PostIt.Android/PlatformBootstrap.cs b/src/PostIt/PostIt.Android/PlatformBootstrap.cs index ab1681bb9..9e0224cf1 100644 --- a/src/PostIt/PostIt.Android/PlatformBootstrap.cs +++ b/src/PostIt/PostIt.Android/PlatformBootstrap.cs @@ -27,6 +27,10 @@ internal static class PlatformBootstrap Platform.CreateVideoSurface = (player, replay) => new AndroidVideoSurface(player, replay); if (System.OperatingSystem.IsAndroidVersionAtLeast(26)) { + Platform.CreateWebRtcMedia = () => System.OperatingSystem.IsAndroidVersionAtLeast(26) + ? new AndroidWebRtcMedia() + : throw new System.PlatformNotSupportedException("Android 8 requis pour WebRTC."); + Platform.GetWebRtcDevices = AndroidLanCallMedia.GetDevices; Platform.GetLanCallDevices = AndroidLanCallMedia.GetDevices; Platform.CreateLanCallMedia = (address, port) => System.OperatingSystem.IsAndroidVersionAtLeast(26) diff --git a/src/PostIt/PostIt.Android/PostIt.Android.csproj b/src/PostIt/PostIt.Android/PostIt.Android.csproj index 5e0e84217..3376eccef 100644 --- a/src/PostIt/PostIt.Android/PostIt.Android.csproj +++ b/src/PostIt/PostIt.Android/PostIt.Android.csproj @@ -30,6 +30,10 @@ + + + + @@ -40,6 +44,7 @@ + - - - - - - - - - - - - - - - - + xmlns:tools="http://schemas.android.com/tools" android:installLocation="auto" +> + + + + + + + + + + + + + + + + + diff --git a/src/PostIt/PostIt.Android/Services/AndroidWebRtcMedia.cs b/src/PostIt/PostIt.Android/Services/AndroidWebRtcMedia.cs new file mode 100644 index 000000000..300fe8351 --- /dev/null +++ b/src/PostIt/PostIt.Android/Services/AndroidWebRtcMedia.cs @@ -0,0 +1,164 @@ +using System; +using System.Diagnostics; +using System.Runtime.Versioning; +using System.Threading; +using System.Threading.Tasks; +using Android.Content; +using Android.Runtime; +using Avalonia.Android; +using Avalonia.Controls; +using Avalonia.Platform; +using PostIt.Services; + +namespace PostIt.Android.Services; + +[SupportedOSPlatform("android26.0")] +internal sealed class AndroidWebRtcMedia : WebRtcNativeMedia +{ + private readonly CancellationTokenSource _lifetime = new(); + private readonly Peer _peer; + private readonly Surface _local; + private readonly Surface _remote; + private readonly Task _poll; + private readonly TaskCompletionSource _closed = new(TaskCreationOptions.RunContinuationsAsynchronously); + private bool _disposed; + + public override Control LocalVideo => _local; + public override Control RemoteVideo => _remote; + + public AndroidWebRtcMedia() + { + _peer = new Peer(MainActivity.Current ?? throw new InvalidOperationException("Activité Android indisponible.")); + _local = new Surface(_peer.GetView("localView")); + _remote = new Surface(_peer.GetView("remoteView")); + _poll = Task.Run(PollAsync); + } + + protected override async Task StartCoreAsync(WebRtcMediaConfiguration configuration, CancellationToken ct) + { + var activity = MainActivity.Current ?? throw new InvalidOperationException("Activité Android indisponible."); + await PodcastPermissions.EnsureAsync(activity, microphone: true, ct, notifications: false); + if (!MainActivity.IsForeground) + throw new InvalidOperationException("Revenez dans PostIt pour demarrer l'appel."); + await Task.WhenAll(_local.Ready, _remote.Ready).WaitAsync(TimeSpan.FromSeconds(10), ct); + await SendCommandAsync(StartCommand(configuration), ct); + } + + protected override Task SendCommandAsync(string json, CancellationToken ct) + { + ct.ThrowIfCancellationRequested(); + _peer.Command(json); + return Task.CompletedTask; + } + + private async Task PollAsync() + { + var stats = Stopwatch.StartNew(); + var failed = false; + try + { + while (!_lifetime.IsCancellationRequested) + { + for (var i = 0; i < 64 && _peer.Poll() is { } message; i++) + { + if (message == "{\"type\":\"closed\"}") _closed.TrySetResult(); + if (!failed) + { + try { ProcessMessage(message); } + catch (Exception error) + { + failed = true; + Fail(error); + if (_disposed) _closed.TrySetException(error); + } + } + } + if (!_disposed && !failed && Configuration is not null && stats.Elapsed >= TimeSpan.FromSeconds(1)) + { + _peer.Command("{\"command\":\"stats\"}"); + stats.Restart(); + } + await Task.Delay(20, _lifetime.Token); + } + } + catch (OperationCanceledException) when (_lifetime.IsCancellationRequested) { } + catch (Exception error) { Fail(error); _closed.TrySetException(error); } + } + + public override async ValueTask DisposeAsync() + { + if (_disposed) return; + _disposed = true; + try + { + _peer.Command("{\"command\":\"close\"}"); + await _closed.Task.WaitAsync(TimeSpan.FromSeconds(10)); + } + finally + { + _lifetime.Cancel(); + await _poll; + _peer.Dispose(); + _lifetime.Dispose(); + Closed(); + } + } + + private sealed class Surface(global::Android.Views.View view) : NativeControlHost + { + private readonly TaskCompletionSource _ready = new(TaskCreationOptions.RunContinuationsAsynchronously); + public Task Ready => _ready.Task; + protected override IPlatformHandle CreateNativeControlCore(IPlatformHandle parent) + { + _ready.TrySetResult(); + return new AndroidViewControlHandle(view); + } + } + + // Only this small Java bridge crosses JNI. SDP and ICE callbacks stay in Java, + // where the native SDK owns their lifetime and thread affinity. + private sealed class Peer : IDisposable + { + private readonly Java.Lang.Class _type; + private readonly Java.Lang.Object _instance; + private readonly Java.Lang.Reflect.Method _command; + private readonly Java.Lang.Reflect.Method _poll; + + public Peer(Context context) + { + _type = Java.Lang.Class.ForName("fr.pschneider.postit.WebRtcPeer")!; + using var contextType = Java.Lang.Class.FromType(typeof(Context)); + using var constructor = _type.GetConstructor(contextType); + _instance = constructor!.NewInstance(context)!; + using var stringType = Java.Lang.Class.FromType(typeof(Java.Lang.String)); + _command = _type.GetMethod("command", stringType)!; + _poll = _type.GetMethod("poll")!; + } + + public global::Android.Views.View GetView(string method) + { + using var getter = _type.GetMethod(method); + return getter!.Invoke(_instance)!.JavaCast()!; + } + + public void Command(string message) + { + using var value = new Java.Lang.String(message); + _command.Invoke(_instance, value); + } + + public string? Poll() + { + using var result = _poll.Invoke(_instance); + return result?.ToString(); + } + + public void Dispose() + { + _command.Dispose(); + _poll.Dispose(); + _instance.Dispose(); + _type.Dispose(); + } + } +} diff --git a/src/PostIt/PostIt.Android/Services/PodcastPermissions.cs b/src/PostIt/PostIt.Android/Services/PodcastPermissions.cs index 9c81338cc..69c3e5ead 100644 --- a/src/PostIt/PostIt.Android/Services/PodcastPermissions.cs +++ b/src/PostIt/PostIt.Android/Services/PodcastPermissions.cs @@ -32,6 +32,7 @@ internal static class PodcastPermissions if (!await pending.Task.WaitAsync(ct)) throw new UnauthorizedAccessException(notifications ? "Autorisez la camera, les notifications et, si selectionne, le microphone pour diffuser." + : microphone ? "Autorisez la camera et le microphone pour l'appel." : "Autorisez la camera pour la previsualisation."); } diff --git a/src/PostIt/PostIt.Android/Services/WebRtcPeer.java b/src/PostIt/PostIt.Android/Services/WebRtcPeer.java new file mode 100644 index 000000000..f959739fa --- /dev/null +++ b/src/PostIt/PostIt.Android/Services/WebRtcPeer.java @@ -0,0 +1,323 @@ +package fr.pschneider.postit; + +import android.content.Context; +import org.json.JSONArray; +import org.json.JSONObject; +import org.webrtc.*; +import org.webrtc.audio.JavaAudioDeviceModule; +import java.util.*; +import java.util.concurrent.*; + +/** Keeps all SDK operations and asynchronous SDP callbacks on one executor. */ +public final class WebRtcPeer { + private final Context context; + private final EglBase egl = EglBase.create(); + private final SurfaceViewRenderer local; + private final SurfaceViewRenderer remote; + private final ExecutorService executor = Executors.newSingleThreadExecutor(); + private final ArrayBlockingQueue events = new ArrayBlockingQueue<>(64); + private final List pendingLocal = new ArrayList<>(); + private final List pendingRemote = new ArrayList<>(); + private PeerConnectionFactory factory; + private PeerConnection peer; + private JavaAudioDeviceModule audioModule; + private VideoCapturer capturer; + private SurfaceTextureHelper texture; + private VideoSource videoSource; + private AudioSource audioSource; + private VideoTrack videoTrack; + private AudioTrack audioTrack; + private VideoTrack remoteTrack; + private boolean localDescriptionSent; + private boolean remoteDescriptionSet; + private volatile boolean closed; + private volatile boolean localRendered; + private volatile boolean remoteRendered; + + public WebRtcPeer(Context context) { + this.context = context.getApplicationContext(); + local = new SurfaceViewRenderer(context); + remote = new SurfaceViewRenderer(context); + local.init(egl.getEglBaseContext(), new RendererCommon.RendererEvents() { + public void onFirstFrameRendered() { localRendered = true; } + public void onFrameResolutionChanged(int width, int height, int rotation) {} + }); + local.setMirror(true); + remote.init(egl.getEglBaseContext(), new RendererCommon.RendererEvents() { + public void onFirstFrameRendered() { remoteRendered = true; } + public void onFrameResolutionChanged(int width, int height, int rotation) {} + }); + local.setEnableHardwareScaler(true); + remote.setEnableHardwareScaler(true); + } + + public android.view.View localView() { return local; } + public android.view.View remoteView() { return remote; } + public String poll() { return events.poll(); } + + private void enqueue(Runnable action) { + try { + executor.execute(() -> { + try { action.run(); } + catch (Exception failure) { error(failure.getMessage()); } + }); + } catch (RejectedExecutionException failure) { + if (!closed) throw failure; + } + } + + public void command(String json) { + enqueue(() -> { + try { + JSONObject message = new JSONObject(json); + switch (message.getString("command")) { + case "start": start(message.getJSONObject("configuration")); break; + case "signal": signal(message.getJSONObject("signal")); break; + case "stats": if (peer != null && !closed) peer.getStats(this::stats); break; + case "close": close(); break; + default: throw new IllegalArgumentException("Unknown WebRTC command"); + } + } catch (Exception error) { error(error.getMessage()); } + }); + } + + private void emit(JSONObject value) { + if (!events.offer(value.toString())) { + events.clear(); + events.offer("{\"type\":\"error\",\"message\":\"WebRTC event queue overflow\"}"); + } + } + + private void error(String message) { + try { emit(new JSONObject().put("type", "error").put("message", message)); } + catch (org.json.JSONException impossible) { throw new IllegalStateException(impossible); } + } + + private void start(JSONObject configuration) throws Exception { + if (factory != null || closed) throw new IllegalStateException("WebRTC already started or closed"); + PeerConnectionFactory.initialize(PeerConnectionFactory.InitializationOptions.builder(context) + .setEnableInternalTracer(false).createInitializationOptions()); + audioModule = JavaAudioDeviceModule.builder(context).createAudioDeviceModule(); + factory = PeerConnectionFactory.builder().setAudioDeviceModule(audioModule) + .setVideoEncoderFactory(new DefaultVideoEncoderFactory(egl.getEglBaseContext(), true, true)) + .setVideoDecoderFactory(new DefaultVideoDecoderFactory(egl.getEglBaseContext())).createPeerConnectionFactory(); + List servers = new ArrayList<>(); + JSONArray configuredServers = configuration.getJSONArray("iceServers"); + boolean relay = configuration.getBoolean("relayOnly"); + for (int i = 0; i < configuredServers.length(); i++) { + JSONObject item = configuredServers.getJSONObject(i); + JSONArray urls = item.getJSONArray("urls"); + for (int j = 0; j < urls.length(); j++) { + String url = urls.getString(j); + if (relay && !url.startsWith("turn:") && !url.startsWith("turns:")) continue; + PeerConnection.IceServer.Builder server = PeerConnection.IceServer.builder(url); + if (!item.isNull("username")) server.setUsername(item.getString("username")); + if (!item.isNull("credential")) server.setPassword(item.getString("credential")); + servers.add(server.createIceServer()); + } + } + PeerConnection.RTCConfiguration rtc = new PeerConnection.RTCConfiguration(servers); + rtc.sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN; + rtc.bundlePolicy = PeerConnection.BundlePolicy.MAXBUNDLE; + rtc.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.REQUIRE; + rtc.iceTransportsType = relay ? PeerConnection.IceTransportsType.RELAY : PeerConnection.IceTransportsType.ALL; + peer = factory.createPeerConnection(rtc, new Observer()); + if (peer == null) throw new IllegalStateException("Cannot create native WebRTC peer"); + Camera2Enumerator cameras = new Camera2Enumerator(context); + String camera = configuration.getString("camera"); + capturer = cameras.createCapturer(camera, new CameraVideoCapturer.CameraEventsHandler() { + public void onCameraError(String message) { error("Camera: " + message); } + public void onCameraDisconnected() { if (!closed) error("Camera disconnected"); } + public void onCameraFreezed(String message) { error("Camera frozen: " + message); } + public void onCameraOpening(String name) {} + public void onFirstFrameAvailable() {} + public void onCameraClosed() { if (!closed) error("Camera closed unexpectedly"); } + }); + if (capturer == null) throw new IllegalArgumentException("Camera unavailable"); + texture = SurfaceTextureHelper.create("PostIt-WebRTC-camera", egl.getEglBaseContext()); + videoSource = factory.createVideoSource(false); + capturer.initialize(texture, context, videoSource.getCapturerObserver()); + videoTrack = factory.createVideoTrack("postit-video", videoSource); + videoTrack.addSink(local); + audioSource = factory.createAudioSource(new MediaConstraints()); + audioTrack = factory.createAudioTrack("postit-audio", audioSource); + peer.addTrack(audioTrack, Collections.singletonList("postit")); + peer.addTrack(videoTrack, Collections.singletonList("postit")); + capturer.startCapture(640, 480, 24); + if (configuration.getBoolean("caller")) peer.createOffer(new CreateDescription("offer"), new MediaConstraints()); + } + + private abstract class SdpCallback implements SdpObserver { + public void onCreateSuccess(SessionDescription description) {} + public void onSetSuccess() {} + public void onCreateFailure(String message) { error("SDP creation failed: " + message); } + public void onSetFailure(String message) { error("SDP application failed: " + message); } + } + + private final class CreateDescription extends SdpCallback { + private final String kind; + CreateDescription(String kind) { this.kind = kind; } + public void onCreateSuccess(SessionDescription description) { + enqueue(() -> { + if (closed) return; + peer.setLocalDescription(new SdpCallback() { + public void onSetSuccess() { + enqueue(() -> { + if (closed) return; + try { + emit(new JSONObject().put("type", "signal").put("signal", + new JSONObject().put("kind", kind).put("sdp", description.description))); + localDescriptionSent = true; + for (IceCandidate candidate : pendingLocal) sendCandidate(candidate); + pendingLocal.clear(); + } catch (Exception failure) { error(failure.getMessage()); } + }); + } + }, description); + }); + } + } + + private void signal(JSONObject signal) throws Exception { + if (closed || peer == null) throw new IllegalStateException("WebRTC peer not running"); + String kind = signal.getString("kind"); + if (kind.equals("candidate")) { + IceCandidate candidate = new IceCandidate(signal.getString("sdpMid"), + signal.getInt("sdpMLineIndex"), signal.getString("candidate")); + if (remoteDescriptionSet) addCandidate(candidate); + else { + if (pendingRemote.size() >= 256) throw new IllegalStateException("Too many pending ICE candidates"); + pendingRemote.add(candidate); + } + } else if (kind.equals("offer") || kind.equals("answer")) { + peer.setRemoteDescription(new SdpCallback() { + public void onSetSuccess() { + enqueue(() -> { + if (closed) return; + remoteDescriptionSet = true; + for (IceCandidate candidate : pendingRemote) addCandidate(candidate); + pendingRemote.clear(); + if (kind.equals("offer")) peer.createAnswer(new CreateDescription("answer"), new MediaConstraints()); + }); + } + }, new SessionDescription(kind.equals("offer") ? SessionDescription.Type.OFFER : SessionDescription.Type.ANSWER, + signal.getString("sdp"))); + } else throw new IllegalArgumentException("Invalid WebRTC signal"); + } + + private void addCandidate(IceCandidate candidate) { + peer.addIceCandidate(candidate, new AddIceObserver() { + public void onAddSuccess() {} + public void onAddFailure(String message) { error("ICE candidate rejected: " + message); } + }); + } + + private void sendCandidate(IceCandidate candidate) { + try { + emit(new JSONObject().put("type", "signal").put("signal", new JSONObject() + .put("kind", "candidate").put("candidate", candidate.sdp) + .put("sdpMid", candidate.sdpMid).put("sdpMLineIndex", candidate.sdpMLineIndex))); + } catch (Exception failure) { error(failure.getMessage()); } + } + + private void stats(RTCStatsReport report) { + enqueue(() -> { + if (closed) return; + try { + Map all = report.getStatsMap(); + String selectedId = null, localType = null; + long audioPackets = 0, videoFrames = 0; + for (RTCStats item : all.values()) { + Map values = item.getMembers(); + if (item.getType().equals("transport") && values.get("selectedCandidatePairId") instanceof String) + selectedId = (String)values.get("selectedCandidatePairId"); + if (item.getType().equals("inbound-rtp")) { + String media = String.valueOf(values.getOrDefault("kind", values.get("mediaType"))); + if (media.equals("audio")) audioPackets += number(values.get("packetsReceived")); + if (media.equals("video")) videoFrames += number(values.get("framesDecoded")); + } + } + RTCStats pair = all.get(selectedId); + if (pair != null) { + RTCStats candidate = all.get(String.valueOf(pair.getMembers().get("localCandidateId"))); + if (candidate != null) localType = String.valueOf(candidate.getMembers().get("candidateType")); + } + String state = peer.connectionState().toString().toLowerCase(Locale.ROOT); + if (state.equals("connected") && localType == null) state = "checking"; + emit(new JSONObject().put("type", "status").put("status", new JSONObject() + .put("connectionState", state).put("localCandidateType", localType) + .put("audioPackets", audioPackets).put("videoFrames", videoFrames) + .put("localVideoRendered", localRendered).put("remoteVideoRendered", remoteRendered))); + } catch (Exception failure) { error(failure.getMessage()); } + }); + } + + private static long number(Object value) { return value instanceof Number ? ((Number)value).longValue() : 0; } + + private final class Observer implements PeerConnection.Observer { + public void onSignalingChange(PeerConnection.SignalingState state) {} + public void onIceConnectionChange(PeerConnection.IceConnectionState state) {} + public void onIceConnectionReceivingChange(boolean receiving) {} + public void onIceGatheringChange(PeerConnection.IceGatheringState state) {} + public void onIceCandidatesRemoved(IceCandidate[] candidates) {} + public void onAddStream(MediaStream stream) {} + public void onRemoveStream(MediaStream stream) {} + public void onDataChannel(DataChannel channel) {} + public void onRenegotiationNeeded() {} + public void onIceCandidate(IceCandidate candidate) { + enqueue(() -> { + if (closed) return; + if (localDescriptionSent) sendCandidate(candidate); + else if (pendingLocal.size() < 256) pendingLocal.add(candidate); + else error("Too many local ICE candidates"); + }); + } + public void onTrack(RtpTransceiver transceiver) { + MediaStreamTrack track = transceiver.getReceiver().track(); + if (track instanceof VideoTrack) { + enqueue(() -> { + if (closed) return; + remoteTrack = (VideoTrack)track; + remoteTrack.addSink(remote); + }); + } + } + } + + private interface Cleanup { void run() throws Exception; } + + private void release(Cleanup cleanup, List failures) { + try { cleanup.run(); } + catch (Exception failure) { failures.add(failure.toString()); } + } + + private void close() { + if (closed) return; + closed = true; + List failures = new ArrayList<>(); + if (capturer != null) release(() -> capturer.stopCapture(), failures); + if (remoteTrack != null) release(() -> remoteTrack.removeSink(remote), failures); + if (videoTrack != null) release(() -> videoTrack.removeSink(local), failures); + if (peer != null) { + release(() -> peer.close(), failures); + release(() -> peer.dispose(), failures); + } + if (videoTrack != null) release(() -> videoTrack.dispose(), failures); + if (audioTrack != null) release(() -> audioTrack.dispose(), failures); + if (capturer != null) release(() -> capturer.dispose(), failures); + if (texture != null) release(() -> texture.dispose(), failures); + if (videoSource != null) release(() -> videoSource.dispose(), failures); + if (audioSource != null) release(() -> audioSource.dispose(), failures); + if (factory != null) release(() -> factory.dispose(), failures); + if (audioModule != null) release(() -> audioModule.release(), failures); + new android.os.Handler(android.os.Looper.getMainLooper()).post(() -> { + release(() -> local.release(), failures); + release(() -> remote.release(), failures); + release(() -> egl.release(), failures); + if (!failures.isEmpty()) error("WebRTC cleanup failed: " + String.join("; ", failures)); + try { emit(new JSONObject().put("type", "closed")); } + catch (Exception failure) { error(failure.getMessage()); } + }); + executor.shutdown(); + } +} diff --git a/src/PostIt/PostIt.Android/proguard-rules.pro b/src/PostIt/PostIt.Android/proguard-rules.pro index 210830083..6e4e25e71 100644 --- a/src/PostIt/PostIt.Android/proguard-rules.pro +++ b/src/PostIt/PostIt.Android/proguard-rules.pro @@ -7,3 +7,5 @@ -keepattributes *Annotation* -dontwarn org.videolan.libvlc.** -dontwarn org.videolan.medialibrary.** +-keep class org.webrtc.** { *; } +-keep class fr.pschneider.postit.WebRtcPeer { *; } diff --git a/src/PostIt/PostIt.Tests/AboutTermsTests.cs b/src/PostIt/PostIt.Tests/AboutTermsTests.cs index 3b4a1e7c4..4e133d05e 100644 --- a/src/PostIt/PostIt.Tests/AboutTermsTests.cs +++ b/src/PostIt/PostIt.Tests/AboutTermsTests.cs @@ -2,6 +2,7 @@ using PostIt.ViewModels; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public sealed class AboutTermsTests { [Fact] diff --git a/src/PostIt/PostIt.Tests/ActivitiesPageViewModelTests.cs b/src/PostIt/PostIt.Tests/ActivitiesPageViewModelTests.cs index 6cac39603..d82ae084b 100644 --- a/src/PostIt/PostIt.Tests/ActivitiesPageViewModelTests.cs +++ b/src/PostIt/PostIt.Tests/ActivitiesPageViewModelTests.cs @@ -5,6 +5,7 @@ using Yavsc.Api.Client; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class ActivitiesPageViewModelTests { [Fact] diff --git a/src/PostIt/PostIt.Tests/ActivityNavigationTests.cs b/src/PostIt/PostIt.Tests/ActivityNavigationTests.cs index 607523deb..331a49af0 100644 --- a/src/PostIt/PostIt.Tests/ActivityNavigationTests.cs +++ b/src/PostIt/PostIt.Tests/ActivityNavigationTests.cs @@ -7,6 +7,7 @@ using PostIt.Views; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class ActivityNavigationTests { [AvaloniaFact] diff --git a/src/PostIt/PostIt.Tests/AddCircleMemberDialogTests.cs b/src/PostIt/PostIt.Tests/AddCircleMemberDialogTests.cs index 8bec1dc60..fa10be0d8 100644 --- a/src/PostIt/PostIt.Tests/AddCircleMemberDialogTests.cs +++ b/src/PostIt/PostIt.Tests/AddCircleMemberDialogTests.cs @@ -2,7 +2,6 @@ using Avalonia; using Avalonia.Headless.XUnit; using Microsoft.Extensions.DependencyInjection; -using PostIt.Helpers; using PostIt.Services; using PostIt.ViewModels; using PostIt.Views; @@ -29,6 +28,7 @@ namespace PostIt.Tests; /// click via button.Command?.Execute(...) + flush /// any async command before asserting. /// +[Trait("Category", "non-reg")] public class AddCircleMemberDialogTests { /// diff --git a/src/PostIt/PostIt.Tests/AdministrationAccessTests.cs b/src/PostIt/PostIt.Tests/AdministrationAccessTests.cs index 30feb7b6e..429e0ac98 100644 --- a/src/PostIt/PostIt.Tests/AdministrationAccessTests.cs +++ b/src/PostIt/PostIt.Tests/AdministrationAccessTests.cs @@ -1,4 +1,3 @@ -using System.Net.Http; using System.Text.Json; using Avalonia.Controls; using Avalonia.Headless.XUnit; @@ -13,6 +12,7 @@ using Yavsc.Api.Client; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class AdministrationAccessTests { [Fact] @@ -41,44 +41,6 @@ public class AdministrationAccessTests Assert.Contains("les usages restent consultables", model.StatusMessage); } - [AvaloniaTheory] - [InlineData("Moderator", false)] - [InlineData("Administrator", true)] - [InlineData("administrator", false)] - [InlineData("Performer", false)] - [InlineData("moderator", false)] - [InlineData("", false)] - public async Task Home_administration_visibility_and_command_follow_the_administrator_role(string role, bool allowed) - { - await using var api = new ProfileTransport(role); - var session = new SessionStatusViewModel { Api = api }; - var vm = new HomePageViewModel(api, api.Settings, session, null!); - var page = new HomePage { DataContext = vm }; - var window = new Window { Content = page }; - try - { - window.Show(); - var button = Assert.Single(page.GetVisualDescendants().OfType -[Trait("Category", "Platform-Android")] +[Trait("Platform", "Android")] +[Trait("Category", "non-reg")] public class AndroidAppLaunchTests { private const string PackageName = "fr.pschneider.postit"; diff --git a/src/PostIt/PostIt.Tests/BearerScopeTests.cs b/src/PostIt/PostIt.Tests/BearerScopeTests.cs index 984483fc7..4c90b0290 100644 --- a/src/PostIt/PostIt.Tests/BearerScopeTests.cs +++ b/src/PostIt/PostIt.Tests/BearerScopeTests.cs @@ -28,6 +28,7 @@ namespace PostIt.Tests; /// it reaches production. /// /// +[Trait("Category", "non-reg")] public class BearerScopeTests { /// diff --git a/src/PostIt/PostIt.Tests/BillingCommandPageViewModelTests.cs b/src/PostIt/PostIt.Tests/BillingCommandPageViewModelTests.cs index 34804b4cd..fc508283c 100644 --- a/src/PostIt/PostIt.Tests/BillingCommandPageViewModelTests.cs +++ b/src/PostIt/PostIt.Tests/BillingCommandPageViewModelTests.cs @@ -10,6 +10,7 @@ using Yavsc.Models.Haircut; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class BillingCommandPageViewModelTests { [Fact] diff --git a/src/PostIt/PostIt.Tests/BillingQueriesPageViewModelTests.cs b/src/PostIt/PostIt.Tests/BillingQueriesPageViewModelTests.cs index e53139351..57e841564 100644 --- a/src/PostIt/PostIt.Tests/BillingQueriesPageViewModelTests.cs +++ b/src/PostIt/PostIt.Tests/BillingQueriesPageViewModelTests.cs @@ -6,6 +6,7 @@ using Yavsc.Api.Client; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class BillingQueriesPageViewModelTests { [Fact] diff --git a/src/PostIt/PostIt.Tests/BlogAttachmentLinkTests.cs b/src/PostIt/PostIt.Tests/BlogAttachmentLinkTests.cs index c9d7d3aae..60ee78c91 100644 --- a/src/PostIt/PostIt.Tests/BlogAttachmentLinkTests.cs +++ b/src/PostIt/PostIt.Tests/BlogAttachmentLinkTests.cs @@ -18,6 +18,7 @@ namespace PostIt.Tests; /// (relative, authority-less) instead of /// https://{authority}/files/{user}/blogs/{id}/{name}. /// +[Trait("Category", "non-reg")] public class BlogAttachmentLinkTests { [Theory] diff --git a/src/PostIt/PostIt.Tests/BlogPostAuthorDtoTests.cs b/src/PostIt/PostIt.Tests/BlogPostAuthorDtoTests.cs index daabdf59b..205ab7bd4 100644 --- a/src/PostIt/PostIt.Tests/BlogPostAuthorDtoTests.cs +++ b/src/PostIt/PostIt.Tests/BlogPostAuthorDtoTests.cs @@ -28,6 +28,7 @@ namespace PostIt.Tests; /// it actually manifested in production. /// /// +[Trait("Category", "non-reg")] public class BlogPostAuthorDtoTests { private static readonly JsonSerializerOptions CaseInsensitiveJson diff --git a/src/PostIt/PostIt.Tests/BlogReaderTests.cs b/src/PostIt/PostIt.Tests/BlogReaderTests.cs index 0b26cf33e..c40e4c088 100644 --- a/src/PostIt/PostIt.Tests/BlogReaderTests.cs +++ b/src/PostIt/PostIt.Tests/BlogReaderTests.cs @@ -21,6 +21,7 @@ using SkiaSharp; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class BlogReaderTests { private static BlogPostDto Post(string article = "Texte du billet.") => new() @@ -139,57 +140,6 @@ public class BlogReaderTests } } - [AvaloniaFact] - public async Task Reader_initialization_and_empty_selection_do_not_report_binding_errors() - { - var vm = CreateViewModel(); - await vm.InitializeAsync(); - var post = Post(); - vm.Posts.Add(post); - vm.FilteredPosts.Add(post); - var previousSink = Logger.Sink; - var sink = new RecordingLogSink(); - Logger.Sink = sink; - Window? window = null; - try - { - var page = new BlogsPage(); - var reader = page.FindControl("ArticleReader")!; - var engine = Assert.IsAssignableFrom(reader.Engine); - Assert.NotNull(engine.HyperlinkCommand); - Assert.False(engine.HyperlinkCommand.CanExecute("https://example.test/")); - page.DataContext = vm; - var nav = new NavigationPage(); - await nav.PushAsync(page); - window = new Window { Width = 800, Height = 700, Content = nav }; - window.Show(); - Dispatcher.UIThread.RunJobs(); - Assert.Empty(vm.ReaderTitle); - Assert.Null(vm.ReaderDateModified); - Assert.Same(vm.OpenResourceCommand, engine.HyperlinkCommand); - Assert.IsType(reader.Plugins.PathResolver); - - vm.SelectedPost = post; - Dispatcher.UIThread.RunJobs(); - Assert.Equal(post.Title, vm.ReaderTitle); - Assert.Equal(post.DateModified, vm.ReaderDateModified); - - vm.SelectedPost = null; - page.DataContext = null; - Dispatcher.UIThread.RunJobs(); - Assert.Empty(vm.ReaderTitle); - Assert.Null(vm.ReaderDateModified); - Assert.NotNull(engine.HyperlinkCommand); - Assert.False(engine.HyperlinkCommand.CanExecute("https://example.test/")); - Assert.DoesNotContain(sink.Entries, entry => entry.Area == LogArea.Binding); - } - finally - { - window?.Close(); - Logger.Sink = previousSink; - } - } - [AvaloniaTheory] [InlineData(360, 800, false)] [InlineData(1000, 420, true)] diff --git a/src/PostIt/PostIt.Tests/BlogResourceServiceTests.cs b/src/PostIt/PostIt.Tests/BlogResourceServiceTests.cs index 0682dc6f2..1cb047aa6 100644 --- a/src/PostIt/PostIt.Tests/BlogResourceServiceTests.cs +++ b/src/PostIt/PostIt.Tests/BlogResourceServiceTests.cs @@ -4,6 +4,7 @@ using PostIt.Services; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class BlogResourceServiceTests { private const string Authority = "https://yavsc.pschneider.fr"; diff --git a/src/PostIt/PostIt.Tests/CallSignalingClientTests.cs b/src/PostIt/PostIt.Tests/CallSignalingClientTests.cs index c3f7945cb..48e9c4dad 100644 --- a/src/PostIt/PostIt.Tests/CallSignalingClientTests.cs +++ b/src/PostIt/PostIt.Tests/CallSignalingClientTests.cs @@ -5,6 +5,7 @@ using Yavsc.Abstract.Chat.Calls; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public sealed class CallSignalingClientTests { [Fact] diff --git a/src/PostIt/PostIt.Tests/CameraFrameClockTests.cs b/src/PostIt/PostIt.Tests/CameraFrameClockTests.cs index 9fbaac067..a5e64e3cd 100644 --- a/src/PostIt/PostIt.Tests/CameraFrameClockTests.cs +++ b/src/PostIt/PostIt.Tests/CameraFrameClockTests.cs @@ -2,6 +2,7 @@ using PostIt.Android.Services; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public sealed class CameraFrameClockTests { [Theory] diff --git a/src/PostIt/PostIt.Tests/CameraFrameOrientationTests.cs b/src/PostIt/PostIt.Tests/CameraFrameOrientationTests.cs index 369d3fd8e..6b9ab89ed 100644 --- a/src/PostIt/PostIt.Tests/CameraFrameOrientationTests.cs +++ b/src/PostIt/PostIt.Tests/CameraFrameOrientationTests.cs @@ -2,6 +2,7 @@ using PostIt.Android.Services; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public sealed class CameraFrameOrientationTests { [Theory] diff --git a/src/PostIt/PostIt.Tests/EstimateEditionPageViewModelTests.cs b/src/PostIt/PostIt.Tests/EstimateEditionPageViewModelTests.cs index 31c82387d..620e6a478 100644 --- a/src/PostIt/PostIt.Tests/EstimateEditionPageViewModelTests.cs +++ b/src/PostIt/PostIt.Tests/EstimateEditionPageViewModelTests.cs @@ -1,4 +1,3 @@ -using System.Net.Http; using PostIt.Models; using PostIt.ViewModels; using Yavsc; @@ -6,6 +5,7 @@ using Yavsc.Api.Client; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class EstimateEditionPageViewModelTests { private static BillingQuerySummaryDto SampleQuery() => new() diff --git a/src/PostIt/PostIt.Tests/EstimateListPageViewModelTests.cs b/src/PostIt/PostIt.Tests/EstimateListPageViewModelTests.cs index eefd59f20..c3838d270 100644 --- a/src/PostIt/PostIt.Tests/EstimateListPageViewModelTests.cs +++ b/src/PostIt/PostIt.Tests/EstimateListPageViewModelTests.cs @@ -4,6 +4,7 @@ using Yavsc.Api.Client; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class EstimateListPageViewModelTests { [Fact] diff --git a/src/PostIt/PostIt.Tests/EstimateValidationPageViewModelTests.cs b/src/PostIt/PostIt.Tests/EstimateValidationPageViewModelTests.cs index 02a6c64bd..ef23eefaa 100644 --- a/src/PostIt/PostIt.Tests/EstimateValidationPageViewModelTests.cs +++ b/src/PostIt/PostIt.Tests/EstimateValidationPageViewModelTests.cs @@ -1,6 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Net.Http; using PostIt.Controls; using PostIt.ViewModels; using Yavsc.Api.Client; @@ -19,6 +16,7 @@ namespace PostIt.Tests; /// TestApp makes GoBackAsync a no-op, so the success paths /// run to completion without navigation side effects. /// +[Trait("Category", "non-reg")] public class EstimateValidationPageViewModelTests { private static EstimateDto SampleEstimate(long? commandId = 42) => new() @@ -252,4 +250,4 @@ public class EstimateValidationPageViewModelTests public ValueTask DisposeAsync() => ValueTask.CompletedTask; } -} \ No newline at end of file +} diff --git a/src/PostIt/PostIt.Tests/AndroidCameraFrameRotationTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidCameraFrameRotationTestActivity.cs similarity index 100% rename from src/PostIt/PostIt.Tests/AndroidCameraFrameRotationTestActivity.cs rename to src/PostIt/PostIt.Tests/Fixtures/AndroidCameraFrameRotationTestActivity.cs diff --git a/src/PostIt/PostIt.Tests/AndroidChatServiceTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidChatServiceTestActivity.cs similarity index 100% rename from src/PostIt/PostIt.Tests/AndroidChatServiceTestActivity.cs rename to src/PostIt/PostIt.Tests/Fixtures/AndroidChatServiceTestActivity.cs diff --git a/src/PostIt/PostIt.Tests/AndroidLanCallTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidLanCallTestActivity.cs similarity index 100% rename from src/PostIt/PostIt.Tests/AndroidLanCallTestActivity.cs rename to src/PostIt/PostIt.Tests/Fixtures/AndroidLanCallTestActivity.cs diff --git a/src/PostIt/PostIt.Tests/AndroidMarkdownEditorTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidMarkdownEditorTestActivity.cs similarity index 100% rename from src/PostIt/PostIt.Tests/AndroidMarkdownEditorTestActivity.cs rename to src/PostIt/PostIt.Tests/Fixtures/AndroidMarkdownEditorTestActivity.cs diff --git a/src/PostIt/PostIt.Tests/AndroidPodcastBlurTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidPodcastBlurTestActivity.cs similarity index 100% rename from src/PostIt/PostIt.Tests/AndroidPodcastBlurTestActivity.cs rename to src/PostIt/PostIt.Tests/Fixtures/AndroidPodcastBlurTestActivity.cs diff --git a/src/PostIt/PostIt.Tests/AndroidPodcastCaptureTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidPodcastCaptureTestActivity.cs similarity index 100% rename from src/PostIt/PostIt.Tests/AndroidPodcastCaptureTestActivity.cs rename to src/PostIt/PostIt.Tests/Fixtures/AndroidPodcastCaptureTestActivity.cs diff --git a/src/PostIt/PostIt.Tests/AndroidScreenAwakeTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidScreenAwakeTestActivity.cs similarity index 100% rename from src/PostIt/PostIt.Tests/AndroidScreenAwakeTestActivity.cs rename to src/PostIt/PostIt.Tests/Fixtures/AndroidScreenAwakeTestActivity.cs diff --git a/src/PostIt/PostIt.Tests/Fixtures/AndroidWebRtcTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidWebRtcTestActivity.cs new file mode 100644 index 000000000..a12066d96 --- /dev/null +++ b/src/PostIt/PostIt.Tests/Fixtures/AndroidWebRtcTestActivity.cs @@ -0,0 +1,140 @@ +#if ANDROID +using System; +using System.IO; +using System.Linq; +using System.Net.Sockets; +using System.Runtime.Versioning; +using System.Text; +using System.Text.Json; +using System.Threading; +using System.Threading.Tasks; +using Android.App; +using Android.Content; +using Android.OS; +using Avalonia.Controls; +using Avalonia.Threading; +using PostIt.Android; +using PostIt.Android.Services; +using PostIt.Services; +using Yavsc.Abstract.Chat.Calls; +using Path = System.IO.Path; + +namespace PostIt.Tests; + +[Activity(Name = "fr.pschneider.postit.WebRtcTestActivity", Exported = true)] +[SupportedOSPlatform("android26.0")] +public sealed class AndroidWebRtcTestActivity : Activity +{ + protected override async void OnCreate(Bundle? state) + { + base.OnCreate(state); + var result = Path.Combine(FilesDir!.AbsolutePath, "webrtc-test-result.txt"); + File.WriteAllText(result, "RUNNING"); + try + { + using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(75)); + await RunAsync(Intent?.GetIntExtra("port", 0) ?? 0, timeout.Token); + File.WriteAllText(result, "PASS\nnative WebRTC media and cleanup complete"); + } + catch (Exception error) { File.WriteAllText(result, "FAIL\n" + error); } + finally { Finish(); } + } + + private async Task RunAsync(int port, CancellationToken ct) + { + if (port is < 1024 or > 65535) throw new ArgumentOutOfRangeException(nameof(port)); + StartActivity(new Intent(this, typeof(MainActivity)).AddFlags(ActivityFlags.NewTask)); + while (!MainActivity.IsForeground || (Avalonia.Application.Current as App)?.View is null) + await Task.Delay(100, ct); + using var socket = new TcpClient(); + await socket.ConnectAsync("127.0.0.1", port, ct); + using var stream = socket.GetStream(); + using var reader = new StreamReader(stream, Encoding.UTF8, false, 4096, leaveOpen: true); + using var writer = new StreamWriter(stream, new UTF8Encoding(false), 4096, leaveOpen: true) { AutoFlush = true }; + using var output = new SemaphoreSlim(1); + var callbackFailure = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + async Task EmitAsync(object value) + { + await output.WaitAsync(ct); + try { await writer.WriteLineAsync(JsonSerializer.Serialize(value, new JsonSerializerOptions(JsonSerializerDefaults.Web))); } + finally { output.Release(); } + } + void Emit(object value) => _ = EmitObservedAsync(value); + async Task EmitObservedAsync(object value) + { + try { await EmitAsync(value); } + catch (Exception error) { callbackFailure.TrySetException(error); } + } + var navigation = ((App)Avalonia.Application.Current!).View!.FindControl("NavRoot") + ?? throw new InvalidOperationException("Main navigation unavailable."); + AndroidWebRtcMedia? media = null; + var attached = false; + try + { + await Dispatcher.UIThread.InvokeAsync(async () => + { + media = new AndroidWebRtcMedia(); + var grid = new Grid { RowDefinitions = new RowDefinitions("*,*") }; + grid.Children.Add(media.LocalVideo); + Grid.SetRow(media.RemoteVideo, 1); + grid.Children.Add(media.RemoteVideo); + await navigation.PushAsync(new ContentPage { Content = grid }); + attached = true; + }); + var peer = media ?? throw new InvalidOperationException("Native UI unavailable."); + peer.Signal += signal => Emit(new { type = "signal", signal }); + peer.StatusChanged += status => + { + Emit(new { type = "status", status }); + if (status.LocalVideoRendered) Emit(new { type = "rendered", target = "local", size = 1_000 }); + if (status.RemoteVideoRendered) Emit(new { type = "rendered", target = "remote", size = 1_000 }); + }; + while (true) + { + var read = reader.ReadLineAsync(ct).AsTask(); + var completed = await Task.WhenAny(read, peer.Completion, callbackFailure.Task); + if (completed != read) + { + await completed; + throw new IOException("Native WebRTC stopped unexpectedly."); + } + var line = await read; + if (line is null) throw new IOException("Test signaling disconnected."); + using var document = JsonDocument.Parse(line); + var root = document.RootElement; + switch (root.GetProperty("command").GetString()) + { + case "start": + var configuration = root.GetProperty("configuration").Deserialize( + new JsonSerializerOptions(JsonSerializerDefaults.Web))!; + var camera = AndroidLanCallMedia.GetDevices().Cameras.FirstOrDefault(c => c.Name == "Camera avant") + ?? throw new InvalidOperationException("Front camera required."); + await Dispatcher.UIThread.InvokeAsync(() => peer.StartAsync( + configuration with { Camera = camera.Value, Microphone = "microphone" }, ct)); + break; + case "signal": + var signal = root.GetProperty("signal").Deserialize( + new JsonSerializerOptions(JsonSerializerDefaults.Web))!; + await peer.HandleSignalAsync(signal, ct); + break; + case "close": + await Dispatcher.UIThread.InvokeAsync(async () => await peer.DisposeAsync()); + await EmitAsync(new { type = "closed" }); + return; + default: throw new InvalidOperationException("Unknown test command."); + } + } + } + catch (Exception error) + { + await EmitAsync(new { type = "error", message = error.ToString() }); + throw; + } + finally + { + if (media is not null) await Dispatcher.UIThread.InvokeAsync(async () => await media.DisposeAsync()); + if (attached) await Dispatcher.UIThread.InvokeAsync(async () => await navigation.PopAsync()); + } + } +} +#endif diff --git a/src/PostIt/PostIt.Tests/BlogApiTestFakes.cs b/src/PostIt/PostIt.Tests/Fixtures/BlogApiTestFakes.cs similarity index 100% rename from src/PostIt/PostIt.Tests/BlogApiTestFakes.cs rename to src/PostIt/PostIt.Tests/Fixtures/BlogApiTestFakes.cs diff --git a/src/PostIt/PostIt.Tests/FakeAuthorizingBrowser.cs b/src/PostIt/PostIt.Tests/Fixtures/FakeAuthorizingBrowser.cs similarity index 100% rename from src/PostIt/PostIt.Tests/FakeAuthorizingBrowser.cs rename to src/PostIt/PostIt.Tests/Fixtures/FakeAuthorizingBrowser.cs diff --git a/src/PostIt/PostIt.Tests/OidcStubAuthority.cs b/src/PostIt/PostIt.Tests/Fixtures/OidcStubAuthority.cs similarity index 100% rename from src/PostIt/PostIt.Tests/OidcStubAuthority.cs rename to src/PostIt/PostIt.Tests/Fixtures/OidcStubAuthority.cs diff --git a/src/PostIt/PostIt.Tests/Fixtures/TestApp.cs b/src/PostIt/PostIt.Tests/Fixtures/TestApp.cs new file mode 100644 index 000000000..b23f2985b --- /dev/null +++ b/src/PostIt/PostIt.Tests/Fixtures/TestApp.cs @@ -0,0 +1,20 @@ +using Avalonia; +using Avalonia.Headless; + +[assembly: AvaloniaTestApplication(typeof(PostIt.Tests.TestAppBuilder))] + +namespace PostIt.Tests; + +public class TestAppBuilder +{ + public static AppBuilder BuildAvaloniaApp() + { + var nativeMedia = System.Environment.GetEnvironmentVariable("POSTIT_TEST_NATIVE_WEBRTC") == "1"; + var builder = AppBuilder.Configure(); + if (nativeMedia) builder.UseSkia(); + return builder.UseHeadless(new AvaloniaHeadlessPlatformOptions + { + UseHeadlessDrawing = !nativeMedia + }); + } +} \ No newline at end of file diff --git a/src/PostIt/PostIt.Tests/TestAppContext.cs b/src/PostIt/PostIt.Tests/Fixtures/TestAppContext.cs similarity index 100% rename from src/PostIt/PostIt.Tests/TestAppContext.cs rename to src/PostIt/PostIt.Tests/Fixtures/TestAppContext.cs diff --git a/src/PostIt/PostIt.Tests/FrontOfficeApiClientTests.cs b/src/PostIt/PostIt.Tests/FrontOfficeApiClientTests.cs index 02f6ae149..d262eff7b 100644 --- a/src/PostIt/PostIt.Tests/FrontOfficeApiClientTests.cs +++ b/src/PostIt/PostIt.Tests/FrontOfficeApiClientTests.cs @@ -1,4 +1,3 @@ -using System.Net.Http; using Yavsc.Api.Client; namespace PostIt.Tests; @@ -9,6 +8,7 @@ namespace PostIt.Tests; /// the PostIt signature payload, using a recording fake /// (no network). /// +[Trait("Category", "non-reg")] public class FrontOfficeApiClientTests { private static QueryAcceptanceRequestDto SampleBody() => new() @@ -154,4 +154,4 @@ public class FrontOfficeApiClientTests public ValueTask DisposeAsync() => ValueTask.CompletedTask; } -} \ No newline at end of file +} diff --git a/src/PostIt/PostIt.Tests/HomePageNotificationsTests.cs b/src/PostIt/PostIt.Tests/HomePageNotificationsTests.cs index 3656f0d83..b9ca27cab 100644 --- a/src/PostIt/PostIt.Tests/HomePageNotificationsTests.cs +++ b/src/PostIt/PostIt.Tests/HomePageNotificationsTests.cs @@ -1,15 +1,12 @@ -using System.Net.Http; -using Avalonia.Controls; using Avalonia.Headless.XUnit; -using Avalonia.VisualTree; using PostIt.Services; using PostIt.ViewModels; -using PostIt.Views; using Yavsc.Abstract.Models.Messaging; using Yavsc.Api.Client; namespace PostIt.Tests; +[Trait("Category", "non-reg")] public class HomePageNotificationsTests { [Fact] @@ -164,56 +161,6 @@ public class HomePageNotificationsTests Assert.Null(transport.LastMethod); } - [AvaloniaFact] - public async Task Home_page_loads_on_navigation_and_renders_wrapped_titles_and_bodies() - { - var transport = new NotificationTransport - { - Response = Task.FromResult(new List { Note(1, "Notification title") }) - }; - var vm = CreateViewModel(transport); - var page = new HomePage { DataContext = vm }; - var nav = new NavigationPage(); - var window = new Window { Content = nav, Width = 320, Height = 450 }; - try - { - window.Show(); - await nav.PushAsync(page); - window.UpdateLayout(); - - Assert.Single(vm.Notifications); - var texts = page.GetVisualDescendants().OfType().ToArray(); - Assert.Contains(texts, t => t.Text == "Notification title" - && t.TextWrapping == Avalonia.Media.TextWrapping.Wrap); - Assert.Contains(texts, t => t.Text == "Notification body" - && t.TextWrapping == Avalonia.Media.TextWrapping.Wrap); - var refresh = Assert.Single(page.GetVisualDescendants().OfType + + + + + + + + + + + + + + + + + + + + + + + + + + + + +