diff --git a/.forgejo/workflows/buildAndTest.yml b/.forgejo/workflows/buildAndTest.yml
index e85a9b167..86ee986ab 100644
--- a/.forgejo/workflows/buildAndTest.yml
+++ b/.forgejo/workflows/buildAndTest.yml
@@ -26,8 +26,23 @@ on:
jobs:
build:
runs-on: docker
+ services:
+ postgres:
+ image: postgres:16
+ env:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: postgres
+ POSTGRES_DB: postgres
+ PGPORT: "55432"
+ ports:
+ - "55432:55432"
+ options: >-
+ --health-cmd="pg_isready -h 127.0.0.1 -p 55432 -U postgres -d postgres"
+ --health-interval=10s
+ --health-timeout=5s
+ --health-retries=10
container:
- image: pazof/yavsc-build-env:debian13-dotnet10-android36-jdk21-v4
+ image: pazof/yavsc-build-env:debian13-dotnet10-android36-jdk21-v5
steps:
- name: Clone yavsc
run: |
@@ -44,12 +59,29 @@ jobs:
- name: Secret scan
run: |
echo "🔍 Scanning for secrets..."
- cd /src/_src && dotnet tool restore && dotnet picket git --verbose --redact --exit-code 1 --log-opts main..HEAD \
+ cd /src/_src && dotnet tool restore || true
+ dotnet picket git --verbose --redact --exit-code 1 --log-opts main..HEAD
- name: Build
run: |
echo "🏗️ Building the solution..."
cd /src/_src && dotnet build --verbosity normal
+ - name: Wait for PostgreSQL
+ run: |
+ echo "⏳ Waiting for PostgreSQL on 127.0.0.1:55432..."
+ for i in $(seq 1 30); do
+ if pg_isready -h 127.0.0.1 -p 55432 -U postgres >/dev/null 2>&1; then
+ echo "âś… PostgreSQL is accepting connections"
+ exit 0
+ fi
+ echo "PostgreSQL not ready yet ($i/30)"
+ sleep 2
+ done
+ echo "❌ PostgreSQL did not become ready in time" >&2
+ exit 1
- name: Test
+ env:
+ YAVSC_API_TEST_DB_PROVIDER: npgsql
+ 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 \
diff --git a/.gitattributes b/.gitattributes
index bdb0cabc8..560496f30 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,5 +1,6 @@
# Auto detect text files and perform LF normalization
* text=auto
+*.onnx binary
# Custom for Visual Studio
*.cs diff=csharp
diff --git a/.github/workflows/docker-publish-backend.yml b/.github/workflows/docker-publish-backend.yml
index 2d84b767f..7c8a8d8b3 100644
--- a/.github/workflows/docker-publish-backend.yml
+++ b/.github/workflows/docker-publish-backend.yml
@@ -9,6 +9,20 @@ on:
jobs:
production-deploy:
runs-on: ubuntu-26.04
+ services:
+ postgres:
+ image: postgres:16
+ env:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: postgres
+ POSTGRES_DB: postgres
+ ports:
+ - 5432:5432
+ options: >-
+ --health-cmd="pg_isready -U postgres -d postgres"
+ --health-interval=10s
+ --health-timeout=5s
+ --health-retries=5
steps:
# 1. Récupération du code
- name: Check out the repo
@@ -33,6 +47,8 @@ jobs:
- name: Test
env:
TEST_FAILED: ""
+ YAVSC_API_TEST_DB_PROVIDER: npgsql
+ YAVSC_API_TEST_NPGSQL_ADMIN_CONNECTION: Host=localhost;Port=5432;Database=postgres;Username=postgres;Password=postgres;Include Error Detail=true
run: make test || export TEST_FAILED=$?
- uses: actions/upload-artifact@v7
with:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 87cf40dbb..1c2776c6f 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -17,8 +17,7 @@
"program": "${workspaceFolder}/src/PostIt/PostIt.Desktop/bin/Debug/net10.0/PostIt.Desktop.dll",
"env": {
"POSTIT_SETTINGS_JSON": "/home/paul/Workspace/yavsc/src/PostIt/PostIt/postit-settings.json"
- },
- "preLaunchTask": "dotnet: build-postit-desktop"
+ }
},
{
"name": "Android Debug",
@@ -57,7 +56,6 @@
"request": "launch",
"projectPath": "${workspaceFolder}/src/Yavsc.Blogs/Yavsc.Blogs.csproj"
},
-
{
"name": "Test PostIt.Android launch (Xamarin.UITest)",
"type": "coreclr",
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 0b0bb63a5..3721b437f 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -1,7 +1,6 @@
{
"version": "2.0.0",
"isRoot": true,
-
"tasks": [
{
"label": "build-debug-android",
@@ -124,11 +123,11 @@
{
"label": "dotnet: build-postit-desktop",
"type": "process",
+ "problemMatcher": "$msCompile",
"isBuildCommand": true,
"isTestCommand": false,
"isBackground": true,
"command": "dotnet",
- "problemMatcher": ["$msCompile"],
"args": ["build", "/property:GenerateFullPaths=true"],
"options": {
"cwd": "src/PostIt/PostIt.Desktop"
@@ -136,6 +135,22 @@
"group": {
"kind": "build"
}
+ },
+ {
+ "label": "build-postit-browser",
+ "type": "process",
+ "problemMatcher": ["$msCompile"],
+ "isBuildCommand": true,
+ "isTestCommand": false,
+ "isBackground": true,
+ "command": "dotnet",
+ "args": ["build", "/property:GenerateFullPaths=true"],
+ "options": {
+ "cwd": "src/PostIt/PostIt.Browser"
+ },
+ "group": {
+ "kind": "build"
+ },
}
]
}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 224008f7e..7df6ba171 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,62 @@
# Changelog
+## [1.0.8-rc35] - unstable
+
+### Added
+
+* [Resource usage] Let users with the `Administrator` role continue making requests after reaching their consumption quota, while still recording their usage.
+
+* [PostIt.Android/Podcasts] Add an optional persisted background blur for camera preview and broadcasting. Run the bundled PPHumanSeg model locally with ONNX Runtime and composite with OpenGL before encoding; preserve the unfiltered pipeline for calls and OBS.
+
+* [Podcasts/OBS/PostIt] Replace the MediaMTX relay with direct encrypted SRT ingestion managed by [FFmpeg.NET](https://github.com/cmxl/FFmpeg.NET). Reserve bounded UDP listeners on activation, display a secret SRT URL with an empty OBS stream-key field, start on received media, preserve revocation/expiry/quotas and authenticated replay, and invalidate in-memory activations after restart. Remove relay configuration and its authentication endpoint; update deployment, privacy and real-media regressions. Use separate request connections to the shared SQLite test database for reliable concurrent podcast requests.
+
+* [Podcasts/OBS/PostIt] Add opt-in MediaMTX RTMPS ingestion for programmed emissions, activated explicitly from PostIt with one-time scoped, expiring and revocable keys. Start on publisher connection, remux H.264/AAC into the existing authenticated segments and MP4 replay workflow, bound concurrency/duration/buffering, enforce consumption and effective disk quotas, account storage with deletion refunds, and report owner-only ingest errors. Add relay configuration, installation instructions and real synthetic RTMP/RTMPS-to-replay regressions, including active revocation.
+
+* [Yavsc/PostIt/Privacy] Close and pseudonymize withdrawn accounts, cancel PayPal subscriptions before confirming withdrawal, erase managed personal files, avatars and podcasts, and reject old sessions across hosts. Purge eligible technical payment residues one year after effective withdrawal automatically and through a confirmed administrator-only PostIt action; preserve accounting records separately. Clarify the privacy policy, recipients, third-party integrations, withdrawal failures and deployment responsibilities. Make the unique email constraint mutable to support pseudonymization without deleting accounting identities.
+
+* [Yavsc/API/Blogs/PostIt] Refund tracked storage points when personal files are deleted or replaced, and when generated PDFs are replaced. Persist per-file accounting receipts, preserve them on rename, reject refunds for untracked legacy files, and allow deletion at the consumption limit without refunding API/CPU/transfer costs. Update CGU and installation instructions.
+
+* [Yavsc/PostIt/PayPal] Add monthly Découverte (EUR 1 excluding VAT) and Premium (EUR 2 excluding VAT) resource subscriptions, charged at EUR 1.20 / EUR 2.40 including 20% VAT. Confirmed monthly PayPal payments erase up to one / three default quotas, carry two thirds of unused monthly credit without expiry, and preserve historical counters. Add persistent idempotent payment credits, refund reconciliation, authenticated Web subscription/cancellation pages, verified REST webhooks, PostIt links and balances, migration and updated CGU.
+* [Yavsc/PostIt/Subscriptions] Align new users' free quota with the existing 500 MiB database default; grant twice that standard quota for Discovery (1,000 MiB) and five times for Premium (2,500 MiB) during confirmed paid monthly periods, including their remainder after cancellation. Restore the user's base quota after expiry or refund without deleting files, refuse uploads beyond available space before writing, and expose the effective quota in profile and usage responses.
+* [PostIt/API/Blogs/Yavsc.Org] Compute cumulative resource consumption in configurable points per API call, recorded CPU second, MiB transferred and MiB added to storage, with backend-defined defaults, a default 1,000-point limit and per-user overrides. Serialize accounting and known-cost admission across PostgreSQL hosts, count streamed HTTP bodies, reject further consuming operations with HTTP 429, and check personal uploads before writing. Keep usage/session access available, display the indicator and balance in PostIt, and publish linked CGU explaining the rule and after-measurement enforcement.
+* [PostIt.Android] Embed managed assemblies in APKs by default, including Debug builds launched outside the Makefile, to prevent the native startup abort "No assemblies found" when fast-deployment files are absent.
+* [PostIt] Remove the redundant "Post detail" heading and its grid row from the blog editor, including the compact layout.
+* [PostIt/Android] Combine system-bar/cutout safe-area insets with actual keyboard overlap at the root, instead of replacing Avalonia's automatic safe-area padding with keyboard-only padding. Preserve the toolbar, session banner, attachments and status controls; place article details beside the editor during landscape keyboard input. Only on Android, temporarily hide the title input while editing in compact mode with the keyboard open, restoring it on keyboard closure or focus change without modifying the draft. Verify visible controls outside native system bars, at least three editor lines and the editor's bottom above IME insets.
+* [PostIt/Android] Remove the outer blog-page scroll container so the editor, reader and list retain bounded viewports. Keep the editing caret visible after the keyboard resizes the editor; request the native keyboard on a touch tap, not a scroll gesture, without cycling focus or replacing the selection. Add headless regressions and a debug-only device check using a local synthetic article.
+* [PostIt.Android] Fix the crash when starting a podcast broadcast with camera preview active: detach preview callbacks using the retained surface holder, before deferred native-view destruction, without accessing an already disposed SurfaceView. Add a device regression covering preview teardown followed by local capture.
+* [PostIt.Android] Keep the screen awake during foreground video playback and release it on pause, stop, completion, error or video teardown. Add a persisted, default-off podcast option to keep the screen awake during camera preview/live capture; release on capture end and allow normal sleep in the background without changing the broadcast service. Include native LibVLC libraries when building with a single runtime identifier (including physical ARM64 phones).
+* [PostIt/Podcasts] Preview the selected camera before starting a live broadcast, without creating an emission, encoding files or opening the microphone. Release preview on stop, navigation, logout and Android backgrounding, and before starting the actual broadcast. Correct Android portrait orientation for rear and front cameras: subtract the sensor rotation already carried by Camera2's SurfaceTexture matrix, reversing the remaining rotation when that matrix mirrors the front camera (it was turned 90° or upside down); track display changes for both preview and encoded frames, preserving aspect ratio and fixed live stream dimensions.
+* [PostIt] Schedule silent OIDC renewal independently of API traffic and SignalR reconnects, while the app is active or background chat is enabled. Derive the wait from the access-token expiration minus the existing 60-second safety margin instead of polling; recalculate after token rotation, login/logout, activity and preference changes. Persist rotated tokens and serialize with request-driven renewal/logout. Run the same maintenance in headless Android chat; background execution and absolute refresh-token lifetime remain subject to Android/identity-provider limits.
+* [PostIt.Android] Request Android's battery optimization exemption when explicitly saving settings with background chat enabled, only if not already exempt. Keep automatic settings saves and reconnects free of prompts; refusal does not disable SignalR.
+* [PostIt.Android] Add an opt-in ordinary background service for the existing SignalR ChatHub connection, without a permanent notification; show native alerts only for received messages/events and attempt restart after phone startup where Android permits it. Reuse one process-wide connection between service, pages and calls, restore locally remembered rooms per account/host and clean up on opt-out/logout. No Firebase, Google push configuration or server push migration; explain background-data/battery settings and Android execution limits.
+* [PostIt/Calls] Support direct IPv6 SRTP calls using global, ULA and loopback addresses, shared endpoint validation, IPv6 UDP sockets and bracketed reception URLs. Exclude scoped/link-local, multicast, unspecified and IPv4-mapped addresses; verify real bidirectional IPv6 audio/video, wrong-key rejection and port lifecycle with LibVLC.
+* [PostIt/Calls] Allow directly assigned public IPv4 addresses for direct SRTP calls, alongside LAN/VPN and loopback addresses. Share unicast validation between interface discovery, media and server signaling; continue rejecting unspecified, link-local, multicast, reserved and IPv6 addresses. Keep explicit address-disclosure consent and no automatic NAT traversal.
+* [PostIt] Update bundled settings with the default podcast title, camera/microphone preferences and French language selection.
+* [Performers] Allow performer profiles without a business registration for amateur use; keep activities available while disabling estimate issuance and new invoicing in the UI and server APIs.
+
+## [1.0.8-rc34] - unstable
+
+### Added
+
+* [PostIt] Share podcast camera/microphone preferences with chat-room calls and persist the selected LAN/VPN address. Restore only currently available network addresses without remembering address-disclosure consent; require an explicit microphone choice for calls when podcasts use no microphone.
+* [PostIt] Remember detected podcast cameras/microphones, selected devices (including no microphone) and the default title in user settings; restore them when reopening the page and report persistence failures.
+* [Podcasts] Reuse persisted LiveFlow entities to prepare, edit and delete emissions from PostIt with a title, scheduled start and estimated duration. Keep start/stop manual and plans private; optionally publish presentation-only announcements on Yavsc.Org without opening anonymous playback. Preserve broadcast identifiers, legacy recordings and authenticated HLS/MP4 access; add a scheduling migration and lifecycle/privacy regressions.
+* [PostIt/API/Yavsc.Org] Expose the private PayPal recipient setting in PostIt's performer editor and authenticated profile API; validate addresses, allow disabling with an empty value and preserve the setting for older clients. Make Web donation settings discoverable from the performer profile and podcast catalogue.
+* [API] Initialize the required address field when creating a performer profile so a first configuration can be saved.
+* [Yavsc.Org] Add an authenticated Razor podcast catalogue with same-origin API-backed HLS/MP4 playback and replay byte-range support. Reuse Site.ApiUrl and the authority's signing credentials to issue short-lived user tokens, without a separate OAuth client or PodcastWeb configuration. Distinguish an empty catalogue from API/configuration failures.
+* [Yavsc.Org] Integrate direct PayPal donations to performers: self-service recipient settings, Yavsc donation pages/history, server-verified checkout and capture, antiforgery/concurrency protection, and validated IPN reconciliation. Reuse the existing merchant settings and persist donation receipts in a dedicated migration; keep uncertain and pending payments distinct from completed donations.
+* [PostIt] Open the Yavsc.Org podcast catalogue in the browser instead of the authenticated API playlist; preserve embedded playback and external blog-video links.
+* [PostIt.Android/Desktop] Extend LAN/VPN SRTP calls to Android 8+ using the existing front-camera/microphone Podcast capture, rotated native preview and embedded LibVLC remote video, without libwebrtc or new dependencies. Pass the live MediaRecorder pipe directly to the shared SRTP engine without HLS files or transcoding; add a call-specific foreground notification, stop on backgrounding, and allow incoming callers to configure devices before acceptance. Use separate RTP/RTCP UDP ports to avoid a diagnosed Android VLC `rtcp-mux` SDP-generation crash. Add debug-only physical camera/SRTP checks and shared control/pipe-input regressions; Internet/TURN/group calls remain outside this transport.
+
+* [PostIt.Desktop/API] Add opt-in Linux LAN/VPN peer calls through the existing ChatHub, reusing Podcast LibVLC camera/microphone capture and H.264/AAC encoding with direct SRTP instead of HLS. Add consent, embedded local/remote video, hangup/interruption cleanup, private IPv4 validation and per-direction ephemeral keys over HTTPS-only signaling. Reject IP-masking accounts rather than silently bypassing TURN; keep this transport disabled by default and separate from the future Internet/group-call design. Test real bidirectional encrypted audio/video, wrong-key rejection, preview output, signaling and UI lifecycle; physical camera/two-machine rendering remains to validate.
+* [PostIt/API] Begin Android/Linux call integration on the existing authenticated ChatHub: typed invitation, single-device consent, bounded SDP/ICE exchange and hangup; derive relay policy from account preferences and issue temporary coturn credentials. Attach the shared PostIt signaling client to the chat connection, end calls on disconnect/room departure/privacy activation, and add targeted regression tests. Calls remain disabled by default; native media adapters and Android/Linux end-to-end validation are not implemented yet.
+* [PostIt] Clarify reuse of the existing ChatHub for call signaling and document the inconclusive Android native WebRTC experiment; discard the isolated laboratory without changing production chat or media behavior.
+* [PostIt/API] Persist the account-level `HideIpAddressInCalls` preference (default false), expose it through the authenticated profile API and PostIt profile editor, and preserve it when older clients omit it. Prepare future TURN-only calls without enabling media transport yet.
+* [PostIt] Show a local live capture preview on Android and Desktop without opening a second camera or reading back uploaded segments. Share Android's oriented EGL frames with an aspect-preserving preview surface; duplicate Desktop LibVLC output without local microphone playback.
+* [Podcasts] Prepare authenticated, seekable MP4 replays for new and existing Completed broadcasts using server-side FFmpeg stream copy and faststart. Retain MPEG-TS, account for both copies in the owner quota, recover preparation after restarts, and expose owner-only retries plus GET/HEAD byte-range playback.
+* [PostIt] Add Android/Desktop native video overlays for MP4 replay position, duration, seeking and play/pause, with three-second auto-hide. Use bounded authenticated range input with token refresh; preserve MPEG-TS live/interrupted playback.
+
## [1.0.8-rc33] - unstable
### Added
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 12028b161..8e1341f23 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -5,6 +5,7 @@
+
diff --git a/Dockerfile b/Dockerfile
index 8ebbb73f0..9d6687b2c 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -93,6 +93,7 @@ HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \
ENTRYPOINT ["dotnet", "Yavsc.Org.dll"]
FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS api-runtime
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg && apt-get clean
WORKDIR /app
COPY --from=publish-api /publish/ ./
RUN --mount=type=secret,id=yavsc_appsettings,dst=/run/secrets/yavsc_appsettings \
diff --git a/INSTALL.md b/INSTALL.md
index 5cea2b6f0..696f3924f 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -76,13 +76,333 @@ login callback, updating and uninstallation on Windows with a standard
(non-administrator) account. Installer compilation alone does not validate
these Windows runtime behaviours.
+## Resource consumption and CGU
+
+### Account withdrawal and payment retention
+
+Apply the `AccountWithdrawal` migration before deploying all three hosts. It adds
+withdrawal timestamps and replaces the immutable alternate email key with a
+required unique email index, preserving uniqueness while allowing pseudonymization.
+Do not run the withdrawal flow until every host uses the matching backend.
+
+Yavsc.Org must have write/delete access to the same managed volumes as API/Blogs:
+`Site:UserFilesRoot`, `Site:Avatars` and `Podcast:RootPath`.
+Use absolute paths shared across processes; defaults relative to application
+directories are not shared automatically. Accounting files under `Site:Bills`
+are not erased by withdrawal. Symbolic links in managed user directories are
+refused rather than followed.
+
+The account is blocked before cancellation/erasure, and withdrawal is only
+confirmed when these operations and pseudonymization succeed. On an explicit
+failure, an administrator must fix the cause and retry the existing administrative
+withdrawal action. Ensure no live upload/encoding operation is still writing to
+the user's volumes during withdrawal; drain such operations before retrying.
+
+The Org hosted worker purges eligible technical payment records at startup and
+checks at most every minute, with an earlier wake-up for a known anniversary.
+Monitor errors and service availability: scheduled processing
+cannot ensure an exact wall-clock deletion while the host is stopped. At least
+one Org instance must run, and an external operations process must enforce the
+one-year retention deadline during prolonged downtime. PostIt administrators can
+also confirm and run `POST /api/v1/administration/payment-residues/purge`.
+The report counts accounts, subscriptions, monthly payments, donations and legacy
+PayPal payments. Active accounts and unfinished withdrawals are never purged.
+No new subscription credits may be granted after withdrawal begins.
+
+Invoice payments, invoices and other legal accounting records are excluded.
+Define and publish the actual accounting, logs and backup retention policy for
+the deployment, verify configured providers and international-transfer safeguards,
+and prevent withdrawn data from being reactivated by backup restoration.
+
+Configure the **same** `ResourceUsage` section on Yavsc.Api, Yavsc.Blogs and
+Yavsc.Org. API and Blogs must also use the same application database.
+All three hosts and configuration templates inherit the backend defaults
+from [ResourceUsageOptions](src/Yavsc.Server/Settings/ResourceUsageOptions.cs).
+Deploy matching backend versions across hosts. The public CGU renders the
+effective coefficients and limit. The default limit is 1,000 points.
+The following is an example explicit override, not a duplicate of defaults.
+Use the account's immutable user ID (`sub`), not its login, for overrides:
+
+```json
+{
+ "ResourceUsage": {
+ "ApiCallWeight": 0.2,
+ "CpuSecondWeight": 0.1,
+ "BandwidthMbWeight": 0.05,
+ "StorageMbWeight": 0.5,
+ "DefaultLimit": 1000,
+ "UserLimits": {
+ "example-account-id": 20000
+ }
+ }
+}
+```
+
+Environment variables follow ASP.NET's convention, for example
+`ResourceUsage__DefaultLimit` and
+`ResourceUsage__UserLimits__example-account-id`. Restart all three services
+after changing the rule. Invalid weights or limits fail startup.
+Existing cumulative `ResourceUsageRecords` are reused, and changing weights
+recalculates their gross indicator. Apply the `ResourceSubscriptions`
+migration before deploying any of the three hosts: it adds the credit
+balance and subscription/payment tables without clearing existing counters.
+
+Consumption is in **points**, independent of `EstimatedCompensation` and
+currency. Counters have no automatic reset. Storage means cumulative
+instrumented writes less individually tracked bytes removed or replaced,
+not total filesystem occupancy. Replacements refund their tracked previous
+size and charge the new size. Legacy files without an individual receipt
+receive no refund; storage counters never become negative. Deletion remains
+available at the consumption limit, but API/transfer/CPU costs are not refunded.
+Apply the `RefundableResourceStorage` migration before deployment; its empty
+receipt table deliberately does not infer provenance from historical counters.
+Renames preserve receipts and repeated PDF generation replaces the previous
+tracked volume rather than charging the whole file again. The historical CPU counter is
+instrumented elapsed processing time, not exhaustive CPU profiling.
+
+Authenticated HTTP operations are admitted atomically against known costs
+(API call and declared request body). Personal-file uploads additionally
+check their aggregate storage cost before writing. Response bytes and
+unknown-length request bodies are measured through counting streams, and
+remaining costs are recorded after execution, including failed requests.
+PostgreSQL transaction-scoped advisory locks serialize admission and
+accounting for each user across hosts. In-flight operations can exceed the
+limit through costs unknown at admission; subsequent operations return
+HTTP 429 with `resource_quota_exceeded` Problem Details. No permanent account
+suspension or strict running-operation interruption is performed.
+
+`GET /api/v1/resource-usage/me` returns `Consumption`, `ConsumptionLimit`,
+`RemainingConsumption` and `IsQuotaReached`, alongside existing counters.
+It also returns `GrossConsumption`, `AppliedCredits` and `CreditBalance`.
+`Consumption` is the gross indicator less acquired credits, floored at zero.
+`RemainingConsumption` includes both unused free quota and carried credit.
+Usage consultation (including the role-protected admin overview), login,
+session refresh and the CGU remain accessible without consuming quota.
+The quota does not measure local PostIt resources, direct peer calls or
+WebSocket traffic. HTTP upload size limits and disk quotas still apply.
+
+The public page `/Home/CGU` describes the effective rule and default limit
+(and the individual limit for a signed-in user). It is linked from the Web
+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.
+
+### Monthly resource subscriptions (PayPal REST)
+
+The free registration keeps the configured cumulative quota without a
+monthly reset. Discovery costs EUR 1 excluding VAT (EUR 1.20 including 20%
+VAT) per month; Premium costs EUR 2 excluding VAT (EUR 2.40 including VAT).
+Every **confirmed payment** grants up to one / three default quotas,
+respectively, with renewal on the UTC monthly anniversary of the PayPal
+start date. The pack allowance is captured at subscription creation, not
+multiplied by an individual user's quota override.
+
+At reconciliation, old carried credit is used first; the new allowance
+erases remaining net usage. Two thirds of the unused allowance are added
+to permanent carried credit, rounded down to eight decimal places.
+Old carried credit never loses another third and survives cancellation.
+Example: 400 points of usage and 1,000 new points erase 400 and carry
+400; an idle Premium month carries 2,000 points.
+Counters are never deleted. Pending/failed payments give no credit.
+Refunds (including partial refunds) revoke the corresponding award once.
+
+Discovery grants **twice `Constants.DefaultFSQ`** (1,000 MiB), and Premium
+**five times `Constants.DefaultFSQ`** (2,500 MiB) of disk space during each
+confirmed, non-reversed paid monthly period. Free registrations use the standard quota.
+The reference is the standard free quota (500 MiB), not an individual's
+administratively adjusted `DiskQuota`. That base quota is never overwritten.
+New user objects now use the existing 500 MiB database default rather than
+the former 512 MiB CLR initializer; existing accounts retain their stored quota.
+Cancellation retains the disk allowance through the UTC anniversary ending
+the paid period; expiry or refund restores the base quota without deleting
+existing files. Uploads exceeding available space are refused before writing.
+The maximum size of one file and separate podcast limits are unchanged.
+Pending/failed payments grant no disk bonus. Apply the
+`ResourceSubscriptions`, `PremiumDiskQuota` and `DiscoveryDiskQuota` EF migrations to the shared
+database before deploying any host. Profile and usage responses expose the
+effective disk quota; usage also exposes `PremiumDiskQuotaUntil` and `DiscoveryDiskQuotaUntil`.
+When paid periods overlap, Premium takes precedence until its expiry, then
+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.
+Use the existing `PayPal:Mode`, `PayPal:ClientId` and `PayPal:ClientSecret`
+REST settings; keep credentials in user-secrets or environment variables.
+
+```json
+{
+ "ResourceSubscriptions": {
+ "DiscoveryPlanId": "P-REPLACEWITHDISCOVERYPLAN",
+ "PremiumPlanId": "P-REPLACEWITHPREMIUMPLAN",
+ "WebhookId": "REPLACEWITHWEBHOOKID",
+ "DiscoveryPriceExcludingTax": 1,
+ "PremiumPriceExcludingTax": 2,
+ "VatPercent": 20
+ }
+}
+```
+
+Before enabling checkout, create a PayPal subscription product and two
+**ACTIVE** billing plans in the same REST app and environment:
+one indefinite `REGULAR` cycle with `interval_unit: MONTH`,
+`interval_count: 1`, `total_cycles: 0`, and EUR `fixed_price.value`
+of **1.20** / **2.40** respectively. These are **already VAT-inclusive**
+amounts: do not add PayPal tax, setup fees, trials, quantity support or
+shipping fees. Disable billing outstanding balances in the plans
+(`auto_bill_outstanding: false`) to avoid bundling missed installments
+into an amount that does not match one monthly payment.
+Checkout checks the configured plan against its expected TTC amount and
+refuses automatic collection of outstanding balances.
+Numerically invalid pricing fails startup; missing plan IDs/webhook/
+credentials returns an explicit unavailable error instead of a fake success.
+
+Register the HTTPS endpoint
+`https:///ResourceSubscription/Notify` in that REST app.
+Subscribe to `BILLING.SUBSCRIPTION.ACTIVATED`, `UPDATED`, `CANCELLED`,
+`SUSPENDED`, `EXPIRED`, `PAYMENT.FAILED`, and `PAYMENT.SALE.COMPLETED`,
+`REFUNDED`, `REVERSED` (the lifecycle events use the
+`BILLING.SUBSCRIPTION.` prefix). Set the returned webhook ID in configuration.
+The server verifies the signature through PayPal, then fetches the bound
+subscription and transaction history; it never grants credit from an
+unverified webhook or the browser return. Payment IDs and monthly cycles
+are unique, and the same per-user PostgreSQL lock serializes usage and awards.
+Delayed notifications take effect on the usage measured when reconciled.
+
+Users manage subscriptions at `/ResourceSubscription`, linked from the Web
+footer and PostIt's About/profile pages. A browser Web login may be required
+independently of PostIt's session. Create/refresh/cancel require antiforgery
+tokens and ownership; the management page remains available at the quota.
+**Refresh payments** reconciles missed notifications and historical refunds.
+Cancellation is confirmed with PayPal, not merely recorded locally.
+Only one non-terminal subscription is allowed per account.
+An uncertain creation is retried with its same PayPal request ID for at
+most 24 hours; an older unresolved creation requires merchant-side review
+before allowing a second checkout. Do not delete that record and retry
+without checking PayPal for a possible existing agreement.
+
+Run a real Sandbox approval, first payment, renewal, repeated webhook,
+refund and cancellation before enabling production. The repository tests
+use synthetic PayPal transports and do not validate merchant credentials
+or PayPal account eligibility.
+
## Podcast live broadcasts and replays
+### OBS Studio for planned emissions
+
+OBS publishes **encrypted SRT directly to Yavsc.Api**, using
+[FFmpeg.NET](https://github.com/cmxl/FFmpeg.NET) (`xFFmpeg.NET`) to manage FFmpeg
+listeners. No MediaMTX, external media server, authentication callback or RTMPS
+certificate is required. Install **FFmpeg with libsrt, H.264/AAC and MPEG-TS
+support** on the **single Yavsc.Api media host** (`ffmpeg -h protocol=srt`).
+OBS supports SRT in its Custom streaming service; see its
+[SRT streaming guide](https://obsproject.com/kb/srt-protocol-streaming-guide).
+This replaces the previous RTMP/RTMPS transport, not the authenticated playback API.
+
+Apply the `PodcastObsIngestion` migration on the shared database. Configure
+`Podcast:Obs` on **Yavsc.Api only**, for example:
+
+```json
+{
+ "Podcast": {
+ "Obs": {
+ "Enabled": true,
+ "ServerUrl": "srt://obs.example.org",
+ "ListenAddress": "0.0.0.0",
+ "FirstPort": 10000,
+ "PortCount": 16,
+ "ActivationMinutes": 30,
+ "MaxDurationMinutes": 120,
+ "MaxConcurrentBroadcasts": 2
+ }
+ }
+}
+```
+
+`ServerUrl` contains the public SRT host only, with no port, path, secret or query.
+`ListenAddress` is a literal local IP address (IPv4 or IPv6); configure a matching
+public address family. Open/forward **UDP 10000-10015** in this example.
+An ordinary HTTP reverse proxy does not carry SRT. NAT forwarding must preserve
+the advertised port numbers.
+One FFmpeg process and UDP port are reserved per armed emission, even before OBS
+connects. Armed and running emissions share `MaxConcurrentBroadcasts`; an exhausted
+pool returns HTTP 503. The port range is bounded (at most 128 ports) and must be
+large enough for the concurrency limit. Listener startup failure is reported,
+not treated as successful activation.
+Keep process arguments and credentials accessible only to the service administrator.
+Limit ingress bitrate at the network level and in OBS: application quotas are checked
+on completed media segments, not on every incoming packet.
+
+In PostIt:
+
+1. Prepare an emission and select it.
+2. Choose **Activer OBS / renouveler la cle**.
+3. In OBS, select **Parametres > Stream > Service : Personnalise**, then copy
+ the complete displayed **secret SRT URL as Server**, leaving **Stream Key empty**.
+ The URL includes caller mode, a random passphrase and enforced AES-256 encryption.
+ Use **H.264 video**, **AAC audio**,
+ a **2-second keyframe interval** and a bitrate producing segments below 8 MiB.
+4. Start streaming in OBS before the activation expires. The actual emission
+ starts when the first complete media segment arrives, even if the scheduled date is later.
+ No camera capture in PostIt is required; PostIt may be closed afterwards.
+5. Stop OBS or choose **Revoquer OBS et arreter le diffuseur** in PostIt.
+ Committed segments remain available and the normal MP4 worker prepares replay.
+
+Passphrases are scoped to one emission, displayed once and rotated on activation.
+Only a SHA-256 hash and lifecycle metadata are stored in the database; FFmpeg needs
+the actual passphrase in memory/process arguments for SRT encryption. It is never
+included in status responses or persisted in PostIt. Navigation/logout clears
+the displayed secret URL but does not revoke a running
+external emission. Revocation is available at the consumption limit.
+After disconnect, restart or timeout, the emission ends rather than silently
+resuming under a new publisher: prepare a new emission for another broadcast.
+An API restart invalidates all old activations; an unstarted emission must be
+activated again because its passphrase is not recoverable from the database.
+An invalid handshake can end an armed listener; no podcast is created without
+media, and the owner can activate again. Rate-limit connection attempts at deployment.
+
+The worker manages bounded FFmpeg.NET listener/remuxing tasks. It rejects ended,
+deleted, revoked or withdrawn accounts and caps
+concurrent captures and duration (the lower of planned duration and configured
+maximum). Revocation cancels the corresponding FFmpeg process and frees its port.
+Activation expiry stops unused listeners. The passphrase is required before SRT
+media can be received; a stream name alone is not an authentication mechanism.
+Committed segments are charged as transferred and stored MiB under the same
+consumption rule; their storage receipts are refunded on podcast deletion.
+OBS storage counts towards the user's effective disk quota and the existing
+podcast media limits. Pending capture files are monitored and bounded; enforcement
+can overshoot by one polling interval of incoming data. Processing errors are
+reported in the owner-only OBS status endpoint, without exposing secret URLs or
+FFmpeg diagnostics. Monitor process/cleanup failures and drain active captures
+before maintenance. An API outage ends ingestion and requires reactivation.
+
+The normal HTTP API authenticates playback; OBS stream credentials never grant
+viewer or account access.
+
+For the real media regressions, install FFmpeg with libsrt and run:
+
+```bash
+dotnet test --project src/test/Yavsc.Api.Tests/Yavsc.Api.Tests.csproj --filter-class '*PodcastObsTests'
+```
+
+The tests launch loopback-only listeners, generate synthetic H.264/AAC media
+with FFmpeg, verify encrypted SRT through FFmpeg.NET, wrong-passphrase rejection,
+revocation during streaming,
+AAC audio, HLS segments, MP4 replay and refund,
+then stops its own processes and removes its temporary files.
+
PostIt Desktop's home page provides **Podcasts : directs et replays**.
Install LibVLC 3 with the `livehttp`, MPEG-TS, x264 and AAC plugins on the
Desktop machine. Windows capture uses DirectShow; Linux uses V4L2 and the
-default PulseAudio microphone. FFmpeg is **not** a runtime dependency.
+default PulseAudio microphone. FFmpeg is **not** a client dependency.
Select a camera and optionally a microphone, enter a title, then start.
+An **Apercu local de la capture** appears at the top of the Podcasts page on
+Android and Desktop. It uses the current capture, not a second camera session
+or the server replay. Android displays the same oriented frames as the encoder,
+with black bars to preserve proportions; Desktop duplicates LibVLC's video
+output. Local microphone playback is disabled to avoid acoustic feedback.
+Stopping releases the preview; hiding/recreating the Android preview surface
+does not restart the encoder or change its timestamps.
Stopping publishes the retained replay; navigating away or logging out
stops capture too. A second signed-in PostIt instance can watch the live
broadcast while it is being captured.
@@ -93,7 +413,12 @@ replays; only the broadcaster can upload, complete or delete their podcast.
Media is not anonymous and no access token is included in a playback URL.
Configure Yavsc.Api's `Podcast` section (or environment variables such as
-`Podcast__RootPath`). No database migration or server-side encoder is needed:
+`Podcast__RootPath`). The base media store needs no database migration;
+planned emissions and OBS require their migrations documented above. Install **FFmpeg 5+
+on the API server** (with `concatf`, MPEG-TS, MP4 and AAC bitstream-filter
+support; for Debian/Ubuntu: `apt-get install ffmpeg`). The API runtime stage
+in the main Dockerfile includes it. Only stream-copy remuxing is performed,
+not video/audio re-encoding:
```json
{
@@ -103,7 +428,9 @@ Configure Yavsc.Api's `Podcast` section (or environment variables such as
"MaxOwnerBytes": 1073741824,
"MaxSegments": 7200,
"MaxOwnerPodcasts": 100,
- "IdleTimeoutSeconds": 60
+ "IdleTimeoutSeconds": 60,
+ "FfmpegPath": "ffmpeg",
+ "ReplayTimeoutSeconds": 600
}
}
```
@@ -118,9 +445,15 @@ Defaults allow 8 MiB per segment (also the HTTP endpoint's hard limit),
1 GiB retained per owner, 7,200 segments per episode and 100 episodes per
owner. At the target two-second segment duration, this is roughly four hours
per episode; the byte quota can be reached earlier. Podcast quotas are
-separate from the legacy user-files `DiskQuota`. Deleting an ended podcast
+separate from the legacy user-files `DiskQuota` for native HTTP capture.
+OBS source segments also count towards the user's effective disk quota and
+instrumented consumption; the additional MP4 is counted only by `MaxOwnerBytes`.
+Deleting an ended podcast
releases its podcast quota. Reverse proxies must allow an 8 MiB PUT body
-and forward Authorization on every API request.
+and forward Authorization, Range and Content-Range on every API request/response.
+The retained MPEG-TS **and** the additional MP4 count toward `MaxOwnerBytes`.
+Allow enough free quota and disk space for both copies and the temporary MP4;
+deletion removes all copies.
A broadcast without a new committed segment for 60 seconds, or present
when the API restarts, becomes an interrupted replay on the next catalogue,
@@ -134,9 +467,26 @@ for manual recovery. There is no automatic resumption after an application
restart; these private local recordings may be removed manually when no
longer needed.
-The replay is **HLS/MPEG-TS**, not an MP4 download. PostIt's authenticated
-player joins a live broadcast up to three segments behind the edge and
-reads a replay from its beginning; seeking is not implemented. Native
+On completion, the API queues a private, seekable **MP4** (`-c copy`,
+`+faststart`). The persisted `replay.state` moves through `Pending`,
+`Processing`, `Ready` or `Failed`; completion itself does not wait for FFmpeg.
+The single API worker also queues older Completed indexes automatically,
+recovers interrupted preparation after a restart, and scans every five seconds.
+Interrupted broadcasts keep MPEG-TS playback unless the owner explicitly
+completes them. Source segments and existing HLS routes remain available.
+Preparation failure keeps all source media and reports an error; after checking
+server logs, FFmpeg installation, timeout and quota, the owner can use PostIt's
+**Relancer la preparation MP4** action, or `POST /api/v1/podcasts/{id}/replay/retry`.
+The MP4 is exposed only when ready, at authenticated
+`GET /api/v1/podcasts/{id}/replay.mp4` (also HEAD; byte ranges supported).
+
+PostIt's Android and Desktop player waits for MP4 preparation, then fetches
+bounded authenticated ranges with token refresh rather than giving LibVLC
+a bearer URL. Replay controls overlay the native video: play/pause, position,
+duration and draggable seek bar. They hide after three seconds without
+interaction while playing, stay visible during seeking/pause/keyboard focus,
+and reappear on pointer movement or touch.
+The live player still joins up to three segments behind the edge. Native
camera/microphone permissions, drivers and codecs must still be verified
on each target Windows/Linux machine.
@@ -147,6 +497,16 @@ the same Avalonia video page as desktop. Catalogue, playback controls and
authenticated segment downloads are shared; no external browser, public media
URL or camera/microphone permissions are needed to watch a podcast.
+Video playback keeps the screen awake while PostIt is visible. Pausing,
+stopping, reaching the end, a playback error or leaving the video releases
+this request; backgrounding the app always allows the screen to sleep.
+
+The podcast page offers **Garder l'ecran allume pendant l'apercu camera et le
+direct** on Android. This preference is saved and disabled by default. It
+only keeps the screen awake during an active camera preview or broadcast
+while PostIt is visible, and can be changed during capture. Turning it off
+does not stop capture or alter the existing background broadcast service.
+
Leaving the app stops playback and cancels downloads. Returning recreates the
player: a replay starts from the beginning, and a live stream rejoins near the
live edge. Seeking and background audio are not supported.
@@ -166,6 +526,22 @@ at IDR frames, with timestamps used for segment durations. Closed segments
enter the same ordered upload/retry/quota/replay pipeline as desktop.
Devices without a supported camera/encoder report a startup error.
+On Android, the optional **Flouter le decor de la camera** setting is saved
+locally and disabled by default. It applies to podcast camera preview and
+recording, not calls or OBS. The bundled Apache-2.0 PPHumanSeg model from
+[OpenCV Zoo](https://github.com/opencv/opencv_zoo/tree/main/models/human_segmentation_pphumanseg)
+is evaluated locally with ONNX Runtime; OpenGL blends the blurred background
+before the native encoder. No frames are sent to a third party. Segmentation
+is imperfect and can expose parts of the background: check the preview and do
+not rely on it to conceal sensitive surroundings. Performance and battery
+usage depend on the device. Capture stops on processing failure.
+The bundled `pphumanseg.onnx` is the OpenCV Zoo 2023mar model (SHA-256
+`552d8a984054e59b5d773d24b9b12022b22046ceb2bbc4c9aaeaceb36a9ddf24`);
+its Apache-2.0 license is included beside the asset.
+ONNX Runtime's Android library requires API 24; it is only loaded by the
+podcast capture code, which is restricted to API 26 and later. The manifest
+override preserves PostIt's existing API 23 minimum for its other features.
+
Camera frames are rotated through an OpenGL surface before encoding, so both
live playback and replays have upright pixels without relying on rotation
metadata (not supported by the MPEG-TS recorder). The sensor, front/rear lens
@@ -262,6 +638,6 @@ You'll need to send e-mail ... using smtp and the provider of your choice, see t
### Google
-I'll have to make with it, a least a moment, it needs a *service account*, and some setup,
-in the `appsettings.*.json` file, and
+I'll have to make with it, a least a moment, it needs a *service account*, and some setup,
+in the `appsettings.*.json` file, and
the execution environment variable GOOGLE_APPLICATION_CREDENTIALS to a value pointing the json description file for the Google Service account.
diff --git a/README.md b/README.md
index 6d4784bad..90e7ba5ba 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,8 @@ Pour une prise en main guidee avec agents IA:
## Construction
```bash
- dotnet build
+sudo dotnet workload restore
+dotnet build
```
et, pour execution en environment de développement
diff --git a/contrib/template.appsettings-api.json b/contrib/template.appsettings-api.json
index afe693a4f..b5562aded 100644
--- a/contrib/template.appsettings-api.json
+++ b/contrib/template.appsettings-api.json
@@ -1,4 +1,7 @@
{
+ "ResourceUsage": {
+ "UserLimits": {}
+ },
"Site": {
"Authority": "https://preprod-yavsc.$DOMAIN",
"Audience": ["api"],
diff --git a/contrib/template.appsettings-blogs.json b/contrib/template.appsettings-blogs.json
index 6f8fa02bc..fa1ebc71c 100644
--- a/contrib/template.appsettings-blogs.json
+++ b/contrib/template.appsettings-blogs.json
@@ -1,4 +1,7 @@
{
+ "ResourceUsage": {
+ "UserLimits": {}
+ },
"Site": {
"Title": "Yavsc Blogs",
"Description": "A collection of blogs about software development, technology, and programming.",
diff --git a/contrib/template.appsettings-org.json b/contrib/template.appsettings-org.json
index c330f5f32..26e987234 100644
--- a/contrib/template.appsettings-org.json
+++ b/contrib/template.appsettings-org.json
@@ -1,4 +1,15 @@
{
+ "ResourceSubscriptions": {
+ "DiscoveryPlanId": "",
+ "PremiumPlanId": "",
+ "WebhookId": "",
+ "DiscoveryPriceExcludingTax": 1,
+ "PremiumPriceExcludingTax": 2,
+ "VatPercent": 20
+ },
+ "ResourceUsage": {
+ "UserLimits": {}
+ },
"Logging": {
"LogLevel": {
"Default": "Information"
@@ -18,7 +29,8 @@
"ApiUrl": "https://preprod-api.$DOMAIN",
"CorsAllowedOrigins": [
"https://preprod-blogs.$DOMAIN",
- "https://preprod-api.$DOMAIN"
+ "https://preprod-api.$DOMAIN",
+ "https://postit.$DOMAIN"
],
"Banner": "/images/banner-dewang.jpg",
"Owner": {
diff --git a/doc/Architecture.md b/doc/Architecture.md
index d48dff22b..820cd37d0 100644
--- a/doc/Architecture.md
+++ b/doc/Architecture.md
@@ -23,6 +23,7 @@ Chaque sujet est détaillé dans sa propre page (sous
| Dictionnaires métier (héritage en arbre) | [dictionnaires-metier.md](architecture/dictionnaires-metier.md) |
| Offre fournisseur + frontmatter (`ClasseFormulaire`, `ClasseDevis`, parsing) | [offres-frontmatter.md](architecture/offres-frontmatter.md) |
| PostIt / OIDC (client desktop, custom URI scheme, silent refresh) | [postit-oidc.md](architecture/postit-oidc.md) |
+| Notifications Web/PostIt, ChatHub et service Android SignalR | [notifications.md](architecture/notifications.md) |
## Stack technique
@@ -57,6 +58,147 @@ sudo adduser --ingroup yavsc --add-extra-groups www-data \
--disabled-password --system yavsc
```
+## Catalogue Web de podcasts
+
+`/Podcast` (vue `src/Yavsc.Org/Views/Podcast/Index.cshtml`) exige une
+session Identity Yavsc.Org, y compris pour chaque requĂŞte de lecture.
+Yavsc.Org interroge Yavsc.Api côté serveur ; aucun jeton n'est transmis
+au navigateur et aucun second catalogue de stockage n'est créé.
+Les replays MP4 prĂŞts prennent en charge GET, HEAD et les plages
+d'octets. Les directs et replays non encore convertis utilisent HLS
+natif ou hls.js (servi localement, installé par `npm install` et copié par
+`npm run build:podcasts`, également inclus dans la copie d'assets de
+`npm run build:js`). Sans support vidéo compatible, la page affiche un
+avertissement et invite à utiliser PostIt. Cette page ne crée ni ne
+supprime de podcast.
+Depuis le lecteur PostIt, « Ouvrir dans le navigateur » ouvre `/Podcast`
+sur l'hôte `Authentication.Authority`, pas la playlist API authentifiée.
+La session Web reste distincte de celle de PostIt : le navigateur peut
+donc demander une connexion.
+
+Il n'y a pas de section de configuration `PodcastWeb`, ni de client OAuth
+technique Ă enregistrer. L'adresse API est celle de `Site:ApiUrl`, en HTTPS
+(avec ou sans suffixe `/api/v1`). Yavsc.Org est l'autorité : comme pour
+l'envoi d'avatar, `IdentityServerTools.IssueJwtAsync` utilise sa signature
+existante pour émettre un jeton de cinq minutes au nom de l'utilisateur
+connecté (`sub`, audience `api`, scope `api` attendu par Yavsc.Api).
+Ce jeton reste côté serveur. Une adresse API manquante renvoie 503 ;
+une panne de l'API renvoie une erreur explicite, pas un catalogue vide.
+
+### Emissions preparees
+
+PostIt memorise dans ses parametres utilisateur les cameras et microphones
+detectes, leurs identifiants selectionnes et le titre par defaut. La page
+les restaure sans redetection automatique ; le bouton de detection actualise
+le materiel disponible en conservant les choix encore presents. Le choix
+« sans microphone » est memorise lui aussi. Charger le titre d'une emission
+preparee ne remplace pas le titre par defaut ; une saisie explicite le modifie.
+Les erreurs de sauvegarde sont affichees dans la page.
+Les appels des salons de discussion reutilisent ces memes choix camera/micro
+et enregistrent leurs changements dans les memes parametres. La page Podcasts
+les recharge a son activation. Les appels exigent toujours un microphone :
+le choix podcast « sans microphone » laisse donc le micro d'appel non selectionne.
+L'adresse LAN/VPN choisie pour les appels est aussi memorisee, mais restauree
+uniquement si elle est encore presente sur une interface locale active.
+Sinon, une nouvelle selection est requise. Le consentement au partage
+d'adresse avec le pair n'est jamais memorise.
+
+PostIt permet de preparer, modifier et supprimer une emission avant son
+demarrage : titre, date/heure locale, duree entiere positive en minutes et
+annonce publique optionnelle. Les horaires sont previsionnels : la camera,
+le demarrage et l'arret restent manuels. Les heures locales inexistantes ou
+ambigues au changement d'heure sont refusees.
+
+La table existante `LiveFlow` conserve la preparation et son proprietaire ;
+`PodcastId` (GUID unique) relie cette emission au manifeste media sur disque.
+`PodcastResponse` reste un DTO, enrichi de `FlowId`, `ScheduledStartAt`,
+`PlannedDurationMinutes` et `PublicAnnouncement`. Un etat `Planned`
+precede le direct ; la date previsionnelle n'est jamais confondue avec
+`CreatedAt` du direct ni la duree previsionnelle avec les secondes enregistrees.
+Les anciens manifestes sans `LiveFlow` restent lisibles ; aucune copie ou
+migration de leurs medias n'est requise. Le demarrage immediat historique
+reste disponible sans preparation.
+
+L'API propose `POST /api/v1/podcasts/planned`,
+`PUT /api/v1/podcasts/{id}/planned` et `POST /api/v1/podcasts/{id}/start`.
+La preparation n'est visible que du proprietaire, meme avec une annonce ;
+les nouvelles routes de mutation exigent le scope `api`. Le demarrage
+conserve le GUID et les tentatives concurrentes reutilisent le meme direct.
+Une emission demarree ne peut plus etre reprogrammee ou redemarree apres
+sa fin. Les medias restent geres par `ILiveProcessor`, avec ses quotas,
+expiration, reprise et preparation MP4. Une suppression conserve un
+marqueur en base pour ne pas ressusciter une emission deja supprimee.
+Le verrou de coordination suit le deploiement mono-processus du stockage
+media actuel ; un deploiement multi-instance necessiterait un stockage et
+une coordination distribues.
+
+Seul `GET /api/v1/podcasts/announcements` est anonyme : titre, nom d'auteur,
+horaire UTC, duree et texte public, sans URL de flux ni metadonnees privees.
+`/Podcast/Announcements` affiche ces annonces avec encodage Razor et sans
+jeton utilisateur. Retirer le texte public avant le debut retire l'annonce.
+Les annonces restent disponibles apres le direct jusqu'a suppression du
+podcast. Les pages et toutes les routes de lecture restent authentifiees.
+Appliquer la migration `PodcastScheduling` au deploiement, apres celle des
+dons ; aucune migration de production n'est appliquee automatiquement ici.
+
+### Dons PayPal aux performers
+
+Les dons sont gérés par Yavsc.Org, pas par un lien de paiement externe
+configuré par l'opérateur :
+
+1. Depuis **Mon compte > Dons PayPal**, le performer renseigne l'adresse
+ de son propre compte PayPal (`/Donation/Settings`). Un champ vide
+ désactive les nouveaux dons. Seuls les performers actifs ayant
+ configuré leur compte proposent un bouton de don dans le catalogue.
+ Le formulaire est aussi accessible depuis le catalogue de podcasts et
+ le profil professionnel Web. Dans PostIt : **Mon profil > Gérer mon
+ activité professionnelle > Dons PayPal**, puis **Enregistrer**.
+ L'API privée `GET/PUT /api/v1/account/performer-profile` transporte
+ `DonationPayPalEmail` uniquement pour le compte connecté ; une chaîne
+ vide désactive les dons, une propriété omise ou nulle préserve
+ l'adresse existante pour les anciens clients.
+2. Le donateur connecté choisit un montant en euros (`/Donation/Create`).
+ Yavsc conserve le don et son bénéficiaire avant de créer le checkout.
+3. Yavsc utilise les paramètres marchands existants
+ `Authentication:PayPal` (mode sandbox/production et identifiants NVP).
+ Express Checkout désigne le compte du performer par
+ `PAYMENTREQUEST_0_SELLERPAYPALACCOUNTID` : le paiement va directement
+ au performer ; Yavsc ne collecte pas les fonds et ne les reverse pas.
+4. PayPal recueille l'accord du donateur puis le renvoie dans Yavsc.
+ Une confirmation POST avec protection antiforgery déclenche le
+ paiement, après vérification côté serveur du token, du montant,
+ de la devise, de la référence et du bénéficiaire. Un simple retour
+ du navigateur n'est jamais considéré comme une preuve de paiement.
+5. Seule une réponse PayPal vérifiée permet d'afficher le don comme payé.
+ Les notifications IPN reçues sur `/Donation/Notify` sont revalidées
+ auprès de PayPal, puis rapprochées du bénéficiaire, du montant, de la
+ devise et de la transaction. Elles permettent aussi de confirmer
+ ultérieurement un paiement Pending ou une réponse de capture perdue.
+
+`Site:ExternalUrl` doit être l'URL HTTPS publique de Yavsc.Org, utilisée
+pour les retours et notifications (jamais le Host fourni par le client).
+PayPal doit pouvoir joindre `/Donation/Notify`. Le compte marchand
+doit être autorisé par PayPal pour les paiements directs à un tiers ;
+valider ce parcours en sandbox avec deux comptes distincts avant mise
+en production. Les tests locaux utilisent un serveur PayPal simulé,
+pas de véritables transactions.
+
+`PerformerDonations` conserve la référence, le donateur, le performer,
+le bénéficiaire figé à la création, le montant et l'état du paiement.
+La migration `PerformerPayPalDonations` ajoute ce suivi et l'adresse
+PayPal optionnelle du performer. Les profils ayant un historique de
+dons ne peuvent pas être supprimés. Les rééditions du profil général
+ne remplacent pas la configuration du bénéficiaire.
+
+Le paiement n'est capturé qu'une fois : contrôle de concurrence,
+référence de déduplication PayPal (`MSGSUBID`) et transaction unique.
+En cas de réponse ambiguë, le don reste en vérification sans nouvelle
+capture automatique. Le donateur retrouve son suivi dans **Mon compte >
+Mes dons** (`/Donation`). Si l'IPN ne réconcilie pas cet état, l'opérateur
+doit vérifier la transaction auprès de PayPal avant toute nouvelle
+tentative. Les dons sont facultatifs et n'ouvrent pas droit à un reçu
+fiscal émis par cette page.
+
## À documenter ensuite
- Modèle `ProjetMusical`
diff --git a/doc/README.md b/doc/README.md
index 10e32b0c9..73f4bae6c 100644
--- a/doc/README.md
+++ b/doc/README.md
@@ -16,6 +16,7 @@ La racine de l'architecture est [Architecture.md](Architecture.md).
| [architecture/offres-frontmatter.md](architecture/offres-frontmatter.md) | Offre fournisseur, ClasseFormulaire, ClasseDevis, parsing frontmatter |
| [architecture/postit-oidc.md](architecture/postit-oidc.md) | Client desktop PostIt, custom URI scheme, silent refresh |
| [architecture/postit.md](architecture/postit.md) | PostIt — topologie des projets, ViewLocator custo, navigation, DI, conventions de binding |
+| [architecture/audio-video-calls.md](architecture/audio-video-calls.md) | Plan des appels WebRTC PostIt : SignalR, préférence de masquage IP via TURN et groupes via SFU |
| [architecture/notifications.md](architecture/notifications.md) | Notifications persistées, messages Web et événements temps réel côté serveur, Web et PostIt |
| [architecture/decoupage-organisation.md](architecture/decoupage-organisation.md) | Découpage des projets .NET (Abstract, Server, Org, Api, Blogs, Web, Org.Tests) |
| [testing.md](testing.md) | Stratégie de test : conventions des dossiers, EF Core in-memory, auth stubs, scaffold partagé |
diff --git a/doc/architecture/audio-video-calls.md b/doc/architecture/audio-video-calls.md
new file mode 100644
index 000000000..1fb9fc7ef
--- /dev/null
+++ b/doc/architecture/audio-video-calls.md
@@ -0,0 +1,587 @@
+# Appels audio-vidéo PostIt — architecture cible
+
+## Statut et périmètre
+
+Ce document décrit l'architecture cible et l'implémentation commencée.
+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.
+Il complète la [topologie de PostIt](postit.md) et les
+[mécanismes de notification existants](notifications.md).
+La cible couvre :
+
+- les appels audio-vidéo bidirectionnels entre deux utilisateurs ;
+- un réglage utilisateur booléen persistant permettant de masquer son adresse
+ IP aux autres participants en imposant TURN ;
+- les appels de groupe ;
+- les clients Browser, Android et Desktop.
+
+## Première implémentation Android et Desktop Linux : SRTP direct IPv4/IPv6
+
+Les adresses IPv4 publiques directement assignees a une interface locale active
+sont egalement disponibles, avec la meme validation unicast cote client,
+media et signalisation serveur. Les IPv6 globales (2000::/3), privees ULA
+(fc00::/7) et de boucle locale (::1) sont aussi acceptees. Les sockets UDP
+utilisent la famille de l'adresse locale et les URL de reception encadrent
+les IPv6 de crochets. Les adresses non specifiees, link-local, multicast,
+reservees IPv4 (240/4), IPv4-mapped IPv6 et les formes non canoniques ou
+avec identifiant de zone sont refusees. Une zone link-local du premier
+pair n'est pas reutilisable telle quelle par le second.
+Il faut autoriser en entree les deux ports UDP consecutifs choisis et assurer
+la joignabilite entre les pairs. Ce support n'ajoute ni ICE/TURN ni traversee
+NAT automatique : l'adresse publique d'un routeur ne remplace pas une adresse
+assignee a la machine. Le consentement explicite au partage d'IP et le refus
+du mode direct pour les comptes masquant leur IP restent inchanges.
+Les pairs doivent disposer de routes vers leurs adresses respectives ;
+aucune traduction automatique IPv4/IPv6 n'est fournie. Les tests natifs
+Linux verifient sur ::1 la reception audio/video bidirectionnelle chiffree,
+le rejet d'une mauvaise cle et le cycle de vie des ports RTP/RTCP.
+Un appel IPv6 entre deux machines et le transport IPv6 Android restent
+a valider en conditions reelles.
+
+Cette tranche réutilise la capture caméra/microphone et les encodeurs des
+Podcasts, mais **pas leur segmentation HLS ni leurs envois de fichiers** :
+
+```text
+PostIt A ----------- ChatHub authentifié / HTTPS ----------- PostIt B
+ invitation, consentement,
+ adresses et clés, fin
+
+PostIt A ========== H.264/AAC, MPEG-TS sur SRTP/UDP ========== PostIt B
+ dans les deux sens
+```
+
+L'implémentation est dans
+[LibVlcLanCallMedia](../../src/PostIt/PostIt/Services/LibVlcLanCallMedia.cs),
+[LinuxLanCallVideo](../../src/PostIt/PostIt/Services/LinuxLanCallVideo.cs) et
+[LanCallViewModel](../../src/PostIt/PostIt/ViewModels/Chat/LanCallViewModel.cs).
+Android utilise
+[AndroidLanCallMedia](../../src/PostIt/PostIt.Android/Services/AndroidLanCallMedia.cs)
+avec les mêmes contrats et clés SRTP.
+Les contrôles et les deux surfaces vidéo sont intégrés à la page du chat.
+Il n'y a pas de service de salles supplémentaire, d'enregistrement,
+de fichier média temporaire ou de moteur WebRTC Android ajouté.
+
+### Activer et essayer
+
+1. Sur le serveur, activer explicitement les deux options :
+
+ ```json
+ {
+ "AudioVideoCalls": {
+ "Enabled": true,
+ "EnableLanCalls": true
+ }
+ }
+ ```
+
+ Les deux valeurs sont `false` par défaut. Les paramètres TURN ne sont
+ pas nécessaires pour ce mode. Utiliser le ChatHub en **HTTPS** ;
+ invitation, acceptation et échange de clés LAN sont refusés en HTTP.
+ Derrière un proxy TLS, configurer correctement le schéma HTTPS transmis
+ Ă ASP.NET Core, uniquement depuis les proxys de confiance.
+2. Utiliser deux clients Android 8+ ou Desktop Linux. Linux nécessite LibVLC
+ avec V4L2, PulseAudio, x264, AAC et RTP/SRTP installés. Android réutilise
+ la bibliothèque VLC embarquée pour les Podcasts et MediaRecorder pour
+ H.264/AAC. La version Debian 13 a été utilisée pour les essais Linux.
+ Les deux comptes doivent être présents dans
+ la mĂŞme salle existante et ne pas se bloquer mutuellement.
+3. Dans « Appel direct IPv4/IPv6 (LAN/VPN ou IP publique) », actualiser les périphériques,
+ sélectionner la caméra, le microphone et une IPv4 privée locale
+ accessible depuis le pair. Les adresses RFC1918 et de bouclage sont
+ acceptées ; pas de DNS, IPv6 ou adresse publique. Le bouclage sert aux
+ essais sur un mĂŞme hĂ´te, pas Ă joindre un second poste.
+4. Choisir un port UDP **pair entre 1024 et 65534**, par défaut 5004.
+ Autoriser l'entrée UDP sur ce port **et le suivant** depuis le pair dans
+ le pare-feu : RTP sur le port pair, RTCP sur le port impair suivant.
+ Les deux ports doivent ĂŞtre disponibles. Deux clients sur la mĂŞme
+ adresse doivent utiliser des paires distinctes.
+ Aucun pare-feu n'est modifié automatiquement.
+5. Saisir le pseudo exact du destinataire, confirmer la divulgation de
+ l'adresse IP locale (LAN/VPN ou publique), puis appeler. Le destinataire choisit ses propres
+ périphériques et son adresse, confirme et accepte explicitement.
+ Aucun accès à la caméra/microphone ne commence avant l'acceptation ;
+ l'émission attend également la destination validée du pair.
+6. Utiliser un **casque** : il n'y a pas d'annulation d'écho acoustique.
+ « Refuser / Raccrocher », la sortie de page et la perte de SignalR
+ arrêtent et libèrent les médias. Il n'y a pas de reprise automatique
+ de capture après reconnexion.
+
+### Capture et cycle de vie Android
+
+- La caméra avant est sélectionnée en priorité dans la liste ; une autre
+ caméra reste sélectionnable explicitement. Le microphone est obligatoire.
+- Les permissions caméra, microphone et notifications sont demandées
+ après acceptation et réception de l'endpoint distant, avant la capture.
+ Un refus termine explicitement l'appel, sans tentative de capture de repli.
+- Camera2, MediaRecorder et la rotation EGL sont ceux des Podcasts.
+ Le descripteur du pipe MPEG-TS est lu directement par LibVLC (`fd://`)
+ puis remultiplexé vers SRTP, **sans réencodage**, HLS ou fichier média.
+ Le pipe système assure une mémoire bornée ; il n'y a pas de file de
+ segments ni de lecture de capture par callbacks managés.
+- La prévisualisation réutilise la surface EGL existante. Le retour
+ distant utilise la surface Android LibVLC déjà employée pour les Podcasts.
+ La rotation capteur/écran tient compte de celle déjà portée par la matrice
+ `SurfaceTexture` (miroir de la caméra avant compris) et suit les changements
+ portrait/paysage. Les dimensions
+ encodées restent fixes pendant l'appel, avec bandes noires si nécessaire.
+- Le service de capture partagé affiche une notification d'appel avec
+ l'action « Raccrocher » ; cette action ne publie aucun Podcast.
+ Un Podcast et un appel ne peuvent pas posséder la capture simultanément.
+- Le passage de PostIt en arrière-plan termine cet appel vidéo ; revenir
+ dans l'application ne le redémarre pas. La sortie de page et la perte
+ SignalR conservent la même règle d'arrêt.
+- À l'arrêt, le lecteur natif libère d'abord son entrée. Le pipe restant
+ est drainé pendant la finalisation de MediaRecorder, pour ne pas bloquer
+ son écrivain, puis caméra, microphone, lecteurs et service sont libérés.
+
+#### Particularité VLC Android : RTCP séparé
+
+L'essai matériel initial a identifié un SIGSEGV dans `libc.__vfprintf`,
+appelé par `vlc_memstream_vprintf` puis `sdp_AddAttribute` pendant la
+création de la sortie RTP. Le code VLC 3 génère l'attribut sans valeur
+`rtcp-mux` avec un format nul ; cette combinaison échoue avec le binaire
+Android embarqué. Ce crash est distinct du précédent essai libwebrtc/JNI.
+
+Les appels utilisent donc une paire RTP/RTCP standard, sans `rtcp-mux`,
+sur Android **et** Linux. Les médias conservent les mêmes codecs, clés et
+port RTP : c'est un changement de configuration du transport, pas
+l'ajout d'un moteur WebRTC ou d'une cryptographie propre au projet.
+
+### Confidentialité et limites
+
+- Une clé SRTP aléatoire de 128 bits et un sel de 112 bits sont générés
+ par appel et par direction avec le générateur cryptographique système.
+ Seuls les deux appareils ayant accepté échangent un endpoint chacun
+ via SignalR authentifié. Les représentations diagnostiques masquent
+ adresse, clé et sel.
+- Le chiffrement SRTP est fourni par LibVLC ; les clés passent par
+ le serveur de signalisation, qui **peut donc les connaître**. Ce n'est
+ pas un chiffrement de bout en bout Ă l'insu du serveur.
+- Si l'un des comptes impose `HideIpAddressInCalls`, le mode LAN est
+ **refusé**, y compris si la préférence change avant l'acceptation.
+ Il n'y a aucun repli direct contournant cette préférence.
+- Pas d'ICE, de STUN, de TURN, de traversée NAT automatique, de groupe,
+ d'interopérabilité Browser, de négociation de codecs ni
+ d'adaptation de débit. Ce mode exige une connectivite IP directe entre les pairs
+ (LAN/VPN ou adresse publique assignee), avec les ports UDP ouverts.
+- H.264 Ă 30 images/s, cible 1 200 kbit/s ; AAC mono 48 kHz, 96 kbit/s.
+ Ces réglages ne constituent pas une garantie de latence ni de débit.
+ Le retour local n'émet pas le son du microphone.
+- L'absence de première réception audio **et** vidéo provoque l'arrêt
+ après 30 secondes ; les erreurs natives sont affichées et terminent
+ l'appel. Après réception initiale, les compteurs LibVLC ne permettent
+ pas ici de diagnostiquer précisément une panne média silencieuse :
+ l'utilisateur peut raccrocher, et la perte de SignalR arrĂŞte toujours
+ la capture. Pas encore de mesure de qualité ou de latence affichée.
+
+### Validation effectuée et restante
+
+Les tests natifs utilisent deux moteurs LibVLC réels, un fichier audio-vidéo
+synthétique fourni explicitement et de vrais sockets UDP de bouclage :
+
+- décodage bidirectionnel de trames vidéo et d'échantillons audio PCM ;
+- refus de décodage avec une mauvaise clé, sans casser l'autre direction ;
+- même échange avec la branche de prévisualisation locale activée
+ (sortie factice dans ce test sans fenĂŞtre).
+- entrée MPEG-TS déjà encodée à travers un pipe, sans transcodage.
+
+Les tests de signalisation couvrent consentement, sélection d'un seul
+appareil, confidentialité, HTTPS, validation des endpoints et arrêt.
+Les tests Avalonia sans fenĂŞtre couvrent l'ordre invitation/acceptation/
+capture, le refus, les événements tardifs, l'interruption, les erreurs média
+et l'annulation d'un démarrage natif en attente. Ils vérifient aussi les
+hooks Android, le choix initial de caméra avant, la configuration lors
+d'une invitation entrante et l'arrêt lors du passage en arrière-plan.
+
+Pour exécuter les tests média, définir `POSTIT_TEST_MEDIA` avec le chemin
+d'un MP4 H.264/AAC de test (640 Ă— 480), puis :
+
+```sh
+dotnet test --project src/PostIt/PostIt.Tests/PostIt.Tests.csproj \
+ --filter-class '*LinuxLanCallMediaTests'
+```
+
+Sans cette entrée explicite, ces tests sont ignorés, pas remplacés par un
+succès fictif. Les tests de contrôle s'exécutent sans caméra.
+Le test de pipe utilise `POSTIT_TEST_TS`, un MPEG-TS H.264/AAC explicite.
+
+Une activité **Debug uniquement**,
+[AndroidLanCallTestActivity](../../src/PostIt/PostIt.Tests/AndroidLanCallTestActivity.cs),
+teste l'adaptateur réel sur téléphone : caméra avant/microphone, surfaces
+de retour et prévisualisation attachées, deux moteurs SRTP en UDP de
+bouclage, retour synthétique et rejet d'une mauvaise clé. Elle n'utilise
+ni compte ni API ; elle ne valide donc pas Ă elle seule un appel SignalR
+entre deux comptes. L'activité n'est pas compilée dans l'APK Release.
+
+Pour la lancer sur un appareil de développement dont les permissions
+ont été accordées, installer l'APK Debug et ses assemblies via
+`dotnet build -t:Install`, puis copier un MPEG-TS synthétique de 40 secondes,
+640 × 480 avec audio AAC, sous `files/lan-call-fixture.ts` dans les données
+privées de l'application. Exécuter :
+
+```sh
+adb shell am start -S -n fr.pschneider.postit/fr.pschneider.postit.LanCallTestActivity
+adb shell run-as fr.pschneider.postit cat files/lan-call-test-result.txt
+# Variante : ajouter --es wrongKey true Ă la commande am start.
+```
+
+Le résultat ne devient `PASS` qu'après vérification des médias et nettoyage
+complet. Le test ne produit aucun enregistrement de caméra.
+Sur le téléphone Android 15 arm64 connecté, l'essai positif a décodé
+158 trames caméra et 399 360 échantillons audio en environ dix secondes,
+avec un retour audio/vidéo décodé simultanément. L'essai avec mauvaise clé
+a produit zéro trame et zéro échantillon dans la direction concernée,
+tout en conservant le retour. Les deux essais ont terminé leur nettoyage,
+sans service de capture restant. La capture Podcast antérieure a également
+été retestée sur caméra avant : quatre segments, environ 11,8 secondes,
+audio AAC présent, capture en arrière-plan puis arrêt par notification.
+
+**La caméra physique, le rendu natif visible dans deux applications, le
+son audible et un appel entre deux machines restent à valider côté Linux** :
+aucune caméra n'était disponible sur cet hôte. La capture matérielle Android
+est testée, mais un appel Android ↔ Linux ou entre deux téléphones distincts
+sur LAN/VPN et la qualité acoustique restent à valider. Les essais de
+bouclage ne prouvent pas une latence conversationnelle.
+
+## Choix des protocoles
+
+La table suivante demeure la **cible multi-plateforme initiale**, distincte
+du premier transport Linux LAN/VPN décrit ci-dessus.
+
+| Besoin | Choix | RĂ´le |
+|---|---|---|
+| Médias temps réel | WebRTC | Audio-vidéo bidirectionnel à faible latence, adaptation au réseau |
+| Chiffrement du transport média | DTLS-SRTP | Établissement des clés et protection des médias |
+| Signalisation | SignalR sur HTTPS | Invitation, acceptation/refus, négociation SDP, candidats ICE, fin d'appel |
+| Connectivité | ICE, STUN et TURN | Sélection du chemin réseau, découverte d'adresse et relais |
+| Audio | Opus | Codec privilégié pour la voix |
+| Vidéo | VP8 ou H.264 | Codec négocié selon les capacités réelles des clients |
+| Appels de groupe | SFU compatible WebRTC | Réception et redistribution sélective des flux |
+
+SignalR transporte les messages de contrôle, **jamais les flux audio-vidéo**.
+La signalisation doit réutiliser le [ChatHub existant](../../src/Yavsc.Server/Hubs/ChatHub.cs),
+déjà exposé par [Yavsc.Api](../../src/Yavsc.Api/Program.cs), et ses salles de
+discussion. Il n'est pas nécessaire de créer un second service de salles.
+Les contrats d'appel et leurs autorisations restent à définir explicitement :
+l'appartenance Ă une salle ne vaut pas acceptation d'un appel.
+Le choix des bibliothèques natives, du SFU et des codecs effectivement
+disponibles reste Ă valider par un prototype multi-plateforme.
+
+## Topologies média
+
+### Appels Ă deux
+
+```text
+PostIt A ---- SignalR / HTTPS ---- Serveur ---- SignalR / HTTPS ---- PostIt B
+ Invitation, acceptation, SDP, candidats ICE, fin
+
+PostIt A ================= WebRTC direct ========================= PostIt B
+ ou
+PostIt A ================= relais TURN =========================== PostIt B
+```
+
+Privilégier un chemin direct lorsque les préférences de confidentialité le
+permettent. Prévoir TURN dès la première version : STUN seul ne suffit pas sur
+certains réseaux mobiles, NAT ou réseaux d'entreprise.
+
+Déployer par exemple coturn, avec des transports UDP et des solutions de
+repli TCP/TLS, dont TURN/TLS sur le port 443. Ce dernier améliore la
+connectivité sans garantir la traversée de tous les pare-feu et proxys.
+
+### Appels de groupe
+
+```text
+PostIt A ---- WebRTC, éventuellement via TURN ----+
+PostIt B ---- WebRTC, éventuellement via TURN ----+---- SFU
+PostIt C ---- WebRTC, éventuellement via TURN ----+
+```
+
+Utiliser un **SFU**, plutĂ´t qu'un maillage de connexions entre participants :
+chaque client envoie ses pistes au serveur, qui redistribue les flux utiles.
+Cela évite de multiplier les envois montants avec le nombre de participants.
+Prévoir la sélection des pistes reçues et, selon les capacités des clients,
+le simulcast ou le codage vidéo scalable pour adapter débit et résolution.
+
+Le SFU ne remplace pas TURN : un client peut avoir besoin d'un relais pour
+atteindre le SFU, ou l'imposer par sa préférence de confidentialité.
+
+Les contrats de signalisation doivent représenter dès le départ un appel et
+ses participants, sans être limités à un couple appelant/appelé. Pour ajouter
+un troisième participant à un appel direct, établir les connexions au SFU,
+puis fermer les connexions directes après confirmation du nouveau transport.
+En cas d'échec, conserver l'appel à deux et signaler l'échec de l'ajout.
+Une topologie SFU pour tous les appels reste une alternative à évaluer si la
+simplicité d'exploitation prime sur le coût serveur.
+
+## Préférence persistante de masquage d'adresse IP
+
+### Contrat fonctionnel
+
+Le booléen de compte `HideIpAddressInCalls` est persisté côté serveur et
+accessible en lecture/écriture uniquement par
+l'utilisateur concerné via `GET /api/v1/account/me` et
+`PUT /api/v1/account/me`, ainsi que dans « Mon profil » de PostIt.
+Le réglage est partagé entre ses appareils ; une préférence locale seule
+ne suffit pas.
+
+Valeur initiale : `false`, pour les nouveaux comptes et les comptes existants
+après migration. Le champ de mise à jour est nullable : son absence ou `null`
+conserve la valeur existante, notamment pour les anciens clients ; `false`
+explicite désactive la préférence.
+`false` autorise le chemin direct mais n'interdit pas TURN lorsqu'il est
+nécessaire à la connectivité. `true` impose un transport relayé.
+
+Présenter le réglage comme « Masquer mon adresse IP aux autres participants »,
+en précisant le surcoût potentiel en latence et en bande passante serveur.
+Il ne procure pas l'anonymat : les services contactés, notamment l'API, le
+serveur de signalisation et TURN, peuvent toujours connaître l'adresse IP.
+
+La migration EF Core `HideIpAddressInCalls`, dans le projet Yavsc.Org, ajoute
+la colonne booléenne non nullable à `AspNetUsers`. Elle doit être déployée
+avant de servir les nouvelles lectures et écritures de profil. Cette étape
+n'installe ni TURN ni SFU et n'implémente pas encore les règles de négociation
+décrites ci-dessous.
+
+### Application à la négociation
+
+- Charger la préférence avant de créer le transport média. Si sa lecture
+ échoue, signaler l'erreur et bloquer l'établissement plutôt que supposer
+ que le masquage est désactivé.
+- Lorsque le réglage est activé, configurer une politique ICE **relay-only**
+ (`iceTransportPolicy: "relay"` dans le navigateur, équivalent natif ailleurs)
+ avant la collecte des candidats.
+- Ne publier aucun candidat local `host` ou `srflx`, ni aucune adresse locale
+ dans les descriptions SDP ou messages de signalisation. Utiliser les API du
+ moteur WebRTC et vérifier les descriptions produites, plutôt qu'une
+ réécriture ad hoc du SDP.
+- Appliquer cette contrainte aux offres, réponses, renégociations,
+ redémarrages ICE et transitions vers le SFU.
+- Le masquage d'un participant impose le relais de **son propre transport**,
+ même si les autres participants n'ont pas activé cette préférence.
+- Si TURN est indisponible ou qu'aucune paire de candidats relayée n'aboutit,
+ afficher une erreur explicite ; **aucun repli direct automatique**.
+
+Le serveur détermine la politique attendue depuis la préférence persistée,
+contrôle les messages de signalisation et distribue les paramètres autorisés.
+Le client applique la politique ICE ; les tests doivent vérifier le chemin
+réellement sélectionné, pas seulement la configuration demandée.
+
+Une modification pendant un appel doit ĂŞtre prise en charge explicitement :
+l'activation suspend l'émission et remplace le transport avant de reprendre
+les médias en mode relayé. L'interface ne doit pas annoncer le masquage tant
+que ce remplacement n'est pas confirmĂ©. Elle prĂ©cise qu'une adresse dĂ©jĂ
+divulguée auparavant ne peut pas être retirée aux participants.
+La désactivation peut attendre l'appel suivant, sans abandonner le relais
+en cours.
+
+## Intégration dans PostIt
+
+Séparer le cycle de vie partagé de l'appel du moteur média :
+
+- code partagé : invitation, sonnerie, acceptation/refus, participants,
+ préférences, état de connexion, coupure micro/caméra et raccrochage ;
+- Browser : API WebRTC du navigateur via interop JavaScript ;
+- Android et Desktop : moteur WebRTC natif et intégration de la capture,
+ des périphériques et du rendu dans Avalonia.
+
+Le prototype doit vérifier les bindings maintenus, leurs licences, les
+architectures processeur supportées, les codecs et l'intégration Avalonia.
+Ne pas supposer qu'une bibliothèque .NET couvre à elle seule la capture,
+l'annulation d'écho et le rendu sur toutes les plateformes.
+
+Prévoir les permissions caméra/micro, les changements de périphérique,
+les interruptions Android, la reconnexion et le redémarrage ICE.
+Les appels entrants en arrière-plan nécessitent une intégration aux
+notifications système et au cycle de vie Android ; une connexion SignalR
+active ne peut pas être présumée.
+
+## Autorisations, confidentialité et exploitation
+
+- Authentifier la signalisation et vĂ©rifier cĂ´tĂ© serveur l'appartenance Ă
+ l'appel pour chaque commande et événement, y compris rejoindre un groupe,
+ inviter, publier une piste et recevoir les flux.
+- Prévoir des invitations expirables et gérer les réponses concurrentes de
+ plusieurs appareils sans accepter plusieurs fois le mĂŞme participant.
+- Délivrer des identifiants TURN temporaires et des autorisations SFU limitées
+ Ă l'appel et au participant ; aucun secret permanent dans les clients.
+- Limiter les invitations, les participants et les débits selon une politique
+ produit à définir ; surveiller la capacité et le coût TURN/SFU.
+- Ne pas journaliser systématiquement SDP, candidats ICE ou identifiants TURN.
+ Préférer des métriques de qualité et des identifiants techniques d'appel.
+- Distinguer chiffrement du transport et chiffrement de bout en bout :
+ en connexion directe ou via TURN, les médias restent chiffrés entre les deux
+ clients ; avec un SFU classique, DTLS-SRTP se termine au SFU. Un chiffrement
+ de bout en bout des groupes demanderait un mécanisme supplémentaire et une
+ gestion des clés à concevoir, sans être promis par ce plan.
+
+## Étapes proposées
+
+1. **Prototype multi-plateforme** : valider capture, rendu, codecs et WebRTC
+ entre Browser, Android et Desktop, y compris via TURN.
+2. **Appels à deux** : signalisation authentifiée, cycle de vie d'appel,
+ coturn, préférence persistante et politique relay-only opérationnelle.
+3. **Appels de groupe** : sélectionner et intégrer le SFU, autoriser les
+ participants, gérer les pistes et la transition depuis un appel direct.
+4. **Fiabilisation** : arrière-plan Android, réseau mobile, reprise après
+ interruption, accessibilité des contrôles et observabilité.
+
+Les appels de groupe font partie de la cible finale, pas d'une simple
+extension facultative. Leur modèle de participants doit être anticipé dès
+la signalisation des premiers appels Ă deux.
+
+## Critères de validation
+
+- Audio et vidéo bidirectionnels sur les combinaisons de plateformes ciblées.
+- Appel direct autorisé quand le réglage est désactivé et relais disponible
+ lorsque le réseau l'exige.
+- Préférence conservée après reconnexion et relue sur un autre appareil.
+- Avec masquage activé, absence d'adresses locales/publiques propres au client
+ dans la signalisation transmise aux pairs et sélection effective d'un
+ candidat local `relay`, confirmée par les statistiques WebRTC.
+- Aucun repli direct si TURN échoue, y compris après redémarrage ICE,
+ changement de réseau ou ajout d'un participant.
+- En groupe, contrôle d'accès aux pistes, départ et arrivée de participants,
+ adaptation de qualité et respect individuel de la politique TURN.
+- Activation du masquage pendant un appel : suspension des médias,
+ remplacement vérifié du transport et retour d'état fidèle dans l'interface.
+- Échecs de permissions, de signalisation, de TURN et du SFU visibles,
+ ressources caméra/micro et connexions libérées à la fin de l'appel.
+
+## Première tranche intégrée : signalisation Android et Desktop Linux
+
+Le périmètre initial retenu est **Android + Desktop Linux**. Il n'ajoute
+aucun serveur ni aucune salle : les méthodes suivantes appartiennent au
+[ChatHub](../../src/Yavsc.Server/Hubs/ChatHub.Calls.cs) existant.
+Les [contrats partagés](../../src/Yavsc.Abstract/Chat/Calls/CallContracts.cs)
+sont utilisés par le serveur et PostIt.
+
+| Méthode | Effet |
+|---|---|
+| `InviteCall(roomName, callee)` | Invite un autre compte présent dans la salle et retourne un identifiant d'appel |
+| `AcceptCall(callId)` | Accepte sur un seul appareil, notifie les deux pairs et ferme l'invitation sur les autres appareils |
+| `SendCallSignal(callId, signal)` | Transmet l'offre, la réponse ou un candidat ICE uniquement à l'autre appareil accepté |
+| `EndCall(callId)` | Annule, refuse ou termine l'appel depuis un appareil autorisé |
+
+Événements : `CallInvitation`, `CallAccepted`, `CallSignal(callId, signal)`
+et `CallEnded`. **Accepté ne veut pas dire connecté** : l'événement accepté
+exprime le consentement et fournit la politique ICE et les paramètres
+STUN/TURN, pas une réussite de l'échange média.
+
+Le serveur vérifie les comptes, la présence dans la salle et le blocage
+entre utilisateurs. Les appareils d'un compte reçoivent l'invitation ;
+seul le premier qui accepte peut ensuite émettre la réponse et les
+candidats. L'appelant reste lié à sa connexion d'origine. Les médias
+ne sont jamais diffusés au groupe SignalR de la salle.
+
+La préférence persistée est lue à l'invitation et relue à l'acceptation.
+Pour cette première version à deux, si l'un des comptes demande le
+masquage, **les deux transports doivent être relayés**, règle conservatrice
+plus stricte que la politique individuelle cible. L'acceptation ne peut
+pas diminuer la protection annoncée à l'invitation. Sans TURN configuré,
+un appel imposant le relais échoue explicitement.
+
+La signalisation refuse les candidats non relayés, les adresses associées
+non masquées et les adresses directes dans les champs SDP contrôlés lorsque
+le relais est imposé. Ces contrôles de forme ne constituent pas un audit
+exhaustif de toutes les extensions SDP possibles : la non-divulgation doit
+encore être prouvée avec les SDP et statistiques des moteurs réellement
+intégrés. Aucun SDP n'est réécrit.
+
+L'activation du masquage ou le changement de pseudo par l'API de profil
+termine l'appel existant ; le client devra libérer les médias et proposer
+un nouvel appel. La renégociation transparente du transport n'est pas
+implémentée. La déconnexion d'un pair sélectionné, le départ ou l'exclusion
+de la salle terminent également l'appel. Pas de reprise automatique après
+reconnexion : elle crée une nouvelle identité de connexion.
+
+Les appels sont temporaires, en mémoire et **sur une seule instance API**.
+Une invitation expire après 45 secondes, une session acceptée après une
+heure ; les identifiants TURN expirent cinq minutes plus tard. Cette borne
+initiale ne remplace pas un futur renouvellement d'identifiants pour les
+appels longs. Un compte ne peut avoir qu'un appel réservé ou accepté à la
+fois. Le registre est limité à 128 appels et 256 candidats par appel.
+La tranche ne permet qu'une offre initiale de l'appelant et une réponse ;
+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 ;
+- `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.
+
+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.
+
+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.
+
+### 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.
+
+## Retour sur l'essai Android du 25 octobre 2026
+
+Le laboratoire indépendant a été supprimé ; il ne constitue pas une base
+de salles de discussion ni une implémentation de PostIt. La suite doit
+réutiliser le ChatHub existant pour la signalisation.
+
+L'essai en échec opposait un téléphone Android 15 arm64 à Chromium,
+en mode TURN uniquement, avec signalisation HTTP locale et TURN/TCP
+accessibles par redirections USB adb. Il n'utilisait ni ChatHub ni
+PostIt.Desktop Linux.
+
+Les observations doivent être distinguées :
+
+- Camera2, la capture audio et un premier rendu EGL local ont démarré.
+ Cela ne valide ni le transport ni le rendu distant.
+- Le processus Android a subi un SIGABRT dans
+ `libjingle_peerconnection_so.so`. Une première pile passait par
+ `PeerConnection.nativeAddIceCandidate` ; après modification du traitement
+ des candidats, un arrĂŞt natif persistait sur `network_thread`.
+- Le test a attendu un échange média qui n'est jamais arrivé. Le dernier
+ rapport Browser indiquait `connection: new`, zéro octet audio/vidéo et
+ aucune paire ICE sélectionnée ; aucun rapport Android n'a validé l'appel.
+- Le problème a été reproduit avec les SDK libwebrtc 150.7871.04 et
+ 144.7559.15. L'attente des descriptions distantes, la résolution du
+ `sdpMid` et l'ajout asynchrone des candidats n'ont pas suffi.
+
+Il s'agit donc d'un **crash natif pendant la tentative d'établissement**,
+pas d'un refus de codec ou d'un échec TURN identifié. Le dernier appel JNI
+visible ne prouve pas la cause du crash. Sans message fatal détaillé ni
+pile native symbolisée, un défaut du code expérimental, de son intégration
+Java/JNI ou de libwebrtc reste à départager. Rien ne démontre une
+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
diff --git a/doc/architecture/notifications.md b/doc/architecture/notifications.md
index 8cf85cfb8..a8024d7f7 100644
--- a/doc/architecture/notifications.md
+++ b/doc/architecture/notifications.md
@@ -20,12 +20,13 @@ clients.
| Annonce persistée | Entité `Notification` en base, API HTTP | Affichée dans le layout et masquable | Liste sur `HomePage`, chargée par HTTP et masquable |
| Message d'interface | Liste de portée requête dans `ViewBag.Notify` | Affichée comme alerte dans le layout | Non consommé |
| Événement de chat | Hub SignalR authentifié à `/chathub` | Le site Web n'en consomme pas dans ses vues MVC | `notifyUser` et `notifyRoom` alimentent les journaux du chat |
-| Événement métier `push` | SignalR vers les connexions actives, plus e-mail | Pas de consommateur identifié dans les vues Web | Pas de gestionnaire `push` dans le client PostIt actuel |
+| Événement métier `push` | SignalR vers les connexions actives, plus e-mail | Pas de consommateur identifié dans les vues Web | Alerte native par le service Android ; liste persistée sur l'accueil via HTTP |
+| Alerte native Android | Connexion SignalR existante | Sans objet | Service de fond facultatif ; notification seulement à réception d'un événement |
Les notifications persistées sont donc différentes d'une notification système
native (notification du navigateur ou du système d'exploitation). Le client
-PostIt affiche une liste dans sa page d'accueil ; il ne demande pas de
-permission de notification native.
+PostIt affiche une liste dans sa page d'accueil. Sur Android, le service de
+messagerie peut aussi afficher des notifications natives, après autorisation.
## 1. Annonces persistées
@@ -173,6 +174,7 @@ Les événements de notification émis par le hub comprennent notamment :
| `notifyRoom` | `type`, salon, utilisateur ou détail | Ajout au journal du salon ; met à jour la liste d'utilisateurs sur `UserJoin` |
| `joint` | `ChatRoomInfo` | Initialise la vue du salon rejoint |
| `ReceiveMessage` | message avec nom, salon et corps | Ajoute le message Ă l'historique du salon |
+| `addPV` | expéditeur, texte privé | Ajoute le message privé au journal système ; alerte native Android en arrière-plan |
| `notifyUserInRoom` | `type`, salon, message | Pas de gestionnaire correspondant dans `ChatViewModel` actuellement |
Les constantes de types du chat sont déclarées dans
@@ -181,23 +183,171 @@ Les messages `notifyUser` et `notifyRoom` ne sont pas enregistrés en base :
ils décrivent l'état temps réel de connexion, de salon ou les erreurs de
conversation.
-Le [`ChatViewModel`](../../src/PostIt/PostIt/ViewModels/Chat/ChatViewModel.cs)
+Le singleton
+[`ChatHubConnection`](../../src/PostIt/PostIt/Services/ChatHubConnection.cs)
ouvre le hub avec le jeton d'accès PostIt, tente un renouvellement silencieux
-du jeton, et active la reconnexion automatique. Après reconnexion, il rejoint
-à nouveau le salon sélectionné, car la connexion SignalR précédente et ses
-groupes ne sont plus actifs. Les callbacks mettent Ă jour les collections sur
-le thread UI d'Avalonia.
+du jeton et active la reconnexion automatique. Il est partagé par le service
+Android, le
+[`ChatViewModel`](../../src/PostIt/PostIt/ViewModels/Chat/ChatViewModel.cs)
+et la signalisation des appels : ouvrir la page ne crée pas une seconde
+connexion.
+
+Le transport conserve en mémoire les 500 dernières livraisons de messages
+privés et de salon pour les présenter si l'interface s'ouvre après le
+démarrage du service. Ce tampon est borné, non persisté sur disque et vidé
+Ă l'arrĂŞt de la connexion ou au changement de compte. Il ne permet pas de
+récupérer les messages envoyés lorsque le socket était déconnecté.
+
+Les salons sont mémorisés localement, par hôte et compte, dans
+`Settings.ChatRoomsByAccount`. Le transport les rejoint à nouveau après une
+reconnexion ou un redémarrage du processus, sans dépendre de l'interface
+Avalonia. « Quitter le salon » supprime cette mémorisation. Cela n'ajoute pas
+d'abonnement serveur hors ligne ni d'historique des messages manqués.
+Les callbacks destinés aux collections de l'interface sont dispatchés sur
+le thread UI et les callbacks obsolètes sont ignorés après déconnexion.
### Événement métier `push`
En plus des événements du chat, `YavscMessageSender` utilise le même contexte
SignalR pour émettre `push` avec le topic et une charge utile sérialisée. Ce
-nom d'événement est distinct de `notifyUser` et `notifyRoom`. Aucun
-gestionnaire `push` n'est présent dans le client PostIt actuel : les annonces
-métier persistées sont visibles dans PostIt lors du prochain chargement ou
-rafraîchissement HTTP.
+nom d'événement est distinct de `notifyUser` et `notifyRoom`. Le service
+Android peut en afficher une alerte native ; les annonces métier persistées
+restent visibles dans PostIt lors du prochain chargement ou rafraîchissement
+HTTP.
-## 5. Points d'attention pour les évolutions
+## 5. Android : connexion SignalR en arrière-plan
+
+### Réglage utilisateur et durée de vie
+
+`AndroidKeepChatConnected`, désactivé par défaut, est éditable dans les
+paramètres Android :
+« Garder la connexion au serveur active et la reprendre au démarrage du
+téléphone ». Enregistrer les paramètres pour appliquer le changement.
+
+Lorsque l'utilisateur clique sur « Sauver » avec cette option activée,
+PostIt vérifie `PowerManager.IsIgnoringBatteryOptimizations` :
+- si l'application n'est pas exemptée, ouvrir
+ `ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` avec l'URI `package:...` ;
+- si elle est déjà exemptée, ne rien ouvrir ni demander.
+
+La permission `REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` est déclarée pour
+cette demande explicite. Android conserve la décision finale ; refuser
+ne désactive ni l'option ni SignalR. Les sauvegardes internes (jetons,
+salons), reconnexions et démarrages du téléphone n'ouvrent pas cet écran.
+Cette demande directe d'exemption est soumise aux règles Google Play
+applicables à l'usage de cette permission ; sa présence ne vaut pas
+approbation pour la publication.
+
+- **Désactivé** : le chat reste connecté pendant la vie du processus PostIt,
+ même si l'activité est masquée, mais rien ne garantit que ce processus
+ survive en arrière-plan. Les messages alimentent le journal ; les alertes
+ natives en arrière-plan nécessitent le service activé.
+- **Activé** : un service Android ordinaire héberge la même connexion
+ SignalR, **sans notification permanente**. Un récepteur
+ `BOOT_COMPLETED` tente de reprendre ce service si l'option et une session
+ enregistrée sont encore disponibles.
+- La fermeture d'une page ou de l'activité ne ferme pas la messagerie.
+ La déconnexion du compte arrête le service et la connexion avant la
+ suppression des jetons. Les appels et captures caméra/micro restent
+ soumis Ă leur propre cycle de vie.
+- Le service peut démarrer sans construire l'interface Avalonia. L'ouverture
+ ultérieure de l'application réutilise le même conteneur et le même
+ transport, sans connexion doublonnée.
+
+Le service n'appelle ni `StartForegroundService` ni `StartForeground` et ne
+publie aucune notification de connexion/reconnexion. Pour l'arrĂŞter,
+désactiver l'option et enregistrer les paramètres, ou déconnecter le compte.
+Les notifications ne sont créées que lors de nouveaux messages ou événements ;
+elles disparaissent à leur ouverture et ne sont pas marquées permanentes.
+Android 13+ demande l'autorisation `POST_NOTIFICATIONS` pour ces alertes
+visibles. Un refus empĂŞche les alertes, **pas la connexion SignalR**.
+Les échecs de démarrage sont signalés, sans basculer silencieusement vers
+un service de premier plan et sans répéter une permission refusée.
+
+### Renouvellement de session
+
+Une maintenance unique par client API démarre avec l'interface et aussi
+avec le service Android démarré sans interface. Elle programme une attente
+à partir de `AccessTokenExpiresAt` (échéance calculée depuis la durée fournie
+par le serveur OIDC, ou le claim JWT `exp`), moins la marge de sécurité de
+60 secondes, indépendamment des appels HTTP et des reconnexions SignalR :
+- pendant l'activité Android visible (sur desktop, pendant l'exécution
+ de l'application), même si « Garder la connexion » est désactivé ;
+- ou avec « Garder la connexion » activé, même si l'activité est masquée.
+
+Le renouvellement utilise le `refresh_token` lorsque l'**access token**
+entre dans sa marge d'expiration de 60 secondes. Les renouvellements
+concurrents partagent le mĂŞme verrou ; les jetons tournants sont
+enregistrés et aucun renouvellement n'est engagé pendant la déconnexion.
+Après chaque renouvellement, l'attente est recalculée avec la nouvelle
+échéance. Connexion, déconnexion, changement d'activité ou de l'option
+réveillent aussi l'ordonnanceur. Sans session ou lorsque les deux conditions
+d'activité sont fausses, il attend un changement, sans contrôle périodique.
+Un échec transitoire est signalé et retenté après 30 secondes ; un rejet
+définitif exige une nouvelle connexion.
+
+Le serveur ne fournit pas ici d'échéance du refresh token au client :
+PostIt n'en invente pas et ne peut pas repousser sa durée de vie absolue.
+La rotation régulière ne garantit pas de prolonger une session révoquée
+ou arrivée à sa limite absolue. Un processus suspendu ou arrêté par Android
+ne peut pas exécuter ce timer ; au retour, le renouvellement reprend si la
+session reste renouvelable.
+
+### Notifications et limites
+
+Le service écoute les messages privés, les messages des salons rejoints et
+l'événement métier SignalR `push`. En arrière-plan, il affiche des alertes
+locales génériques pour ne pas exposer de contenu privé sur l'écran
+verrouillé. Il ne faut pas confondre cet événement SignalR nommé `push` avec
+un service de push externe.
+
+**Aucun Firebase/FCM, serveur Google de notifications, jeton d'appareil,
+configuration de projet ou migration push n'est requis.** Les API métier et
+le ChatHub existants restent les seuls services réseau utilisés pour la
+messagerie.
+
+Cette solution est de type *best effort*, pas une connexion immortelle :
+
+- Android, Doze, l'absence de réseau et les politiques des constructeurs
+ peuvent interrompre le socket ou empêcher le redémarrage du service.
+ Autoriser les données en arrière-plan permet le trafic réseau ; désactiver
+ manuellement l'optimisation de batterie pour PostIt assouplit les limites
+ de Doze. Ces réglages ne garantissent pas la survie du processus ou du
+ service et ne suppriment pas les autres limites d'exécution Android.
+- Android 8+ peut arrĂŞter un service ordinaire lorsque l'application reste
+ en arrière-plan, ou refuser `StartService` depuis le récepteur de démarrage.
+ Dans ce cas, PostIt signale le refus et attend une nouvelle ouverture de
+ l'application ; aucune tentative de contournement par service de premier
+ plan, tâche périodique ou exemption sans consentement n'est ajoutée.
+- Après un arrêt forcé par l'utilisateur, rouvrir PostIt ; le démarrage du
+ téléphone n'est pas un contournement de cet arrêt.
+- Le renouvellement nécessite une session encore valide. Une session
+ révoquée ou sans jeton de renouvellement exige une reconnexion.
+- Les messages de chat sont éphémères : les messages envoyés pendant une
+ interruption ne sont pas récupérés par cette fonctionnalité. Les
+ notifications métier persistées restent accessibles par l'API.
+- Aucun type `specialUse` ni permission `FOREGROUND_SERVICE_SPECIAL_USE`
+ n'est déclaré pour la messagerie. Les services de premier plan des appels
+ et captures caméra/micro restent inchangés : ils ne sont pas utilisés pour
+ maintenir le chat.
+
+### Validation sur téléphone
+
+Les tests locaux vérifient le partage de connexion, la restauration des
+salons et le nettoyage de session. Ils ne remplacent pas une validation
+Android réelle : absence de notification lors de l'activation et des
+reconnexions, notification seulement à réception d'un événement activité
+masquée, retour dans l'interface sans second socket, désactivation dans les
+paramètres, déconnexion/reconnexion, coupure et retour réseau, veille
+prolongée, redémarrage du téléphone et refus de permission sans arrêt du chat.
+
+Une activité de vérification est incluse uniquement dans l'APK Debug :
+`fr.pschneider.postit.ChatServiceTestActivity`. Son résultat est écrit dans
+le fichier privé de l'application `files/chat-service-test-result.txt`.
+Elle vérifie la composition du conteneur partagé, pas la réception réelle
+après un démarrage ou une longue veille.
+
+## 6. Points d'attention pour les évolutions
- Conserver les règles d'audience alignées entre l'API et le site Web ; en
particulier, appliquer un filtrage `Target` côté Web avant d'exposer les
diff --git a/doc/architecture/postit.md b/doc/architecture/postit.md
index 625cc1875..baa2331e8 100644
--- a/doc/architecture/postit.md
+++ b/doc/architecture/postit.md
@@ -12,6 +12,13 @@
## Surface : un code-base, trois front-ends
+Le projet Android active `EmbedAssembliesIntoApk` par défaut, y compris en
+Debug : un APK installé directement doit contenir les assemblies .NET,
+sans dépendre des fichiers de Fast Deployment sous `files/.__override__`.
+Sans elles, le runtime Android abandonne avant de charger l'interface
+avec « No assemblies found ». Le Makefile conserve également ce réglage
+explicite pour ses commandes de compilation.
+
```
┌────────────────────────�
│ PostIt (lib) │
@@ -53,8 +60,52 @@ Le rafraîchissement silencieux de session reste unique par processus.
Cette restauration couvre la recréation d'activité dans le même processus,
pas la destruction du processus par Android.
+## Prévisualisation et orientation des Podcasts
+
+« Prévisualiser la caméra » ouvre un aperçu local avant « Démarrer le
+direct », sans exiger de titre. Cette phase ne crée aucune émission côté
+serveur, n'enregistre aucun segment et n'ouvre pas le microphone. Le choix
+de caméra est verrouillé pendant l'aperçu ; l'arrêter pour changer de caméra.
+Le microphone sélectionné n'est ouvert qu'au démarrage du direct.
+
+« Arrêter la prévisualisation », la sortie de page et la déconnexion libèrent
+la caméra. Le passage au direct ferme d'abord l'aperçu, puis ouvre la capture
+avec les périphériques sélectionnés : les images d'essai ne sont pas publiées.
+Sous Android, un aperçu seul s'arrête aussi au passage en arrière-plan,
+sans lancer de service de capture ni de notification de direct.
+Les Podcasts en direct conservent leur service caméra/microphone existant.
+
+Le chemin Android partage le rendu Camera2/EGL entre aperçu seul et encodage.
+L'arrêt de l'aperçu détache ses callbacks via le `SurfaceHolder` conservé,
+avant la destruction différée du contrôle natif ; le nettoyage ne relit pas
+la propriété `Holder` d'une `SurfaceView` dont le wrapper Java peut être libéré.
+La rotation physique utilise l'orientation du capteur, la caméra avant/arrière
+et la rotation de l'écran. Camera2 peut déjà inclure la rotation du capteur
+dans la matrice `SurfaceTexture`, ainsi qu'un miroir pour la caméra avant :
+seule la rotation restante est appliquée, dans le sens inverse si la matrice
+contient un miroir, afin de ne pas tourner l'image deux fois.
+Un changement de rotation d'écran recalcule ce rendu pendant la capture.
+L'aperçu conserve les proportions ; les dimensions encodées restent celles
+du démarrage du direct, avec des bandes noires si la nouvelle orientation
+l'exige, pour ne pas modifier le format HLS/SRTP en cours d'émission.
+
+Les tests partagés couvrent l'aperçu sans appel API, le passage au direct,
+les arrêts et une sortie de page pendant l'ouverture de caméra. L'activité
+Debug `CameraFrameRotationTestActivity` vérifie les quatre rotations avec
+encodage, puis l'aperçu sans encodeur et ses changements de rotation.
+Une validation physique caméra avant/arrière en portrait et paysage reste
+nécessaire : les tests synthétiques ne vérifient pas le comportement du HAL
+de chaque téléphone.
+
## Administration et profil personnel
+Le quota disque renvoyé par le profil est le quota effectif : Découverte donne
+deux fois et Premium cinq fois le quota gratuit standard durant la mensualité confirmée payée,
+y compris après résiliation jusqu'à son échéance UTC. Ensuite, ou après
+remboursement, le quota habituel reprend sans suppression des fichiers.
+Les téléversements dépassant l'espace disponible sont refusés avant écriture.
+La taille maximale par fichier et les quotas podcast restent inchangés.
+
L'accueil présente un seul accès **Administration**, visible et exécutable
uniquement pour le rĂ´le exact `Administrator`. `SessionStatusViewModel.RefreshAsync`
lit les rôles dans `GET account/me` après le rafraîchissement de session ;
@@ -75,6 +126,37 @@ indépendamment de la visibilité du bouton dans PostIt.
endpoints `account/me` pour lire et enregistrer les informations personnelles.
Elle affiche aussi `resource-usage/me`, sans appeler la liste des usages
globaux. Une indisponibilité de l'usage n'empêche pas la gestion du profil.
+La consommation est chargée avant le profil, pour rester consultable même
+si une opération de gestion reçoit un refus de quota. L'administration
+charge également les usages avant ses autres outils et les conserve sur
+un refus HTTP 429, tant que le rôle administrateur est toujours présent.
+
+L'indicateur est exprimé en points selon les coefficients effectifs du
+backend, présentés dans les CGU. Le stockage correspond aux volumes
+instrumentés ajoutés, moins les volumes individuellement suivis supprimés
+ou remplacés. Les anciens fichiers sans suivi ne sont pas remboursés.
+La suppression reste disponible au seuil ; CPU, appels API et transferts
+ne sont pas remboursés. Les renommages conservent le suivi individuel.
+Le profil et les vues d'administration affichent le seuil effectif, le
+solde et l'atteinte du quota, indépendamment de l'estimation financière.
+La section serveur `ResourceUsage` configure les coefficients et les
+seuils individuels ; voir [INSTALL.md](../../INSTALL.md#resource-consumption-and-cgu).
+Le contrôle admet les coûts connus puis constate les coûts restants :
+il bloque les opérations suivantes, sans interrompre strictement celles
+déjà en cours.
+
+La page **À propos** ouvre les CGU dédiées de PostIt et de Yavsc sur
+`Home/CGU` auprès de l'autorité configurée, y compris sans session.
+Cette page publique présente les coefficients réellement configurés,
+la période cumulée, le seuil et les limites de la mesure.
+**Mon profil** et **Ă€ propos** proposent aussi un lien vers
+`ResourceSubscription` sur cette même autorité. La souscription mensuelle
+et la résiliation PayPal utilisent la session Web et des formulaires
+antiforgery ; PostIt ne stocke ni identifiant marchand ni secret PayPal.
+Le profil affiche la consommation brute, l'usage effacé et le crédit
+reporté, en plus de l'indicateur net. Les crédits Découverte/Premium ne
+suppriment pas les compteurs : les paiements confirmés sont rapprochés
+par Yavsc.Org et leur déduction est appliquée aussi au quota API/Blogs.
### Outils d'administration du site
@@ -339,7 +421,8 @@ de modifier cette répartition. La liste et l'article défilent séparément.
Lorsque la largeur de la fenêtre atteint ou dépasse sa hauteur, le lecteur
ou l'éditeur passe à gauche (deux tiers de la largeur par défaut), et
-l'en-tĂŞte, la recherche, les commandes et la liste passent Ă droite.
+l'en-tĂŞte, la recherche et la liste passent Ă droite ; les commandes
+restent dans la barre de navigation.
Le séparateur devient vertical. En portrait, la disposition verticale
revient sans recréer les contrôles ni perdre le brouillon.
Le seuil utilise les dimensions clientes de la fenêtre, indépendamment
@@ -358,6 +441,41 @@ dépasser le viewport pour que les barres automatiques s'activent.
Ne pas placer cette grille dans un `StackPanel` vertical ou un
`ScrollViewer` de page, qui lui donnerait une hauteur de mesure illimitée.
+Après un redimensionnement de la zone de texte (notamment à l'ouverture du
+clavier Android avec `AdjustResize`), l'éditeur remet le curseur dans son
+viewport après la mise en page, uniquement s'il garde le focus. Un toucher
+dans la zone éditable demande aussi le clavier via le pont natif Android,
+sans retirer puis redonner le focus ni modifier la sélection. Les autres
+plateformes conservent leur gestion habituelle du clavier.
+
+`MainView` compose les marges de `TopLevel.InsetsManager` (barres système
+et découpes) avec le recouvrement réel indiqué par `TopLevel.InputPane`,
+car le clavier ne redimensionne pas toujours la fenĂŞtre Android en mode
+edge-to-edge. Si `AdjustResize` a déjà réduit la fenêtre, cette réserve
+ne soustrait pas une seconde fois la hauteur du clavier. La racine gère
+explicitement ces marges et désactive `TopLevel.AutoSafeAreaPadding` pour
+éviter deux propriétaires du même padding. Ne pas remplacer les marges
+système par un padding contenant uniquement la hauteur du clavier.
+En disposition large, tant que le clavier est ouvert et que l'article
+garde le focus, son titre et ses pièces jointes passent dans
+une colonne à côté du texte. La barre de commandes, la bannière de session
+et le statut restent visibles. La disposition habituelle revient Ă la
+fermeture du clavier ou au changement de focus, sans recréer le brouillon.
+Sous Android uniquement, le champ du titre est masqué pendant la saisie
+compacte avec le clavier ouvert, en portrait comme en paysage ; il réapparaît à la fermeture du clavier
+ou quand le focus quitte l'article. Sa valeur n'est jamais effacée.
+
+En Debug Android, `fr.pschneider.postit.MarkdownEditorTestActivity` ouvre
+un billet synthétique local, vérifie au moins trois lignes visibles et
+le bas de l'éditeur au-dessus des insets natifs du clavier et les contrôles
+en dehors des barres système,
+ferme puis rouvre le clavier par toucher sans perte de focus. Le résultat
+est écrit dans `files/markdown-editor-test-result.txt`. Ce test nécessite
+Android 11 ou plus pour vérifier les insets du clavier ; il ne publie
+aucun billet et retire sa page Ă la fin.
+L'extra booléen `landscape=true` force le paysage pendant le test et restaure
+l'orientation demandée précédemment à la fin.
+
## Navigation
Le host de navigation est un `NavigationPage x:Name="NavRoot"`
diff --git a/doc/testing.md b/doc/testing.md
index 7b5de174f..7a8d1eba2 100644
--- a/doc/testing.md
+++ b/doc/testing.md
@@ -78,24 +78,62 @@ pour éviter de monter un host complet.
Avec le runner Microsoft.Testing.Platform du depot (.NET 10, xUnit v3) :
```bash
+dotnet test --project src/test/Yavsc.Org.Tests/Yavsc.Org.Tests.csproj \
+ --filter-class '*PodcastWebTests' --filter-class '*PerformerDonationTests'
dotnet test --project src/test/Yavsc.Api.Tests/Yavsc.Api.Tests.csproj \
- --filter-class '*LiveProcessorTests' --filter-class '*PodcastControllerTests'
+ --filter-class '*LiveProcessorTests' --filter-class '*PodcastControllerTests' \
+ --filter-class '*PodcastReplayTests' --filter-class '*PodcastScheduleTests' \
+ --filter-class '*PerformerDonationSettingsTests'
dotnet test --project src/PostIt/PostIt.Tests/PostIt.Tests.csproj \
- --filter-class '*PodcastTests' --filter-class '*PodcastNativeCaptureTests'
+ --filter-class '*PodcastTests' --filter-class '*PodcastReplayTests' \
+ --filter-class '*YavscApiClientTests' --filter-class '*PodcastNativeCaptureTests' \
+ --filter-class '*PerformerDonationSettingsTests'
+dotnet test --project src/PostIt/PostIt.Tests/PostIt.Tests.csproj \
+ --filter-method '*Shared_page_exposes_running_capture_preview_and_clears_it_before_disposal'
+dotnet test --project src/PostIt/PostIt.Tests/PostIt.Tests.csproj \
+ --filter-class '*PodcastScheduleTests'
```
Les tests serveur couvrent HTTP/authentification, proprietaire, sequences,
reprises idempotentes, limites exactes, concurrence et persistance des replays
apres interruption/redemarrage, dans des dossiers temporaires isoles.
+Les tests de configuration PayPal couvrent la lecture privee, la creation,
+la validation avant toute sauvegarde, l'effacement, la compatibilite des anciens
+clients, ainsi que le chargement, la liaison du champ et l'enregistrement PostIt.
+Les tests `PodcastScheduleTests` couvrent la preparation persistante dans
+`LiveFlow`, la confidentialite, l'annonce/unpublication, les controles
+proprietaire, la validation et le demarrage manuel idempotent.
+La preparation PostIt et les tests de capture headless ont ete verifies
+separement : leur selection groupee peut rester bloquee alors que chaque
+test cible reussit isole.
+Installer FFmpeg 5+ et ffprobe pour ces tests serveur : ils generent une
+source H.264/AAC synthetique de quatre secondes, verifient le remuxage reel
+(pistes, duree, faststart, decodage et seek a deux secondes), puis les reponses
+HTTP authentifiees GET/HEAD/206/416 du worker. Aucune camera ni microphone
+n'est utilise. Les tests client couvrent les plages exactes et bornees,
+les seeks avant/arriere/EOF, l'annulation, le renouvellement des jetons
+et le seuil exact d'auto-hide de trois secondes.
+Pour tester aussi le decodage MP4 et les seeks avant/arriere dans LibVLC,
+definir `POSTIT_TEST_REPLAY` sur un MP4 H.264/AAC local de 8 a 30 secondes
+(LibVLC installe sur la machine de test). Le test natif est ignore sinon.
+Verifier manuellement les overlays sur Desktop et Android : pause/reprise,
+glissement de la barre, masquage apres trois secondes, reapparition au
+toucher/survol et nettoyage apres navigation ou mise en arriere-plan.
Les tests natifs sont explicitement ignores sans `POSTIT_TEST_MEDIA`.
Pour les activer, installer LibVLC avec ses encodeurs H.264/AAC et definir
cette variable sur un fichier video local d'environ huit secondes contenant
une piste audio. Ils exercent la segmentation LibVLC reelle, l'envoi et la
reprise apres acquittement perdu, le dernier segment apres arret et le
-decodage authentifie du replay. Aucun FFmpeg n'est requis par ces tests ni
-par l'application (le fichier d'entree peut provenir de n'importe quelle source).
+decodage authentifie du replay MPEG-TS. FFmpeg n'est pas une dependance
+d'execution de PostIt (le serveur MP4, lui, en a besoin).
Les tests materiels camera/microphone Windows/Linux restent manuels.
+Les deux variantes du test d'encodage HLS (avec/sans apercu) necessitent
+egalement `ffprobe` pour verifier independamment les pistes H.264 et AAC
+du premier segment. La variante avec apercu attend une image decodee
+par LibVLC dans un tampon memoire, sans ouvrir de camera ni diffuser le son
+sur les haut-parleurs. Le test de page headless verifie aussi le binding
+du controle d'apercu et son retrait avant liberation de la capture.
### Rotation de la capture Android
@@ -118,10 +156,20 @@ adb shell am start -n fr.pschneider.postit/fr.pschneider.postit.CameraFrameRotat
adb shell run-as fr.pschneider.postit cat files/camera-rotation-test-result.txt
```
+Pour un telephone ARM64, ajouter `-r android-arm64` au build et installer
+l'APK de `bin/Debug/net10.0-android/android-arm64/`. Le projet transmet ce RID
+aux targets natives LibVLC : l'APK doit contenir `libvlc.so` et
+`libc++_shared.so`. Utiliser `adb -s ` si plusieurs appareils sont
+connectes. Laisser l'appareil deverrouille et les tests au premier plan ;
+ne lancer le test suivant qu'apres `PASS` ou `FAIL`.
+
Attendre la fin du test : `RUNNING` doit devenir `PASS`. Il encode quatre
quadrants colores en MPEG-TS pour 0, 90, 180 et 270 degres, decode une image et
verifie les dimensions (640x480 ou 480x640) et les couleurs aux quatre positions.
La tolerance de chaque composante RGB est de 40 pour tenir compte de H.264.
+Il verifie aussi les couleurs RGBA de l'apercu OpenGL (tolerance 5), les
+bandes noires sans deformation et le detachement/rattachement de sa surface
+pendant l'encodage, toujours pour les quatre rotations.
Une erreur de rendu, d'encodage, de decodage ou de comparaison produit `FAIL`
avec l'exception. Cette activite est exclue des builds Release.
@@ -134,6 +182,17 @@ adb shell am start -n fr.pschneider.postit/fr.pschneider.postit.PodcastCaptureTe
adb shell run-as fr.pschneider.postit cat files/podcast-capture-test-result.txt
```
+Pour verifier la transition apercu vers diffusion sans contacter le serveur :
+
+```bash
+adb shell am start -S -n fr.pschneider.postit/fr.pschneider.postit.PodcastCaptureTestActivity --es microphone false --es previewTransition true
+```
+
+Cette variante affiche puis retire deux apercus natifs avant la capture :
+nettoyage normal, puis nettoyage apres liberation du wrapper Java de la vue.
+Elle attend la destruction differee Avalonia et verifie que la capture suivante
+produit toujours des segments. Le resultat doit inclure `previewTransition=True`.
+
Attendre `PASS` : au moins trois segments, 8 a 16 secondes capturees,
pistes H.264 et AAC presentes, et progression des segments en arriere-plan.
Ce test detecte notamment les captures de zero seconde dues au decalage entre
@@ -143,13 +202,36 @@ Le resultat inclut les angles capteur/ecran et la premiere matrice
SurfaceTexture recue. Les tests unitaires couvrent notamment la matrice
reelle `[0,-1,0,0,-1,0,0,0,0,0,1,0,1,1,0,1]` : pour un capteur a 90 degres
et un ecran a 0, elle porte deja la rotation et ne doit pas recevoir 90 degres
-supplementaires. Le test synthetique seul ne detecte pas cette double rotation.
+supplementaires. La camera avant mesuree
+`[0,-1,0,0,1,0,0,0,0,0,1,0,0,1,0,1]` (capteur a 270 degres) contient en plus
+un miroir : la rotation restante y est appliquee dans le sens inverse.
+Le test synthetique seul ne detecte pas cette double rotation.
Verifier aussi manuellement les cameras avant/arriere en portrait et paysage,
le son, le direct et le replay, et la poursuite de l'emission en arriere-plan.
L'orientation est fixee au demarrage d'une emission ; tourner le telephone
pendant l'emission ne reconfigure pas le format encode.
+### Anti-veille Android
+
+`ScreenAwakeRequestsTests`, `PodcastPreferencesTests` et les regressions
+d'apercu de `PodcastBroadcasterTests` couvrent les demandes independantes,
+leur liberation, le changement d'option pendant la capture et sa persistance.
+Le test natif Debug utilise une video MP4 H.264 locale synthetique, sans API,
+camera ni microphone :
+
+```bash
+adb push /chemin/video-test.mp4 /data/local/tmp/postit-screen-awake-fixture.mp4
+adb shell run-as fr.pschneider.postit cp /data/local/tmp/postit-screen-awake-fixture.mp4 files/screen-awake-fixture.mp4
+adb shell am start -n fr.pschneider.postit/fr.pschneider.postit.ScreenAwakeTestActivity
+adb shell run-as fr.pschneider.postit cat files/screen-awake-test-result.txt
+```
+
+Attendre `PASS` : lecture, pause/reprise, arret, fin, destruction de la surface,
+demandes simultanees, arriere-plan et retour au premier plan sont verifies
+sur le drapeau Android `KeepScreenOn`. Les changements de page et le retour
+temporaire a l'accueil pendant ce test sont automatiques.
+
## Quand ne PAS écrire de test
Un test qui ne détecte rien n'est pas un test. Si l'invariant
diff --git a/dotnet-tools.json b/dotnet-tools.json
index 1762a89de..037b83194 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -8,6 +8,20 @@
"picket"
],
"rollForward": false
+ },
+ "gitversion.tool": {
+ "version": "6.8.2",
+ "commands": [
+ "dotnet-gitversion"
+ ],
+ "rollForward": false
+ },
+ "dotnet-ef": {
+ "version": "10.0.13",
+ "commands": [
+ "dotnet-ef"
+ ],
+ "rollForward": false
}
}
}
\ No newline at end of file
diff --git a/esbuild.config.mjs b/esbuild.config.mjs
index 7884f601d..4f3edf355 100644
--- a/esbuild.config.mjs
+++ b/esbuild.config.mjs
@@ -48,6 +48,10 @@ const bundleNames = [
// of bootstrap, jquery-ui, etc., which are NOT touched by this
// toolchain).
const staticAssets = [
+ {
+ src: 'node_modules/hls.js/dist/hls.light.min.js',
+ dst: 'hls.light.min.js',
+ },
{
src: 'node_modules/@aspnet/signalr/dist/browser/signalr.min.js',
dst: 'signalr.min.js',
diff --git a/package.json b/package.json
index e419cd0ca..c8d376253 100644
--- a/package.json
+++ b/package.json
@@ -5,6 +5,7 @@
"description": "Yavsc front-end toolchain (esbuild bundles for Yavsc.Org).",
"scripts": {
"build:js": "node esbuild.config.mjs",
+ "build:podcasts": "node -e \"require('node:fs').copyFileSync('node_modules/hls.js/dist/hls.light.min.js', 'src/Yavsc.Org/wwwroot/js/hls.light.min.js')\"",
"build:js:watch": "node esbuild.config.mjs --watch",
"clean:js": "node esbuild.config.mjs --clean"
},
@@ -13,6 +14,7 @@
"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",
diff --git a/src/PostIt/Directory.Packages.props b/src/PostIt/Directory.Packages.props
index ae6708992..b1be58760 100644
--- a/src/PostIt/Directory.Packages.props
+++ b/src/PostIt/Directory.Packages.props
@@ -39,5 +39,6 @@
+
diff --git a/src/PostIt/PostIt.Android/Assets/PodcastBackground/LICENSE b/src/PostIt/PostIt.Android/Assets/PodcastBackground/LICENSE
new file mode 100644
index 000000000..94255ff45
--- /dev/null
+++ b/src/PostIt/PostIt.Android/Assets/PodcastBackground/LICENSE
@@ -0,0 +1,203 @@
+Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
\ No newline at end of file
diff --git a/src/PostIt/PostIt.Android/Assets/PodcastBackground/pphumanseg.onnx b/src/PostIt/PostIt.Android/Assets/PodcastBackground/pphumanseg.onnx
new file mode 100644
index 000000000..f0ebfc9fc
--- /dev/null
+++ b/src/PostIt/PostIt.Android/Assets/PodcastBackground/pphumanseg.onnx
@@ -0,0 +1,22323 @@
+:Ő›ř
+–
+x
+810
+812conv2d_73.tmp_0
+p2o.Conv.0"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_73.tmp_0relu_0.tmp_0
+p2o.Relu.0"Relu
+ˇ
+relu_0.tmp_0
+814
+816conv2d_74.tmp_0
+p2o.Conv.1"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_74.tmp_0relu_1.tmp_0
+p2o.Relu.1"Relu
+ˇ
+relu_1.tmp_0
+818
+820conv2d_75.tmp_0
+p2o.Conv.2"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_75.tmp_0relu_2.tmp_0
+p2o.Relu.2"Relu
+ˇ
+relu_2.tmp_0
+822
+824conv2d_76.tmp_0
+p2o.Conv.3"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_76.tmp_0relu_3.tmp_0
+p2o.Relu.3"Relu
+ˇ
+relu_3.tmp_0
+826
+828conv2d_77.tmp_0
+p2o.Conv.4"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+ˇ
+relu_1.tmp_0
+830
+832conv2d_78.tmp_0
+p2o.Conv.5"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+=
+conv2d_77.tmp_0
+conv2d_78.tmp_0 p2o.Add.1 p2o.Add.0"Add
++
+ p2o.Add.1relu_4.tmp_0
+p2o.Relu.4"Relu
+ˇ
+relu_4.tmp_0
+834
+836conv2d_79.tmp_0
+p2o.Conv.6"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_79.tmp_0relu_5.tmp_0
+p2o.Relu.5"Relu
+ˇ
+relu_4.tmp_0
+838
+840conv2d_80.tmp_0
+p2o.Conv.7"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_80.tmp_0relu_6.tmp_0
+p2o.Relu.6"Relu
+ˇ
+relu_5.tmp_0
+842
+844conv2d_81.tmp_0
+p2o.Conv.8"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_81.tmp_0relu_7.tmp_0
+p2o.Relu.7"Relu
+ˇ
+relu_7.tmp_0
+846
+848conv2d_82.tmp_0
+p2o.Conv.9"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+:
+conv2d_82.tmp_0
+relu_5.tmp_0 p2o.Add.3 p2o.Add.2"Add
++
+ p2o.Add.3relu_8.tmp_0
+p2o.Relu.8"Relu
+˘
+relu_8.tmp_0
+850
+852conv2d_83.tmp_0p2o.Conv.10"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+1
+conv2d_83.tmp_0relu_9.tmp_0
+p2o.Relu.9"Relu
+˘
+relu_9.tmp_0
+854
+856conv2d_84.tmp_0p2o.Conv.11"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+:
+conv2d_84.tmp_0
+relu_8.tmp_0 p2o.Add.5 p2o.Add.4"Add
+-
+ p2o.Add.5
relu_10.tmp_0p2o.Relu.10"Relu
+˘
+relu_6.tmp_0
+858
+860conv2d_85.tmp_0p2o.Conv.12"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+3
+conv2d_85.tmp_0
relu_11.tmp_0p2o.Relu.11"Relu
+Ł
+
relu_11.tmp_0
+862
+864conv2d_86.tmp_0p2o.Conv.13"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+:
+conv2d_86.tmp_0
+relu_6.tmp_0 p2o.Add.7 p2o.Add.6"Add
+-
+ p2o.Add.7
relu_12.tmp_0p2o.Relu.12"Relu
+Ł
+
relu_12.tmp_0
+866
+868conv2d_87.tmp_0p2o.Conv.14"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+3
+conv2d_87.tmp_0
relu_13.tmp_0p2o.Relu.13"Relu
+Ł
+
relu_13.tmp_0
+870
+872conv2d_88.tmp_0p2o.Conv.15"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+;
+conv2d_88.tmp_0
+
relu_12.tmp_0 p2o.Add.9 p2o.Add.8"Add
+-
+ p2o.Add.9
relu_14.tmp_0p2o.Relu.14"Relu
+Ł
+
relu_14.tmp_0
+874
+876conv2d_89.tmp_0p2o.Conv.16"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ę
+conv2d_89.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.0bilinear_interp_v2_0.tmp_0p2o.Resize.0"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+H
+
relu_10.tmp_0
+bilinear_interp_v2_0.tmp_0
+p2o.Add.11
+p2o.Add.10"Add
+.
+
+p2o.Add.11
relu_15.tmp_0p2o.Relu.15"Relu
+Ł
+
relu_10.tmp_0
+878
+880conv2d_90.tmp_0p2o.Conv.17"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+=
+
relu_14.tmp_0
+conv2d_90.tmp_0
+p2o.Add.13
+p2o.Add.12"Add
+.
+
+p2o.Add.13
relu_16.tmp_0p2o.Relu.16"Relu
+Ł
+
relu_16.tmp_0
+882
+884conv2d_91.tmp_0p2o.Conv.18"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+3
+conv2d_91.tmp_0
relu_17.tmp_0p2o.Relu.17"Relu
+Ł
+
relu_15.tmp_0
+886
+888conv2d_92.tmp_0p2o.Conv.19"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+3
+conv2d_92.tmp_0
relu_18.tmp_0p2o.Relu.18"Relu
+Ł
+
relu_18.tmp_0
+890
+892conv2d_93.tmp_0p2o.Conv.20"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+=
+conv2d_93.tmp_0
+
relu_15.tmp_0
+p2o.Add.15
+p2o.Add.14"Add
+.
+
+p2o.Add.15
relu_19.tmp_0p2o.Relu.19"Relu
+Ł
+
relu_19.tmp_0
+894
+896conv2d_94.tmp_0p2o.Conv.21"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+3
+conv2d_94.tmp_0
relu_20.tmp_0p2o.Relu.20"Relu
+Ł
+
relu_20.tmp_0
+898
+900conv2d_95.tmp_0p2o.Conv.22"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+=
+conv2d_95.tmp_0
+
relu_19.tmp_0
+p2o.Add.17
+p2o.Add.16"Add
+.
+
+p2o.Add.17
relu_21.tmp_0p2o.Relu.21"Relu
+Ł
+
relu_16.tmp_0
+902
+904conv2d_96.tmp_0p2o.Conv.23"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+3
+conv2d_96.tmp_0
relu_22.tmp_0p2o.Relu.22"Relu
+Ł
+
relu_22.tmp_0
+906
+908conv2d_97.tmp_0p2o.Conv.24"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+=
+conv2d_97.tmp_0
+
relu_16.tmp_0
+p2o.Add.19
+p2o.Add.18"Add
+.
+
+p2o.Add.19
relu_23.tmp_0p2o.Relu.23"Relu
+Ł
+
relu_23.tmp_0
+910
+912conv2d_98.tmp_0p2o.Conv.25"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+3
+conv2d_98.tmp_0
relu_24.tmp_0p2o.Relu.24"Relu
+Ł
+
relu_24.tmp_0
+914
+916conv2d_99.tmp_0p2o.Conv.26"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+=
+conv2d_99.tmp_0
+
relu_23.tmp_0
+p2o.Add.21
+p2o.Add.20"Add
+.
+
+p2o.Add.21
relu_25.tmp_0p2o.Relu.25"Relu
+¤
+
relu_17.tmp_0
+918
+920conv2d_100.tmp_0p2o.Conv.27"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_100.tmp_0
relu_26.tmp_0p2o.Relu.26"Relu
+¤
+
relu_26.tmp_0
+922
+924conv2d_101.tmp_0p2o.Conv.28"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_101.tmp_0
+
relu_17.tmp_0
+p2o.Add.23
+p2o.Add.22"Add
+.
+
+p2o.Add.23
relu_27.tmp_0p2o.Relu.27"Relu
+¤
+
relu_27.tmp_0
+926
+928conv2d_102.tmp_0p2o.Conv.29"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_102.tmp_0
relu_28.tmp_0p2o.Relu.28"Relu
+¤
+
relu_28.tmp_0
+930
+932conv2d_103.tmp_0p2o.Conv.30"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_103.tmp_0
+
relu_27.tmp_0
+p2o.Add.25
+p2o.Add.24"Add
+.
+
+p2o.Add.25
relu_29.tmp_0p2o.Relu.29"Relu
+¤
+
relu_25.tmp_0
+934
+936conv2d_104.tmp_0p2o.Conv.31"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_104.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.0bilinear_interp_v2_1.tmp_0p2o.Resize.1"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+H
+
relu_21.tmp_0
+bilinear_interp_v2_1.tmp_0
+p2o.Add.27
+p2o.Add.26"Add
+¤
+
relu_29.tmp_0
+938
+940conv2d_105.tmp_0p2o.Conv.32"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_105.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.0bilinear_interp_v2_2.tmp_0p2o.Resize.2"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+E
+
+p2o.Add.27
+bilinear_interp_v2_2.tmp_0
+p2o.Add.29
+p2o.Add.28"Add
+.
+
+p2o.Add.29
relu_30.tmp_0p2o.Relu.30"Relu
+¤
+
relu_21.tmp_0
+942
+944conv2d_106.tmp_0p2o.Conv.33"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+
relu_25.tmp_0
+conv2d_106.tmp_0
+p2o.Add.31
+p2o.Add.30"Add
+¤
+
relu_29.tmp_0
+946
+948conv2d_107.tmp_0p2o.Conv.34"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_107.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.3bilinear_interp_v2_3.tmp_0p2o.Resize.3"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+E
+
+p2o.Add.31
+bilinear_interp_v2_3.tmp_0
+p2o.Add.33
+p2o.Add.32"Add
+.
+
+p2o.Add.33
relu_31.tmp_0p2o.Relu.31"Relu
+¤
+
relu_21.tmp_0
+950
+952conv2d_108.tmp_0p2o.Conv.35"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_108.tmp_0
relu_32.tmp_0p2o.Relu.32"Relu
+¤
+
relu_32.tmp_0
+954
+956conv2d_109.tmp_0p2o.Conv.36"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+
relu_29.tmp_0
+conv2d_109.tmp_0
+p2o.Add.35
+p2o.Add.34"Add
+¤
+
relu_25.tmp_0
+958
+960conv2d_110.tmp_0p2o.Conv.37"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+;
+
+p2o.Add.35
+conv2d_110.tmp_0
+p2o.Add.37
+p2o.Add.36"Add
+.
+
+p2o.Add.37
relu_33.tmp_0p2o.Relu.33"Relu
+¤
+
relu_33.tmp_0
+962
+964conv2d_111.tmp_0p2o.Conv.38"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_111.tmp_0
relu_34.tmp_0p2o.Relu.34"Relu
+¤
+
relu_30.tmp_0
+966
+968conv2d_112.tmp_0p2o.Conv.39"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_112.tmp_0
relu_35.tmp_0p2o.Relu.35"Relu
+¤
+
relu_35.tmp_0
+970
+972conv2d_113.tmp_0p2o.Conv.40"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_113.tmp_0
+
relu_30.tmp_0
+p2o.Add.39
+p2o.Add.38"Add
+.
+
+p2o.Add.39
relu_36.tmp_0p2o.Relu.36"Relu
+¤
+
relu_36.tmp_0
+974
+976conv2d_114.tmp_0p2o.Conv.41"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_114.tmp_0
relu_37.tmp_0p2o.Relu.37"Relu
+¤
+
relu_37.tmp_0
+978
+980conv2d_115.tmp_0p2o.Conv.42"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_115.tmp_0
+
relu_36.tmp_0
+p2o.Add.41
+p2o.Add.40"Add
+.
+
+p2o.Add.41
relu_38.tmp_0p2o.Relu.38"Relu
+¤
+
relu_31.tmp_0
+982
+984conv2d_116.tmp_0p2o.Conv.43"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_116.tmp_0
relu_39.tmp_0p2o.Relu.39"Relu
+¤
+
relu_39.tmp_0
+986
+988conv2d_117.tmp_0p2o.Conv.44"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_117.tmp_0
+
relu_31.tmp_0
+p2o.Add.43
+p2o.Add.42"Add
+.
+
+p2o.Add.43
relu_40.tmp_0p2o.Relu.40"Relu
+¤
+
relu_40.tmp_0
+990
+992conv2d_118.tmp_0p2o.Conv.45"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_118.tmp_0
relu_41.tmp_0p2o.Relu.41"Relu
+¤
+
relu_41.tmp_0
+994
+996conv2d_119.tmp_0p2o.Conv.46"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_119.tmp_0
+
relu_40.tmp_0
+p2o.Add.45
+p2o.Add.44"Add
+.
+
+p2o.Add.45
relu_42.tmp_0p2o.Relu.42"Relu
+Ą
+
relu_33.tmp_0
+998
+1000conv2d_120.tmp_0p2o.Conv.47"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_120.tmp_0
relu_43.tmp_0p2o.Relu.43"Relu
+¦
+
relu_43.tmp_0
+1002
+1004conv2d_121.tmp_0p2o.Conv.48"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_121.tmp_0
+
relu_33.tmp_0
+p2o.Add.47
+p2o.Add.46"Add
+.
+
+p2o.Add.47
relu_44.tmp_0p2o.Relu.44"Relu
+¦
+
relu_44.tmp_0
+1006
+1008conv2d_122.tmp_0p2o.Conv.49"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_122.tmp_0
relu_45.tmp_0p2o.Relu.45"Relu
+¦
+
relu_45.tmp_0
+1010
+1012conv2d_123.tmp_0p2o.Conv.50"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_123.tmp_0
+
relu_44.tmp_0
+p2o.Add.49
+p2o.Add.48"Add
+.
+
+p2o.Add.49
relu_46.tmp_0p2o.Relu.46"Relu
+¦
+
relu_34.tmp_0
+1014
+1016conv2d_124.tmp_0p2o.Conv.51"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_124.tmp_0
relu_47.tmp_0p2o.Relu.47"Relu
+¦
+
relu_47.tmp_0
+1018
+1020conv2d_125.tmp_0p2o.Conv.52"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_125.tmp_0
+
relu_34.tmp_0
+p2o.Add.51
+p2o.Add.50"Add
+.
+
+p2o.Add.51
relu_48.tmp_0p2o.Relu.48"Relu
+¦
+
relu_48.tmp_0
+1022
+1024conv2d_126.tmp_0p2o.Conv.53"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_126.tmp_0
relu_49.tmp_0p2o.Relu.49"Relu
+¦
+
relu_49.tmp_0
+1026
+1028conv2d_127.tmp_0p2o.Conv.54"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+conv2d_127.tmp_0
+
relu_48.tmp_0
+p2o.Add.53
+p2o.Add.52"Add
+.
+
+p2o.Add.53
relu_50.tmp_0p2o.Relu.50"Relu
+¦
+
relu_42.tmp_0
+1030
+1032conv2d_128.tmp_0p2o.Conv.55"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_128.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.0bilinear_interp_v2_4.tmp_0p2o.Resize.4"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+H
+
relu_38.tmp_0
+bilinear_interp_v2_4.tmp_0
+p2o.Add.55
+p2o.Add.54"Add
+¦
+
relu_46.tmp_0
+1034
+1036conv2d_129.tmp_0p2o.Conv.56"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_129.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.0bilinear_interp_v2_5.tmp_0p2o.Resize.5"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+E
+
+p2o.Add.55
+bilinear_interp_v2_5.tmp_0
+p2o.Add.57
+p2o.Add.56"Add
+¦
+
relu_50.tmp_0
+1038
+1040conv2d_130.tmp_0p2o.Conv.57"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_130.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.0bilinear_interp_v2_6.tmp_0p2o.Resize.6"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+E
+
+p2o.Add.57
+bilinear_interp_v2_6.tmp_0
+p2o.Add.59
+p2o.Add.58"Add
+.
+
+p2o.Add.59
relu_51.tmp_0p2o.Relu.51"Relu
+¦
+
relu_38.tmp_0
+1042
+1044conv2d_131.tmp_0p2o.Conv.58"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+
relu_42.tmp_0
+conv2d_131.tmp_0
+p2o.Add.61
+p2o.Add.60"Add
+¦
+
relu_46.tmp_0
+1046
+1048conv2d_132.tmp_0p2o.Conv.59"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_132.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.3bilinear_interp_v2_7.tmp_0p2o.Resize.7"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+E
+
+p2o.Add.61
+bilinear_interp_v2_7.tmp_0
+p2o.Add.63
+p2o.Add.62"Add
+¦
+
relu_50.tmp_0
+1050
+1052conv2d_133.tmp_0p2o.Conv.60"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_133.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.3bilinear_interp_v2_8.tmp_0p2o.Resize.8"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+E
+
+p2o.Add.63
+bilinear_interp_v2_8.tmp_0
+p2o.Add.65
+p2o.Add.64"Add
+.
+
+p2o.Add.65
relu_52.tmp_0p2o.Relu.52"Relu
+¦
+
relu_38.tmp_0
+1054
+1056conv2d_134.tmp_0p2o.Conv.61"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_134.tmp_0
relu_53.tmp_0p2o.Relu.53"Relu
+¦
+
relu_53.tmp_0
+1058
+1060conv2d_135.tmp_0p2o.Conv.62"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+
relu_46.tmp_0
+conv2d_135.tmp_0
+p2o.Add.67
+p2o.Add.66"Add
+¦
+
relu_42.tmp_0
+1062
+1064conv2d_136.tmp_0p2o.Conv.63"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+;
+
+p2o.Add.67
+conv2d_136.tmp_0
+p2o.Add.69
+p2o.Add.68"Add
+¦
+
relu_50.tmp_0
+1066
+1068conv2d_137.tmp_0p2o.Conv.64"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+Ë
+conv2d_137.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.9bilinear_interp_v2_9.tmp_0p2o.Resize.9"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+E
+
+p2o.Add.69
+bilinear_interp_v2_9.tmp_0
+p2o.Add.71
+p2o.Add.70"Add
+.
+
+p2o.Add.71
relu_54.tmp_0p2o.Relu.54"Relu
+¦
+
relu_38.tmp_0
+1070
+1072conv2d_138.tmp_0p2o.Conv.65"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_138.tmp_0
relu_55.tmp_0p2o.Relu.55"Relu
+¦
+
relu_55.tmp_0
+1074
+1076conv2d_139.tmp_0p2o.Conv.66"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_139.tmp_0
relu_56.tmp_0p2o.Relu.56"Relu
+¦
+
relu_56.tmp_0
+1078
+1080conv2d_140.tmp_0p2o.Conv.67"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+>
+
relu_50.tmp_0
+conv2d_140.tmp_0
+p2o.Add.73
+p2o.Add.72"Add
+¦
+
relu_42.tmp_0
+1082
+1084conv2d_141.tmp_0p2o.Conv.68"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_141.tmp_0
relu_57.tmp_0p2o.Relu.57"Relu
+¦
+
relu_57.tmp_0
+1086
+1088conv2d_142.tmp_0p2o.Conv.69"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+;
+
+p2o.Add.73
+conv2d_142.tmp_0
+p2o.Add.75
+p2o.Add.74"Add
+¦
+
relu_46.tmp_0
+1090
+1092conv2d_143.tmp_0p2o.Conv.70"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+;
+
+p2o.Add.75
+conv2d_143.tmp_0
+p2o.Add.77
+p2o.Add.76"Add
+.
+
+p2o.Add.77
relu_58.tmp_0p2o.Relu.58"Relu
+Ë
+
relu_52.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.10bilinear_interp_v2_10.tmp_0
p2o.Resize.10"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+Ë
+
relu_54.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.11bilinear_interp_v2_11.tmp_0
p2o.Resize.11"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+Ë
+
relu_58.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.12bilinear_interp_v2_12.tmp_0
p2o.Resize.12"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+™
+
relu_51.tmp_0
+bilinear_interp_v2_10.tmp_0
+bilinear_interp_v2_11.tmp_0
+bilinear_interp_v2_12.tmp_0
p2o.Concat.14
p2o.Concat.13"Concat*
+axis
+¦
+
p2o.Concat.14
+1094
+1096conv2d_144.tmp_0p2o.Conv.71"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+auto_pad"
+SAME_UPPER
+4
+conv2d_144.tmp_0
relu_59.tmp_0p2o.Relu.59"Relu
+°
+
relu_59.tmp_0
+
conv2d_72.w_0
+
conv2d_72.b_0conv2d_145.tmp_0p2o.Conv.72"Conv*
+ dilations@@ *
+kernel_shape@@ *
+strides@@ *
+group *
+pads@ @ @ @
+Î
+conv2d_145.tmp_0
+p2o.helper.constant.4
+p2o.helper.constant.4
+p2o.helper.concat.13bilinear_interp_v2_13.tmp_0
p2o.Resize.13"Resize*
+mode"linear */
+coordinate_transformation_mode"
+half_pixel
+]
+bilinear_interp_v2_13.tmp_0p2o.Transpose.1p2o.Transpose.0" Transpose*
+perm@ @@@
+N
+p2o.Transpose.1
p2o.Softmax.1
p2o.Softmax.0"Softmax*
+axis˙˙˙˙˙˙˙˙˙
+^
+
p2o.Softmax.1save_infer_model/scale_0.tmp_1p2o.Transpose.2" Transpose*
+perm@ @@@ Model from PaddlePaddle.*B
conv2d_72.b_0J[=>8ľ*ťđB
conv2d_72.w_0J€őŘŁ=óÎÎ=m=„đľKëź=O4µ=�+ľfüÜ=‚˝ś=żA>OÎś=Y®”=X=łĘĘ=-
+„=C†<=ş->ŇI ľ;ć=Biľşhę=±@-ľ®
+ľľŁĺ>Çů3=ĽJŐ=Ě/>„j—=.‹>żg�=°ş=¶h%>ŔJ_ľ�#§=-v>ä«?ľc]¨=.×>ÓQ>ő“†=Ýś^=,Ąę˝Oä>ëžT=÷AľE<-ľÚ›Mľ->>î,p=�SMľAP(ľź
FľNNTľ•=pBľl5>eÖî=iv4>FźX=ă>—µ>ő9=c-š=*%Í˝›ú‚>Ĺ.Vľ8ÎGľŘ. =ČR>ś\ľý™x=
+®ď<ÍHá˝Â“8>rŇĽ=¶ş_=|¶=ú�D=Y~Ä=D>ľ
f7>Ł�ě=7^@="ĽGľ”6É=ľ”�ˇ=˝j7>ąrD>=Z=bp;=~ö'=ĎŢ>>đ.ľî%cľ^¸&>¬t'ľ
+Ě©=˘„S=Ô Ż˝˘Ź‚=Ůđ==2QV=ČŤ=ţňv=°ĐBľŤ›Ř=í>íŔmľŔ¦«=ź·>¶l8>*ô=
+Ô>BT>ë· >§O%=&Ă9>�ŕŚ=ÎŘ˝ç‹Ý=Šş>ŘóU=�)n=śO =Ejí˝iÜ=ĆÎ6>iW,=ąň*>ʲ ľął=«>Ń=ľEČ=ďłľWäľŰUß=yŢ>ňWNľŠ =zR[=lS_=’!=ć(.>ź÷ă=¨Ç=”8÷˝ÄT>łËi=Ü;˙=ćµ8>ťÖš=Ή�={"M>>u
+~=AąĘ=C˝p=BP=†~=‚îW=R× =”ÁP=§—R=đ%<=Â�ň=úS{>溯=Ŕ"/>Dôn=›m‚=1=áý{=©Ĺ4=ä�=ä6(>,&6>âr9>Ő÷ľgë>‚1>�GV=]¶Ą=i¬>®ÎZľF®O>©DĎ˝d]ż=$Ů@=tw}=Ţ÷dľĎŚ=aŢ&>NŐx>#¤TľŃR">ŕĆZ>Î0g=)"U=m_ľŁ©}=c;>˝k=ŮťKľh=h=üżG=Z`|ľ–¤đ=ă%2=é4?=Ä—=ď8>=Űů >üšő˝–€_>�e>k»Mľ…żs=~I=é%=ďę™˝đ÷+ľŤť!> †=>o€Ő=Ř*>=ÓÍ=L3ź=Ąľ ‹S=°¸ľe=‚\=ÜP =•Hľ®—=Ŕ”Á=´t>>jŐŁ˝~Ňνčm˝ň>îź˝»,µ˝Ż‘+> ůܽ๜˝gAľËÇś˝,˛”˝Y˝’ËĘ˝X„˝�„<˝ną-ľŰH >7;ć˝'i>gę˝E->Ϋ
+>g >Nâľ ř3˝&JŐ˝‹Ě/ľŐm—˝d‹ľc�˝."ş˝ h%ľzJ_>“#§˝‚tľ'?><]¨˝ĽŘľňNľ •†˝Â™^˝vŁę=5ćľRĄT˝ŁC>›:->VťM>[=ľŇ%p˝TM>ĘN(>ň
F>éNT>Ď•˝CtB>ö5ľXÖî˝s4ľx“X˝xĺľµľ4ü9˝X-š˝—&Í=ěú‚ľ+V>#ĐG>˛8 ˝óQľp›\>Fťx˝�§ďĽÓIá=7•8ľŻĐĽ˝(¸_˝‹ ¶˝
‹D˝{wÄ˝°C>ŕc7ľ†ě˝_^@˝:»G>c8É˝Î>C‰ˇ˝ćk7ľ4qDľă!Z˝Łh;˝5ţ'˝™Ţ>ľ—.>m%c>Ť·&ľ»s'>sĐ©˝éS˝őŻ=
‘‚˝ó=˝gNV˝Ź
Ť˝Növ˝˘ĎB>̜ؽńľTżm>şĄ«˝H¶ľ�k8ľEô˝SŐľđPľ ¶ ľ’U%˝‰ż9ľňÜŚ˝fŘ=
ŹÝ˝)Ľľ(ěU˝Ěn˝äN ˝:lí=BdÜ˝-Ń6ľ-X,˝ň*ľ^Ż >Ił˝ŽFŃ˝ŮGČ˝!µ>Ĺć>KYß˝ZŢľ¸ZN>7‰ ˝Ŕ\[˝öP_˝Ă’!˝‘,.ľ+úă˝ţÇ˝r7÷=»TľňŇi˝ę@˙˝¦ł8ľËŰš˝µŚ�˝¦ Mľhľ¨~˝›»Ę˝!˝p˝Ş6P˝…�˝-ďW˝đă ˝ĺĽP˝_‡R˝‚<˝Šň˝äS{ľ…şŻ˝]"/ľňn˝Yn‚˝Ń˝ký{˝đČ4˝:"�˝ű6(ľ='6ľĎp9ľŹö>ľęľ\‚1ľFV˝m¶Ą˝@¬ľHŃZ>MOľ[HĎ=ä`ż˝îĘ@˝Ňp}˝±÷d>NŚ˝ľŢ&ľ%Ůxľ¨¤T>ŹP"ľŮÄZľˇ/g˝â$U˝ç]>–}˝á:ľnÂk˝XźK>_h˝xh˝1ÁG˝©^|>b¦đ˝h(2˝C*?˝Ä—˝*>˝ů ľňśő=>‚_ľYgľ ľM>@˝s˝NyI˝Ň!˝€đ™=üř+>iť!ľÔ†=ľY„Ő˝AŮ*ľ¸ŐÍ˝3ź˝zĄ>řŽS˝l»>óe˝°\˝>O ˝ŇH>�±—˝»ŠÁ˝ t>ľ* Bp2o.helper.constant.4J *’6@B810J€6~Ú‚:*aa:é|:Ż×Š:;±™:D–k:HyI:‡4R:Ç:V•*9aM8Ł@Ű9
¤L8ö|*9ĐÓź9›‰T9˙±y9Ŕ˛«9f'0:¬@˝9Ä'H:lsŢ9q7Ă9„…:¶a4:b]:Í©H:Ţď ˝rç˝?nĽYÁ˝„x7˝Ř!ŻĽ�˙˘ĽTmÖĽˇ|†»Ý<v=á¨Ă<2é =U®#=X_ȡśĽ@ú¦Ľ†¸ Ľâ/Ľ¶ü@Ľ(6I;ŢRě»› uĽ•$şIA™Ľ¦8ÔĽŘ~Ľ_´+ĽsšĽć€PşßS;ä'˝×†'˝ß˛=ĽŚęY˝ąxM˝ßšŇ;LľĽ8€“Ľ> =ńlA=ţ†=]ş=ve=‹č= č