feat: partage d'écran Android 5+ (MediaProjection) et blocage des installations

- Partage d'écran par MediaProjection (ScreenCaptureService + ScreenConsentActivity)
  quand la capture par accessibilité n'est pas possible (Android < 11 ou service coupé).
  En mode propriétaire, le service d'accessibilité valide seul le consentement système.
- Blocage de l'installation d'applications (Play Store compris) piloté par le parent
  (policy block_installs → OwnerPolicy DISALLOW_INSTALL_APPS en mode propriétaire).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01R9CBCVP5oDu2sfoYPisNCQ

CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## v0.10.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Partage d'écran compatible dès Android 5** : capture par MediaProjection quand la capture par le service d'accessibilité n'est pas possible (celle-ci reste réservée à Android 11+). En mode propriétaire, le consentement système « Démarrer la capture » peut être validé automatiquement par le service d'accessibilité ; sinon un appui est demandé sur le téléphone. Une notification « Écran partagé avec le parent » reste affichée pendant le partage.
+- ✨ **Ajouté** — **Blocage de l'installation d'applications** (Play Store compris), piloté par le parent depuis l'espace parents. Appliqué en mode propriétaire (restriction système `DISALLOW_INSTALL_APPS`).
+
+## v0.9.0 – 2026-10-25
+
+- 🛠️ **Modifié** — **Quatre modes réseau distincts** décidés par le serveur, affichés sur le tableau de bord et la notification : *Accès libre* (aucun filtrage), *Liste noire* (tout sauf les services bloqués), *Liste blanche* (rien sauf les domaines autorisés), *Internet coupé*. La liste noire ne s'applique désormais que dans le mode qui lui correspond.
+
+## v0.8.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Verrouillage parental à distance** : depuis l'espace parents, le parent verrouille le téléphone sur un écran de blocage plein écran que seul un **code à usage unique** (généré par le serveur et dicté à l'enfant) permet de lever. En mode propriétaire, l'écran est épinglé (accueil et récents neutralisés) ; sinon il revient de lui-même si l'enfant tente de le quitter. Le parent peut aussi déverrouiller à distance.
+- 🔒 **Sécurité** — **Désactivation protégée par un code du serveur** : sur un téléphone associé, couper la protection, dissocier le téléphone, quitter le mode propriétaire ou retirer l'anti-désinstallation exige désormais un code à usage unique fourni par le parent — **à la place du mot de passe local**. L'enfant ne peut plus rien désactiver sans l'accord du parent.
+
+## v0.7.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Déploiement forcé** depuis l'espace parents : réinstalle DataControl via le tunnel WireGuard même si la version proposée n'est pas plus récente que celle installée (réparation / réinstallation à distance).
+
+## v0.6.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Faire sonner le téléphone** depuis l'espace parents : une sonnerie d'alarme retentit à plein volume (même si le téléphone est en silencieux), avec vibration et une notification « touchez pour arrêter » ; la sonnerie s'arrête d'elle-même au bout de la durée demandée, ou quand le parent l'arrête.
+- 🛠️ **Modifié** — Chaque action à distance (verrouillage, son, partage d'écran, sonnerie) est désormais acquittée au serveur — exécutée ou en échec, avec le détail — ce qui complète l'audit des commandes côté espace parents.
+
+## v0.5.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Actions à distance depuis l'espace parents** (téléphones DataControl) : voir l'écran en direct, verrouiller / mettre en veille, couper ou rétablir le son.
+- ✨ **Ajouté** — Partage d'écran par le service d'accessibilité (Android 11+), image réduite envoyée par le tunnel ; un bandeau rouge « Écran partagé avec le parent » reste affiché sur le téléphone pendant toute la durée, et le partage s'arrête de lui-même au bout de 5 minutes.
+
+## v0.4.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Mises à jour poussées depuis le serveur** : depuis l'espace parents (bouton « Déployer » ou « Mettre à jour DataControl partout »), la nouvelle version est téléchargée par le tunnel, son empreinte vérifiée, puis installée — sans aucune action sur le téléphone en mode propriétaire, sinon après un toucher sur la notification « Mise à jour de DataControl ».
+- 🛠️ **Modifié** — DataControl redémarre sa surveillance tout seul juste après une mise à jour.
+
+## v0.3.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Provisionnement du mode propriétaire par QR code**, sans PC ni débogage USB : sur un téléphone réinitialisé, toucher 6 fois l'écran d'accueil puis scanner le QR créé sur l'espace parents. DataControl est installé, devient propriétaire de l'appareil, s'associe tout seul au serveur et active la protection.
+- ✨ **Ajouté** — En mode propriétaire, DataControl s'accorde les autorisations de notification et de position, et pose ses verrous avant de monter le tunnel.
+
+## v0.2.0 – 2026-10-25
+
+- ✨ **Ajouté** — **Tunnel WireGuard permanent vers le serveur familyd** du parent : tout le trafic du téléphone (Wi-Fi et données mobiles) passe par le serveur, qui applique le mode choisi (accès libre, liste blanche seulement, Internet coupé) et bloque les services interdits.
+- ✨ **Ajouté** — Appairage par code (ou lien familyd://) dans Réglages → Contrôle parental ; clés WireGuard générées sur le téléphone, clé privée et jeton chiffrés par l'Android Keystore.
+- ✨ **Ajouté** — **Mode propriétaire de l'appareil** : VPN toujours actif avec blocage hors VPN, réglages VPN / date et heure / DNS privé verrouillés, pas de réinitialisation, DataControl indésinstallable ; garde-fou si le serveur ne répond plus pendant 15 min.
+- ✨ **Ajouté** — Le tableau de bord et la notification affichent l'état du tunnel et le mode décidé par le parent.
+- 🗑️ **Supprimé** — Firebase, le pare-feu local (liste blanche par application, filtrage Wi-Fi) et la coupure cyclique locale : ces règles s'appliquent désormais sur le serveur. L'onglet Liste blanche disparaît.
+- ⚙️ **Technique** — Mise à jour depuis la v0.1 : l'ancien appairage Firebase est effacé, il faut associer de nouveau le téléphone puis réactiver la protection. APK limité aux processeurs ARM (wireguard-go natif).
+
+## v0.1.10 – 2026-10-25
+
+- 🐛 **Corrigé** — Configuration Firebase (Réglages → Contrôle parental) : le bloc collé est accepté même si le copier-coller a remplacé les guillemets par des guillemets typographiques (“ ” « »), et le contenu du fichier google-services.json de l'application Android est aussi reconnu.
+
 ## v0.1.9 – 2026-10-25
 
 - 🔒 **Sécurité** — Retirer l'autorisation VPN ou activer un autre VPN ne désactive plus le contrôle : la notification passe en rouge, le parent est alerté, le tunnel est remonté après 30 s si possible et l'autorisation est redemandée à l'ouverture.

README.md

@@ -1,57 +1,47 @@
 # DataControl
 
-🚀 v0.1.9 · 🤖 Android · 🟣 Kotlin · 🎨 Jetpack Compose · 🔥 Firebase · 🔒 pare-feu VPN local · 👨‍👩‍👧 contrôle parental · 🧪 tests · 📄 licence non déclarée
+🚀 v0.10.0 · 🤖 Android · 🟣 Kotlin · 🎨 Jetpack Compose · 🔒 WireGuard · 🛡️ mode propriétaire · 👨‍👩‍👧 contrôle parental · 🧪 tests · 📄 licence non déclarée
 
-**DataControl** est une application Android qui surveille en arrière-plan la consommation de données mobiles et coupe automatiquement l'accès à Internet en cas de dépassement du forfait — sans jamais toucher au Wi-Fi.
+**DataControl** est l'application Android du téléphone de l'enfant. Elle relie le téléphone en permanence, par un tunnel **WireGuard**, au serveur de contrôle parental **familyd** du parent : tout le trafic (Wi-Fi comme données mobiles) passe par ce serveur, qui décide de ce qui passe. Sur le téléphone, elle bloque les applications interdites, compte le temps d'écran et suit la consommation de données mobiles.
 
-> JT-Tools by Johnny — version courante et historique : voir [CHANGELOG.md](CHANGELOG.md) (aussi lisible dans l'onglet *À propos* de l'application).
+> JT-Tools by Johnny — version courante et historique : voir [CHANGELOG.md](CHANGELOG.md) (aussi lisible dans l'onglet *À propos* de l'application). Plan de la refonte WireGuard : [docs/PLAN-wireguard.md](docs/PLAN-wireguard.md).
 
 ---
 
 ## Fonctionnalités
 
-- **Suivi de la consommation** — Mesure en continu les données mobiles consommées depuis le début du cycle de forfait (`TrafficStats`, aucune permission spéciale requise).
+- **Tunnel WireGuard permanent** — Une fois le téléphone associé et la protection activée, tout son trafic passe par le serveur du parent. Bibliothèque officielle `com.wireguard.android:tunnel` (wireguard-go embarqué).
-- **Forfait configurable** — Volume du forfait (Mo), prix du forfait (€), prix par Mo hors-forfait (€), date de début du cycle.
+- **Accès décidé par le parent** — Le serveur applique l'un des trois modes : *accès libre*, *liste blanche seulement* (par exemple Pronote) ou *Internet coupé* ; à la main, ou selon des plages horaires, un forfait de données mobiles ou une coupure cyclique. Il bloque aussi des services (réseaux sociaux, vidéo, jeux…) par son DNS filtrant.
-- **Estimation du coût** — Calcul automatique : prix du forfait + (Mo hors-forfait × prix/Mo), affiché en temps réel sur le tableau de bord.
+- **Appairage par code** — Code de 8 caractères (ou lien `familyd://`) créé sur l'espace parents, saisi dans *Réglages → Contrôle parental*. La paire de clés WireGuard est générée sur le téléphone ; la clé privée et le jeton de l'appareil sont chiffrés par l'Android Keystore.
-- **Réinitialisation** — Automatique chaque mois à la date anniversaire du début de forfait, ou manuelle à tout moment depuis le tableau de bord.
+- **Règles d'usage** (service d'accessibilité) — Plages horaires, temps d'écran quotidien global ou par application, ajout de temps, applications interdites ; le lanceur, le téléphone, le clavier et DataControl ne sont jamais bloqués. Changer à la main la date, l'heure ou le fuseau ne contourne pas ces règles (le changement est ignoré et signalé au parent).
-- **Liste blanche d'applications** — Les applications cochées gardent toujours accès aux données mobiles ; toutes les autres en sont privées en permanence (voir *Comportement du pare-feu* ci-dessous). Le Wi-Fi n'est jamais filtré.
+- **Remontées au parent** — Batterie, position (si autorisée), type de réseau, état des protections, applications installées, temps d'écran, évènements (tunnel coupé, protection retirée, heure modifiée…). Les évènements sont gardés sur le téléphone tant que le serveur n'est pas joignable.
-- **Coupure cyclique** — Sur données mobiles, une coupure totale (même pour la liste blanche) se déclenche automatiquement toutes les X minutes (paramétrable), pendant une courte pulsation de 30 s, avant de revenir en mode "liste blanche seule". Elle tourne en permanence, que le forfait soit dépassé ou non : le forfait sert au suivi et à l'estimation du coût, pas au déclenchement du filtrage.
+- **Tunnel coupé = alerte** — Si le tunnel tombe (VPN retiré, autre VPN, serveur injoignable), la protection reste activée : la notification passe en rouge (« PROTECTION INACTIVE »), le parent est prévenu et le tunnel est remonté dès que possible.
-- **Notification permanente** — Affiche la consommation (Mo / forfait / %), l'état des données avec un code couleur (🟢 sous le forfait, 🟠 proche du forfait, 🔴 hors-forfait/coupure, 🔵 Wi-Fi actif), et le coût estimé. Rafraîchie toutes les 20 secondes et à chaque changement de réseau.
+- **Mode propriétaire de l'appareil** (Device Owner, facultatif) — VPN toujours actif avec blocage des connexions hors VPN, réglages VPN / date et heure / DNS privé verrouillés, pas de réinitialisation ni de mode sans échec, DataControl indésinstallable. Garde-fou : si le serveur ne répond plus pendant 15 min, le blocage hors VPN est levé jusqu'à son retour.
-- **Démarrage au boot** — Le service redémarre automatiquement après un redémarrage de l'appareil si le contrôle était actif.
+- **Suivi de la consommation** — Données mobiles depuis le début du cycle (`TrafficStats`), forfait, coût estimé, réinitialisation mensuelle automatique ou manuelle.
-- **Alerte pare-feu inactif** — Si le contrôle est actif sur données mobiles mais que le tunnel VPN n'est pas monté, la notification passe en rouge (« PARE-FEU INACTIF ») : les données ne sont alors pas filtrées. Retirer l'autorisation VPN (ou activer un autre VPN) ne désactive **pas** le contrôle : le parent est alerté, le tunnel est remonté après 30 s si possible, et l'autorisation est redemandée à l'ouverture de l'application.
+- **Mot de passe de verrouillage** — Protège l'accès aux Réglages et l'effacement du journal (haché avec PBKDF2 ; après 3 essais ratés, attente croissante de 30 s à 15 min). Sur un téléphone associé, la *désactivation* du contrôle et la sortie du mode propriétaire exigent en plus un code du serveur dicté par le parent (voir ci-dessus).
-- **Journal de diagnostic** — Onglet *Journal* : état du VPN en direct, décisions du pare-feu, et, avec le service d'accessibilité, chaque application utilisée avec son verdict réseau/lancement. Conservé 15 jours.
+- **Journal de diagnostic** — État du tunnel, mode appliqué et, avec le service d'accessibilité, chaque application utilisée. Conservé 15 jours.
-- **Mise à jour intégrée** — Recherche et installation de la dernière Release Gitea depuis l'onglet *À propos*.
+- **Mise à jour intégrée** — Dernière Release Gitea depuis l'onglet *À propos* ; le serveur familyd la propose aussi aux appareils du tunnel sur `http://10.78.0.1/installer`.
-- **Mot de passe de verrouillage** — Protège les Réglages, la Liste blanche, l'effacement du journal et la désactivation du contrôle. Haché avec PBKDF2 ; après 3 essais ratés, attente croissante (30 s, 1 min, 2 min… jusqu'à 15 min).
+- **Déploiement depuis le serveur** — Le parent pousse la nouvelle version depuis l'espace parents : téléchargement par le tunnel, empreinte SHA-256 vérifiée, installation silencieuse en mode propriétaire (sinon un toucher sur la notification).
-- **Interface Material 3** — Thème clair/sombre avec couleurs dynamiques (Android 12+), 5 onglets : Tableau de bord, Réglages, Liste blanche, Journal, À propos.
+- **Actions à distance** — Depuis l'espace parents : voir l'écran en direct (service d'accessibilité, Android 11+, avec bandeau visible « Écran partagé » sur le téléphone), verrouiller / mettre en veille, couper ou rétablir le son, faire sonner, et **verrouiller le téléphone** sur un écran de blocage que seul un code du serveur lève.
+- **Déverrouillage et désactivation par code** — Sur un téléphone associé, couper la protection, dissocier, quitter le mode propriétaire ou lever le verrouillage parental exige un **code à usage unique** généré par le parent (dans l'espace parents) et dicté à l'enfant, au lieu du mot de passe local.
 
 ---
 
-## Contrôle parental (avec FamilyControl)
+## Installation sur le téléphone de l'enfant
 
-DataControl peut être associé à **FamilyControl** (application parent en TypeScript/Expo, dépôt séparé) via Firebase (Auth + Firestore). La configuration du projet Firebase se **colle dans l'application** (*Réglages → Contrôle parental → Configuration Firebase*), sans recompiler ; sans elle, ces fonctions sont simplement désactivées (un `firebase.properties` à la compilation reste possible comme valeur par défaut).
+1. **Installer DataControl** : par la Release Gitea, ou — sans PC — en ajoutant d'abord le téléphone par QR code dans l'application WireGuard (espace parents → *Ajouter un appareil*), puis en ouvrant `http://10.78.0.1/installer` dans son navigateur.
+2. **Associer** : espace parents → *Associer un téléphone (DataControl)* ; saisir le code dans *Réglages → Contrôle parental*.
+3. **Activer la protection** sur le tableau de bord et accepter la demande VPN d'Android.
+4. **Verrouiller** (recommandé) : mot de passe dans *Réglages → Sécurité*, administrateur d'appareil, et si possible le mode propriétaire.
 
-- **Appairage** par code à usage court, saisi dans *Réglages → Contrôle parental*.
+   **Par QR code, sans PC** (téléphone réinitialisé) : espace parents → *Préparer un téléphone (mode propriétaire)* ; sur l'écran « Bienvenue » du téléphone, toucher 6 fois au même endroit, scanner le QR. DataControl est installé, devient propriétaire, s'associe et active la protection tout seul.
-- **Remontées** : batterie, position, état du pare-feu, consommation, trafic quotidien mobile/Wi-Fi, temps d'écran, événements (VPN révoqué, protection retirée…).
-- **Consignes du parent** : contrôle activé/désactivé, applications autorisées (mobile et Wi-Fi), filtrage Wi-Fi.
-- **Règles d'usage** (service d'accessibilité) : plages horaires (avec coupure optionnelle des données mobiles hors plage), temps d'écran quotidien global ou par application, ajout de temps, applications interdites. Le lanceur, le téléphone, le clavier et DataControl ne sont jamais bloqués. Changer à la main la date, l'heure ou le fuseau du téléphone ne contourne pas ces règles (le changement est ignoré et signalé au parent) ; laisser l'heure automatique activée est recommandé.
-- **Anti-désinstallation** par administrateur d'appareil (retirable depuis les Réglages Android : le parent est alors alerté ; le mot de passe protège le retrait depuis l'application).
 
----
+   **Ou par adb** :
 
-## Comportement du pare-feu (important)
+   ```bash
-
+   # téléphone branché en USB, débogage USB actif, tous les comptes retirés le temps de la commande
-Android interdit depuis longtemps aux applications normales de couper les données mobiles par programmation (l'API historique a été bloquée depuis Android 5). DataControl **ne nécessite ni root ni Shizuku** : il utilise un pare-feu local basé sur `VpnService` (comme NetGuard), qui ne route ni ne transmet aucun paquet — il capture le trafic des applications non autorisées dans un tunnel VPN local et le laisse silencieusement tomber ("trou noir"), tandis que les applications autorisées sont explicitement exclues du tunnel (`addDisallowedApplication`) et continuent de communiquer normalement.
+   adb shell dpm set-device-owner com.jttools.datacontrol/.admin.AppDeviceAdminReceiver
-
+   ```
-Règles appliquées :
-
-| Réseau actif | Sous le forfait | Forfait dépassé |
-|---|---|---|
-| **Wi-Fi** | Aucun filtrage, jamais | Aucun filtrage, jamais |
-| **Données mobiles** | Liste blanche active en permanence **+** coupure totale cyclique toutes les X minutes | Identique (le dépassement ne change pas le filtrage, seulement l'état affiché et le coût) |
-
-Pendant la pulsation de coupure (30 s), même les applications de la liste blanche sont coupées.
-
-Le pare-feu est démarré/arrêté automatiquement selon le transport réseau actif détecté (`ConnectivityManager.NetworkCallback`) : dès que l'appareil bascule sur le Wi-Fi, le tunnel VPN est entièrement fermé.
 
 ---
 
@@ -59,34 +49,40 @@ Le pare-feu est démarré/arrêté automatiquement selon le transport réseau ac
 
 | Permission | Usage |
 |---|---|
-| VPN (consentement système) | Établir le pare-feu local — demandé au premier `Activer le contrôle` |
+| VPN (consentement système) | Tunnel WireGuard — demandé à l'activation de la protection (accordé automatiquement en mode propriétaire) |
-| Notifications (Android 13+) | Afficher la notification permanente d'état |
+| Notifications (Android 13+) | Notification permanente d'état |
-| Ignorer l'optimisation de la batterie | Éviter que le système ne tue le service de surveillance |
+| Ignorer l'optimisation de la batterie | Éviter que le système n'arrête la surveillance |
-| `QUERY_ALL_PACKAGES` | Lister toutes les applications installées dans l'écran Liste blanche |
+| `QUERY_ALL_PACKAGES` | Liste des applications installées, pour que le parent choisisse lesquelles limiter |
-| `RECEIVE_BOOT_COMPLETED` | Relancer la surveillance après redémarrage si le contrôle était actif |
+| `RECEIVE_BOOT_COMPLETED` | Relancer la surveillance et le tunnel après redémarrage |
-| Position (dont arrière-plan) | Facultatif — transmise au parent si l'appareil est associé |
+| Position (dont arrière-plan) | Facultatif — transmise au parent |
-| Administrateur d'appareil | Facultatif — anti-désinstallation |
+| Administrateur d'appareil / propriétaire de l'appareil | Facultatif — anti-désinstallation, verrouillage du VPN et des réglages |
-| Service d'accessibilité | Facultatif — détecte l'application au premier plan (sans lire les écrans) pour les règles d'usage et le journal |
+| Service d'accessibilité | Facultatif — détecte l'application au premier plan (sans lire les écrans) pour les règles d'usage |
+
+Réseau : sortant UDP 51721 (tunnel vers `fam-vpn.tuxtech.fr`) et HTTPS (appairage sur `family.tuxtech.fr`, mises à jour sur `git.tuxtech.fr`). L'API du serveur est jointe en HTTP **dans** le tunnel (10.78.0.1:8100), seule exception autorisée par `network_security_config.xml`.
 
 ---
 
 ## Limites connues
 
-- Le compteur de consommation repose sur `TrafficStats` (cumul depuis le dernier redémarrage de l'appareil). Un redémarrage réinitialise ce compteur système ; DataControl détecte cette situation et rebascule automatiquement sa référence à 0 pour éviter un calcul négatif, mais la consommation entre le redémarrage et la détection n'est pas comptabilisée.
+- Sans le mode propriétaire, le VPN peut être coupé dans les réglages Android : le serveur le voit et alerte le parent, sans pouvoir l'empêcher.
-- `QUERY_ALL_PACKAGES` est soumis à restriction sur le Google Play Store pour les apps grand public ; sans distribution via le Store, cela ne pose pas de problème.
+- Le mode propriétaire se provisionne par QR code au premier démarrage (téléphone réinitialisé) ou par `adb` sur un téléphone sans compte.
-- Le pare-feu VPN local est incompatible avec l'usage simultané d'un autre VPN (limitation système Android : un seul VPN actif à la fois).
+- Un seul VPN peut être actif à la fois sous Android : DataControl est incompatible avec un autre VPN.
+- Si le serveur familyd est arrêté, le téléphone n'est plus filtré (et, en mode propriétaire, n'a plus Internet pendant 15 min au plus).
+- Le compteur de consommation local repose sur `TrafficStats` (remis à zéro au redémarrage, la référence est recalée) ; le serveur mesure de son côté le trafic réel du tunnel.
 
 ---
 
 ## Architecture
 
-- **Kotlin + Jetpack Compose (Material 3)**, Hilt pour l'injection de dépendances.
+- **Kotlin + Jetpack Compose (Material 3)**, Hilt, DataStore Preferences.
-- `data/` — `SettingsRepository` (DataStore Preferences), `UsageRepository` (TrafficStats), `InstalledAppsRepository` (PackageManager).
+- `vpn/` — `TunnelManager` (bibliothèque WireGuard officielle, `GoBackend`).
-- `service/` — `FirewallVpnService` (VpnService), `ConnectivityObserver` (détection Wi-Fi/cellulaire), `DataMonitorService` (orchestration + notification), `MonitorStateHolder` (pont service ↔ UI), `BootReceiver`.
+- `remote/` — `FamilyApi` (client HTTP de familyd), `FamilyLink` / `PairingInput` (liaison et saisie du code), `RemoteSync` (appairage, consignes, file d'évènements), `DeviceReporter` (état, temps d'écran, applications).
-- `remote/` — `FirebaseGateway`, `RemoteSync` (appairage, consignes, remontées), `DeviceReporter` (batterie, position, trafic, état).
+- `service/` — `DataMonitorService` (tunnel, consommation, notification, mode propriétaire), `ConnectivityObserver`, `MonitorStateHolder`, `BootReceiver`, `DataMonitorRestartWorker`.
-- `guard/` — `GuardEngine` (règles d'usage, temps d'écran), `AppGuardService` (accessibilité), `BlockedActivity`.
+- `guard/` — `GuardEngine` (règles d'usage, temps d'écran, horloge de confiance), `AppGuardService` (accessibilité), `BlockedActivity`.
-- `admin/` — administrateur d'appareil (anti-désinstallation). `log/` — journal de diagnostic.
+- `admin/` — administrateur d'appareil et `OwnerPolicy` (mode propriétaire). `data/` — réglages, mot de passe, `SecretBox` (Android Keystore). `log/` — journal.
-- `ui/` — écrans Compose (`dashboard`, `settings`, `whitelist`, `journal`, `about`, `family`), navigation par `NavigationBar`, thème dynamique.
+- `ui/` — écrans Compose (`dashboard`, `settings`, `family`, `journal`, `about`).
+
+Le serveur **familyd** (FastAPI, WireGuard, nftables, AdGuard Home) est dans un dépôt séparé (`~/scripts/familyd`).
 
 ---
 

app/build.gradle.kts

@@ -9,13 +9,6 @@ plugins {
     alias(libs.plugins.kotlin.kapt)
 }
 
-// Configuration Firebase (liaison distante avec FamilyControl) : fichier local non versionné.
-// Sans ce fichier l'app se compile normalement, mais l'appairage/le contrôle à distance sont désactivés.
-val firebaseProps = Properties().apply {
-    val f = rootProject.file("firebase.properties")
-    if (f.exists()) f.inputStream().use { load(it) }
-}
-
 // Clé de signature des releases : fichier local non versionné (voir keystore.properties.example).
 // Sans lui, la release est signée avec la clé de débogage (avertissement à la compilation).
 val keystoreProps = Properties().apply {
@@ -42,10 +35,9 @@ android {
         vectorDrawables {
             useSupportLibrary = true
         }
+        // wireguard-go est natif : seuls les téléphones (ARM) sont visés, pour alléger l'APK.
+        ndk { abiFilters += listOf("arm64-v8a", "armeabi-v7a") }
 
-        buildConfigField("String", "FIREBASE_API_KEY", "\"${firebaseProps.getProperty("apiKey", "")}\"")
-        buildConfigField("String", "FIREBASE_APP_ID", "\"${firebaseProps.getProperty("appId", "")}\"")
-        buildConfigField("String", "FIREBASE_PROJECT_ID", "\"${firebaseProps.getProperty("projectId", "")}\"")
         buildConfigField("String", "BUILD_DATE", "\"${SimpleDateFormat("yyyy-MM-dd").format(Date())}\"")
     }
 
@@ -130,10 +122,8 @@ dependencies {
     implementation(libs.androidx.datastore.preferences)
     implementation(libs.kotlinx.coroutines.android)
     implementation(libs.androidx.work.runtime.ktx)
-    implementation(platform(libs.firebase.bom))
+    // Client WireGuard officiel (GoBackend : wireguard-go embarqué, VpnService fourni par la bibliothèque).
-    implementation(libs.firebase.auth)
+    implementation(libs.wireguard.tunnel)
-    implementation(libs.firebase.firestore)
-    implementation(libs.kotlinx.coroutines.play.services)
 
     testImplementation(libs.junit)
     // org.json est fourni par Android à l'exécution, mais absent (bouchonné) des tests JVM.

app/proguard-rules.pro

@@ -7,3 +7,8 @@
 
 # Hilt
 -dontwarn dagger.hilt.**
+
+# WireGuard (com.wireguard.android:tunnel) : méthodes natives (JNI) et rappels appelés par libwg-go.
+-keep class com.wireguard.android.backend.** { *; }
+-keep class com.wireguard.config.** { *; }
+-keep class com.wireguard.crypto.** { *; }

app/src/main/AndroidManifest.xml

@@ -6,7 +6,9 @@
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.VIBRATE" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
@@ -23,6 +25,7 @@
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
@@ -39,21 +42,23 @@
             </intent-filter>
         </activity>
 
-        <service
-            android:name=".service.FirewallVpnService"
-            android:permission="android.permission.BIND_VPN_SERVICE"
-            android:exported="false"
-            android:foregroundServiceType="dataSync">
-            <intent-filter>
-                <action android:name="android.net.VpnService" />
-            </intent-filter>
-        </service>
-
         <service
             android:name=".service.DataMonitorService"
             android:exported="false"
             android:foregroundServiceType="dataSync" />
 
+        <!-- Partage d'écran par MediaProjection (fonctionne dès Android 5, contrairement à l'accessibilité). -->
+        <service
+            android:name=".remote.ScreenCaptureService"
+            android:exported="false"
+            android:foregroundServiceType="mediaProjection" />
+
+        <activity
+            android:name=".remote.ScreenConsentActivity"
+            android:exported="false"
+            android:excludeFromRecents="true"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
+
         <!-- FileProvider pour installer l'APK de mise à jour téléchargé -->
         <provider
             android:name="androidx.core.content.FileProvider"
@@ -86,6 +91,15 @@
             android:launchMode="singleTask"
             android:theme="@style/Theme.DataControl" />
 
+        <!-- Verrouillage parental plein écran : levé uniquement par un code à usage unique du serveur. -->
+        <activity
+            android:name=".guard.ParentalLockActivity"
+            android:exported="false"
+            android:excludeFromRecents="true"
+            android:launchMode="singleTask"
+            android:showOnLockScreen="true"
+            android:theme="@style/Theme.DataControl" />
+
         <!-- Administrateur d'appareil : bloque la désinstallation tant qu'il est actif. -->
         <receiver
             android:name=".admin.AppDeviceAdminReceiver"
@@ -96,15 +110,49 @@
                 android:resource="@xml/device_admin" />
             <intent-filter>
                 <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
+                <action android:name="android.app.action.PROFILE_PROVISIONING_COMPLETE" />
             </intent-filter>
         </receiver>
 
+        <!-- Provisionnement « propriétaire de l'appareil » par QR code (assistant de première mise en route). -->
+        <activity
+            android:name=".admin.ProvisioningModeActivity"
+            android:exported="true"
+            android:permission="android.permission.BIND_DEVICE_ADMIN"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar">
+            <intent-filter>
+                <action android:name="android.app.action.GET_PROVISIONING_MODE" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".admin.PolicyComplianceActivity"
+            android:exported="true"
+            android:permission="android.permission.BIND_DEVICE_ADMIN"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar">
+            <intent-filter>
+                <action android:name="android.app.action.ADMIN_POLICY_COMPLIANCE" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
+        <!-- Résultat des mises à jour poussées par le serveur (PackageInstaller). -->
+        <receiver
+            android:name=".remote.InstallResultReceiver"
+            android:exported="false" />
+
+        <!-- Arrêt de la sonnerie « Faire sonner » depuis la notification. -->
+        <receiver
+            android:name=".remote.RingStopReceiver"
+            android:exported="false" />
+
         <receiver
             android:name=".service.BootReceiver"
             android:exported="true"
             android:enabled="true">
             <intent-filter>
                 <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
             </intent-filter>
         </receiver>
 

app/src/main/java/com/jttools/datacontrol/DataControlApp.kt

@@ -9,8 +9,6 @@ import com.jttools.datacontrol.service.DataMonitorRestartWorker
 import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
@@ -19,15 +17,18 @@ import javax.inject.Inject
 class DataControlApp : Application() {
 
     @Inject lateinit var settingsRepository: SettingsRepository
-    @Inject lateinit var firebaseGateway: com.jttools.datacontrol.remote.FirebaseGateway
 
     override fun onCreate() {
         super.onCreate()
         com.jttools.datacontrol.log.AppLog.init(this)
-        CoroutineScope(Dispatchers.IO).launch { settingsRepository.resetPasswordOnce() }
-        // La config Firebase se saisit dans l'appli : on l'applique au démarrage et à chaque modification.
         CoroutineScope(Dispatchers.IO).launch {
-            settingsRepository.settingsFlow.map { it.firebase }.distinctUntilChanged().collect { firebaseGateway.apply(it) }
+            settingsRepository.resetPasswordOnce()
+            settingsRepository.migrateToV02()
+        }
+        // VPN « toujours actif » (réglage Android ou mode propriétaire) : le système démarre le service
+        // VPN de la bibliothèque ; on relance alors la surveillance, qui monte le tunnel.
+        com.wireguard.android.backend.GoBackend.setAlwaysOnCallback {
+            com.jttools.datacontrol.service.DataMonitorService.start(this)
         }
         // Filet de sécurité : relance périodiquement DataMonitorService s'il a été tué en arrière-plan.
         // enqueueUniquePeriodicWork + KEEP : sans effet si déjà planifié, donc sûr à appeler à chaque démarrage.

app/src/main/java/com/jttools/datacontrol/admin/AdminController.kt

@@ -20,6 +20,10 @@ object AdminController {
                 "Empêche la désinstallation de DataControl sans mot de passe."
             )
 
+    /** Vrai si DataControl est « propriétaire de l'appareil » (provisionné par adb, voir le plan, phase 4). */
+    fun isDeviceOwner(context: Context): Boolean =
+        context.getSystemService(DevicePolicyManager::class.java).isDeviceOwnerApp(context.packageName)
+
     /** À n'appeler qu'après vérification du mot de passe. */
     fun deactivate(context: Context) {
         context.getSystemService(DevicePolicyManager::class.java).removeActiveAdmin(component(context))

app/src/main/java/com/jttools/datacontrol/admin/AppDeviceAdminReceiver.kt

@@ -15,6 +15,11 @@ class AppDeviceAdminReceiver : DeviceAdminReceiver() {
 
     @Inject lateinit var remoteSync: RemoteSync
 
+    /** Android 9 et avant : fin du provisionnement signalée ici (Android 10+ : PolicyComplianceActivity). */
+    override fun onProfileProvisioningComplete(context: Context, intent: Intent) {
+        Provisioning.complete(context, Provisioning.extrasOf(intent))
+    }
+
     override fun onDisableRequested(context: Context, intent: Intent): CharSequence =
         "Désactiver la protection permet de désinstaller DataControl. Cette action est signalée à FamilyControl."
 

app/src/main/java/com/jttools/datacontrol/admin/OwnerPolicy.kt

@@ -0,0 +1,120 @@
+package com.jttools.datacontrol.admin
+
+import android.app.admin.DevicePolicyManager
+import android.content.Context
+import android.os.Build
+import android.os.UserManager
+import com.jttools.datacontrol.log.AppLog
+
+/**
+ * Mode « propriétaire de l'appareil » (Device Owner), provisionné une fois par adb :
+ *   adb shell dpm set-device-owner com.jttools.datacontrol/.admin.AppDeviceAdminReceiver
+ *
+ * DataControl impose alors au système : VPN toujours actif (connexions bloquées hors tunnel), réglages
+ * VPN / date et heure / DNS privé verrouillés, pas de réinitialisation, pas de mode sans échec, pas
+ * d'autre utilisateur, désinstallation impossible. Sans ce mode, toutes ces fonctions sont inertes.
+ */
+object OwnerPolicy {
+
+    /** Restrictions posées tant que la protection est active (le débogage USB reste permis : maintenance). */
+    private val RESTRICTIONS = buildList {
+        add(UserManager.DISALLOW_CONFIG_VPN)
+        add(UserManager.DISALLOW_CONFIG_DATE_TIME)
+        add(UserManager.DISALLOW_FACTORY_RESET)
+        add(UserManager.DISALLOW_SAFE_BOOT)
+        add(UserManager.DISALLOW_ADD_USER)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) add(UserManager.DISALLOW_CONFIG_PRIVATE_DNS)
+    }
+
+    /** État voulu, appliqué tel quel ; [lockdown] = connexions bloquées hors VPN ;
+     * [blockInstalls] = installation d'applications interdite (Play Store compris). */
+    data class Target(val protect: Boolean, val lockdown: Boolean, val blockInstalls: Boolean = false)
+
+    private var applied: Target? = null
+
+    fun isDeviceOwner(context: Context): Boolean = AdminController.isDeviceOwner(context)
+
+    private fun dpm(context: Context) = context.getSystemService(DevicePolicyManager::class.java)
+
+    /** Applique [target] si DataControl est propriétaire et que l'état a changé. Renvoie faux en cas d'échec. */
+    fun sync(context: Context, target: Target, force: Boolean = false): Boolean {
+        if (!isDeviceOwner(context)) {
+            applied = null
+            return true
+        }
+        if (!force && target == applied) return true
+        val dpm = dpm(context)
+        val admin = AdminController.component(context)
+        return try {
+            if (target.protect) {
+                // Le système accorde lui-même l'autorisation VPN au paquet désigné : aucune fenêtre de consentement.
+                dpm.setAlwaysOnVpnPackage(admin, context.packageName, target.lockdown)
+                RESTRICTIONS.forEach { dpm.addUserRestriction(admin, it) }
+                // Blocage des installations : facultatif, piloté par le parent.
+                if (target.blockInstalls) dpm.addUserRestriction(admin, UserManager.DISALLOW_INSTALL_APPS)
+                else dpm.clearUserRestriction(admin, UserManager.DISALLOW_INSTALL_APPS)
+                dpm.setUninstallBlocked(admin, context.packageName, true)
+                requireAutoTime(context)
+            } else {
+                dpm.setAlwaysOnVpnPackage(admin, null, false)
+                RESTRICTIONS.forEach { dpm.clearUserRestriction(admin, it) }
+                dpm.clearUserRestriction(admin, UserManager.DISALLOW_INSTALL_APPS)
+                dpm.setUninstallBlocked(admin, context.packageName, false)
+            }
+            applied = target
+            AppLog.i("Propriétaire", when {
+                !target.protect -> "Protections levées (contrôle désactivé ou appareil non associé)"
+                target.lockdown -> "VPN toujours actif, connexions bloquées hors VPN, réglages verrouillés"
+                else -> "VPN toujours actif SANS blocage hors VPN (serveur injoignable), réglages verrouillés"
+            })
+            true
+        } catch (e: Exception) {
+            AppLog.e("Propriétaire", "Application des protections impossible", e)
+            false
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    private fun requireAutoTime(context: Context) {
+        val dpm = dpm(context)
+        val admin = AdminController.component(context)
+        runCatching {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                dpm.setAutoTimeEnabled(admin, true)
+                dpm.setAutoTimeZoneEnabled(admin, true)
+            } else {
+                dpm.setAutoTimeRequired(admin, true)
+            }
+        }
+    }
+
+    /** VPN toujours actif imposé par DataControl, et avec quel blocage. */
+    fun alwaysOnState(context: Context): Pair<Boolean, Boolean> {
+        if (!isDeviceOwner(context)) return false to false
+        val dpm = dpm(context)
+        val admin = AdminController.component(context)
+        return runCatching {
+            val pkg = dpm.getAlwaysOnVpnPackage(admin)
+            val lockdown = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && dpm.isAlwaysOnVpnLockdownEnabled(admin)
+            (pkg == context.packageName) to lockdown
+        }.getOrDefault(false to false)
+    }
+
+    /**
+     * Sortie du mode propriétaire (après vérification du mot de passe) : protections levées, puis
+     * DataControl redevient une application ordinaire (l'administrateur d'appareil simple reste actif).
+     */
+    fun release(context: Context): Boolean {
+        if (!isDeviceOwner(context)) return true
+        sync(context, Target(protect = false, lockdown = false), force = true)
+        return runCatching {
+            dpm(context).clearDeviceOwnerApp(context.packageName)
+            applied = null
+            AppLog.w("Propriétaire", "Mode propriétaire de l'appareil retiré")
+            true
+        }.getOrElse {
+            AppLog.e("Propriétaire", "Retrait du mode propriétaire impossible", it)
+            false
+        }
+    }
+}

app/src/main/java/com/jttools/datacontrol/admin/Provisioning.kt

@@ -0,0 +1,101 @@
+package com.jttools.datacontrol.admin
+
+import android.Manifest
+import android.app.Activity
+import android.app.admin.DevicePolicyManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.os.PersistableBundle
+import com.jttools.datacontrol.data.SettingsRepository
+import com.jttools.datacontrol.log.AppLog
+import com.jttools.datacontrol.service.DataMonitorService
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.runBlocking
+
+/**
+ * Provisionnement « propriétaire de l'appareil » par QR code, à la première mise en route d'un téléphone
+ * réinitialisé (QR créé sur l'espace parents). Le QR transmet, dans le bundle « admin extras », l'adresse du
+ * serveur familyd, un code d'appairage et le nom du téléphone : DataControl s'associe ensuite tout seul
+ * (voir DataMonitorService) et active la protection.
+ */
+object Provisioning {
+
+    @EntryPoint
+    @InstallIn(SingletonComponent::class)
+    interface Deps {
+        fun settingsRepository(): SettingsRepository
+    }
+
+    fun extrasOf(intent: Intent?): PersistableBundle? {
+        intent ?: return null
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            intent.getParcelableExtra(DevicePolicyManager.EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE, PersistableBundle::class.java)
+        } else {
+            @Suppress("DEPRECATION")
+            intent.getParcelableExtra(DevicePolicyManager.EXTRA_PROVISIONING_ADMIN_EXTRAS_BUNDLE)
+        }
+    }
+
+    /** Fin du provisionnement : appairage en attente, autorisations accordées, surveillance démarrée. */
+    fun complete(context: Context, extras: PersistableBundle?) {
+        val app = context.applicationContext
+        val url = extras?.getString("familyd_url").orEmpty()
+        val code = extras?.getString("familyd_code").orEmpty()
+        val name = extras?.getString("device_name").orEmpty()
+        if (url.startsWith("https://") && code.isNotBlank()) {
+            val settings = EntryPointAccessors.fromApplication(app, Deps::class.java).settingsRepository()
+            // Écriture courte et indispensable avant de rendre la main à l'assistant de configuration.
+            runBlocking { settings.setPendingProvision(url, code, name) }
+            AppLog.i("Propriétaire", "Provisionnement par QR : appairage prévu avec $url (« $name »)")
+        } else {
+            AppLog.w("Propriétaire", "Provisionnement sans informations d'appairage : associer à la main")
+        }
+        grantPermissions(app)
+        DataMonitorService.start(app)
+    }
+
+    /** Le propriétaire de l'appareil accorde lui-même les autorisations d'exécution utiles. */
+    private fun grantPermissions(context: Context) {
+        if (!AdminController.isDeviceOwner(context)) return
+        val dpm = context.getSystemService(DevicePolicyManager::class.java)
+        val admin = AdminController.component(context)
+        val perms = buildList {
+            add(Manifest.permission.ACCESS_FINE_LOCATION)
+            add(Manifest.permission.ACCESS_COARSE_LOCATION)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) add(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) add(Manifest.permission.POST_NOTIFICATIONS)
+        }
+        for (p in perms) {
+            val ok = runCatching {
+                dpm.setPermissionGrantState(admin, context.packageName, p, DevicePolicyManager.PERMISSION_GRANT_STATE_GRANTED)
+            }.getOrDefault(false)
+            AppLog.i("Propriétaire", "Autorisation ${p.substringAfterLast('.')} : ${if (ok) "accordée" else "refusée par le système"}")
+        }
+    }
+}
+
+/** Android 12+ : l'assistant demande quel mode de gestion l'application veut (ici : appareil entièrement géré). */
+class ProvisioningModeActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setResult(RESULT_OK, Intent().putExtra(
+            DevicePolicyManager.EXTRA_PROVISIONING_MODE, DevicePolicyManager.PROVISIONING_MODE_FULLY_MANAGED_DEVICE
+        ))
+        finish()
+    }
+}
+
+/** Android 10+ : dernière étape du provisionnement, l'application finalise sa configuration. */
+class PolicyComplianceActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        Provisioning.complete(this, Provisioning.extrasOf(intent))
+        setResult(RESULT_OK)
+        finish()
+    }
+}

app/src/main/java/com/jttools/datacontrol/data/AppSettings.kt

@@ -1,39 +1,36 @@
 package com.jttools.datacontrol.data
 
+import com.jttools.datacontrol.remote.FamilyLink
 import java.time.LocalDate
 
 /**
  * Réglages persistés de l'application, avec leurs valeurs par défaut.
  */
 data class AppSettings(
+    /** Tunnel WireGuard vers le serveur familyd monté en permanence (désactivation protégée par mot de passe). */
     val controlEnabled: Boolean = false,
     val planLimitMo: Long = 1000L,
     val planPriceEuro: Double = 19.99,
     val overagePricePerMoEuro: Double = 0.01,
     val planStartDateEpochDay: Long = LocalDate.now().toEpochDay(),
     val autoResetEnabled: Boolean = true,
-    val cutoffIntervalMinutes: Int = 15,
     val baselineMobileBytesAtReset: Long = 0L,
-    val whitelistedPackages: Set<String> = DEFAULT_WHITELIST,
-    val whitelistedPackagesWifi: Set<String> = DEFAULT_WHITELIST,
-    val wifiFilterEnabled: Boolean = false,
-    val showSystemApps: Boolean = false,
     val passwordHash: String? = null,
     val passwordSalt: String? = null,
-    val cutoffCycleAnchorMillis: Long? = null,
+    /** Règles d'usage des applications (plages horaires, limites, interdites), envoyées par le serveur. */
-    val cutoffInPulse: Boolean = false,
-    val cutoffPulseStartMillis: Long = 0L,
-    /** Appairage avec FamilyControl (null tant que l'appareil n'est pas associé). */
-    val familyId: String? = null,
-    val deviceId: String? = null,
-    /** Horodatage (ms) de la dernière configuration distante appliquée. */
-    val remoteConfigVersion: Long = 0L,
-    /** Règles d'usage (plages horaires, limites de temps, applications interdites), au format JSON. */
     val rulesJson: String? = null,
-    /** Configuration Firebase saisie dans l'application (null : voir firebase.properties de compilation). */
+    /** Liaison avec le serveur familyd (null tant que l'appareil n'est pas associé). */
-    val firebase: com.jttools.datacontrol.remote.FirebaseConfig? = null
+    val link: FamilyLink? = null,
+    /** Mode réseau appliqué par le serveur : open, allowlist ou cut. */
+    val serverMode: String = "open",
+    val serverModeReason: String = "",
+    val policyVersion: Long = 0L,
+    /** Bloque l'installation d'applications (Play Store compris) — appliqué en mode propriétaire. */
+    val blockInstalls: Boolean = false,
+    /** Téléphone verrouillé à distance par le parent : un code du serveur est exigé pour le déverrouiller. */
+    val parentalLocked: Boolean = false
 ) {
-    val isPaired: Boolean get() = !familyId.isNullOrEmpty() && !deviceId.isNullOrEmpty()
+    val isPaired: Boolean get() = link != null
 
     val planStartDate: LocalDate get() = LocalDate.ofEpochDay(planStartDateEpochDay)
 
@@ -49,13 +46,6 @@ data class AppSettings(
         }
         return next
     }
-
-    companion object {
-        const val PRONOTE_PACKAGE = "com.indexeducation.pronote"
-
-        /** Applications autorisées par défaut (tant que l'utilisateur n'a pas modifié la liste blanche). */
-        val DEFAULT_WHITELIST: Set<String> = setOf(PRONOTE_PACKAGE)
-    }
 }
 
 /** État calculé de la consommation, dérivé des réglages + de la mesure de données réelle. */
@@ -70,12 +60,9 @@ data class UsageState(
         get() = if (planLimitMo <= 0) 0f else (consumedMo.toFloat() / planLimitMo.toFloat()).coerceAtLeast(0f)
 }
 
-/** Trafic cumulé d'une journée, pour l'historique envoyé à FamilyControl. */
-data class TrafficDay(val date: String, val mobileBytes: Long, val wifiBytes: Long)
-
 enum class DataState {
-    OK,      // sous le seuil d'alerte, liste blanche active, pas de coupure en cours
+    OK,      // sous le seuil d'alerte
-    WARNING, // proche ou au-delà du forfait (>= 80%), liste blanche active, pas de coupure en cours
+    WARNING, // proche ou au-delà du forfait (>= 80 %)
-    CUT,     // coupure totale cyclique en cours (indépendant du dépassement de forfait)
+    CUT,     // le serveur coupe l'accès (mode « coupé » ou « liste blanche »)
-    WIFI     // Wi-Fi actif, aucun filtrage (sauf si filtrage Wi-Fi activé séparément)
+    WIFI     // Wi-Fi actif
 }

app/src/main/java/com/jttools/datacontrol/data/SecretBox.kt

@@ -0,0 +1,51 @@
+package com.jttools.datacontrol.data
+
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import android.util.Base64
+import java.security.KeyStore
+import javax.crypto.Cipher
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.crypto.spec.GCMParameterSpec
+
+/**
+ * Chiffrement des secrets (jeton de l'appareil, clé privée WireGuard) par une clé AES de l'Android
+ * Keystore : la clé ne sort jamais du matériel, une copie des fichiers de l'application ne suffit pas.
+ * Format : « v1:<base64(iv + chiffré)> ».
+ */
+object SecretBox {
+    private const val ALIAS = "datacontrol_secrets"
+    private const val TRANSFORMATION = "AES/GCM/NoPadding"
+
+    private fun key(): SecretKey {
+        val ks = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
+        (ks.getKey(ALIAS, null) as? SecretKey)?.let { return it }
+        val gen = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
+        gen.init(
+            KeyGenParameterSpec.Builder(ALIAS, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
+                .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+                .setKeySize(256)
+                .build()
+        )
+        return gen.generateKey()
+    }
+
+    fun encrypt(plain: String): String {
+        val cipher = Cipher.getInstance(TRANSFORMATION).apply { init(Cipher.ENCRYPT_MODE, key()) }
+        val out = cipher.iv + cipher.doFinal(plain.toByteArray(Charsets.UTF_8))
+        return "v1:" + Base64.encodeToString(out, Base64.NO_WRAP)
+    }
+
+    /** null si la valeur est absente ou illisible (clé du Keystore perdue : il faut se ré-associer). */
+    fun decrypt(stored: String?): String? {
+        if (stored.isNullOrEmpty() || !stored.startsWith("v1:")) return null
+        return runCatching {
+            val raw = Base64.decode(stored.removePrefix("v1:"), Base64.NO_WRAP)
+            val cipher = Cipher.getInstance(TRANSFORMATION)
+            cipher.init(Cipher.DECRYPT_MODE, key(), GCMParameterSpec(128, raw, 0, 12))
+            String(cipher.doFinal(raw, 12, raw.size - 12), Charsets.UTF_8)
+        }.getOrNull()
+    }
+}

app/src/main/java/com/jttools/datacontrol/data/SettingsRepository.kt

@@ -2,27 +2,34 @@ package com.jttools.datacontrol.data
 
 import android.content.Context
 import android.os.SystemClock
-import com.jttools.datacontrol.log.AppLog
+import androidx.datastore.preferences.core.Preferences
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.doublePreferencesKey
 import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.core.stringSetPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
+import com.jttools.datacontrol.log.AppLog
+import com.jttools.datacontrol.remote.FamilyLink
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
 import java.time.LocalDate
 import javax.inject.Inject
 import javax.inject.Singleton
 
 private val Context.dataStore by preferencesDataStore(name = "datacontrol_settings")
 
+/** Évènement à transmettre au serveur, gardé tant qu'il n'est pas parti (tunnel coupé, serveur injoignable). */
+data class PendingEvent(val type: String, val detail: String, val at: Long)
+
 @Singleton
 class SettingsRepository @Inject constructor(
     @ApplicationContext private val context: Context
@@ -34,42 +41,50 @@ class SettingsRepository @Inject constructor(
         val OVERAGE_PRICE_PER_MO = doublePreferencesKey("overage_price_per_mo")
         val PLAN_START_DATE_EPOCH_DAY = longPreferencesKey("plan_start_date_epoch_day")
         val AUTO_RESET_ENABLED = booleanPreferencesKey("auto_reset_enabled")
-        val CUTOFF_INTERVAL_MINUTES = intPreferencesKey("cutoff_interval_minutes")
         val BASELINE_MOBILE_BYTES = longPreferencesKey("baseline_mobile_bytes")
-        val WHITELISTED_PACKAGES = stringSetPreferencesKey("whitelisted_packages")
-        val WHITELISTED_PACKAGES_WIFI = stringSetPreferencesKey("whitelisted_packages_wifi")
-        val WIFI_FILTER_ENABLED = booleanPreferencesKey("wifi_filter_enabled")
-        val SHOW_SYSTEM_APPS = booleanPreferencesKey("show_system_apps")
         val PASSWORD_HASH = stringPreferencesKey("password_hash")
         val PASSWORD_SALT = stringPreferencesKey("password_salt")
         val PASSWORD_RESET_V1_DONE = booleanPreferencesKey("password_reset_v1_done")
-        val CUTOFF_ANCHOR_MILLIS = longPreferencesKey("cutoff_anchor_millis")
-        val CUTOFF_IN_PULSE = booleanPreferencesKey("cutoff_in_pulse")
-        val CUTOFF_PULSE_START_MILLIS = longPreferencesKey("cutoff_pulse_start_millis")
-        val FAMILY_ID = stringPreferencesKey("family_id")
-        val DEVICE_ID = stringPreferencesKey("device_id")
-        val REMOTE_CONFIG_VERSION = longPreferencesKey("remote_config_version")
-        val RULES_JSON = stringPreferencesKey("rules_json")
-        val FIREBASE_API_KEY = stringPreferencesKey("firebase_api_key")
-        val FIREBASE_APP_ID = stringPreferencesKey("firebase_app_id")
-        val FIREBASE_PROJECT_ID = stringPreferencesKey("firebase_project_id")
-        val USAGE_DAY = stringPreferencesKey("usage_day")
-        val USAGE_JSON = stringPreferencesKey("usage_json")
-        val TRAFFIC_DAY = stringPreferencesKey("traffic_day")
-        val TRAFFIC_MOBILE_ACC = longPreferencesKey("traffic_mobile_acc")
-        val TRAFFIC_WIFI_ACC = longPreferencesKey("traffic_wifi_acc")
-        val TRAFFIC_LAST_MOBILE = longPreferencesKey("traffic_last_mobile")
-        val TRAFFIC_LAST_OTHER = longPreferencesKey("traffic_last_other")
         val PASSWORD_FAILS = intPreferencesKey("password_fails")
         val PASSWORD_LOCK_UNTIL = longPreferencesKey("password_lock_until")
+        val RULES_JSON = stringPreferencesKey("rules_json")
+        val PARENTAL_LOCKED = booleanPreferencesKey("parental_locked")
+        val USAGE_DAY = stringPreferencesKey("usage_day")
+        val USAGE_JSON = stringPreferencesKey("usage_json")
         val CLOCK_SKEW_MS = longPreferencesKey("clock_skew_ms")
         val CLOCK_ZONE = stringPreferencesKey("clock_zone")
+        // v0.2 : liaison familyd
+        val LINK_JSON = stringPreferencesKey("link_json")
+        val LINK_TOKEN_ENC = stringPreferencesKey("link_token_enc")
+        val WG_PRIVATE_ENC = stringPreferencesKey("wg_private_enc")
+        val SERVER_MODE = stringPreferencesKey("server_mode")
+        val BLOCK_INSTALLS = booleanPreferencesKey("block_installs")
+        val SERVER_MODE_REASON = stringPreferencesKey("server_mode_reason")
+        val POLICY_VERSION = longPreferencesKey("policy_version")
+        val EVENT_QUEUE = stringPreferencesKey("event_queue")
+        val MIGRATED_V02 = booleanPreferencesKey("migrated_v02")
+        val PENDING_PROVISION = stringPreferencesKey("pending_provision")
     }
 
+    /** Clés de la v0.1 (Firebase, liste blanche locale, coupure cyclique locale) retirées à la mise à jour. */
+    private val obsoleteKeys: List<Preferences.Key<*>> = listOf(
+        intPreferencesKey("cutoff_interval_minutes"), stringSetPreferencesKey("whitelisted_packages"),
+        stringSetPreferencesKey("whitelisted_packages_wifi"), booleanPreferencesKey("wifi_filter_enabled"),
+        booleanPreferencesKey("show_system_apps"), longPreferencesKey("cutoff_anchor_millis"),
+        booleanPreferencesKey("cutoff_in_pulse"), longPreferencesKey("cutoff_pulse_start_millis"),
+        stringPreferencesKey("family_id"), stringPreferencesKey("device_id"),
+        longPreferencesKey("remote_config_version"), stringPreferencesKey("firebase_api_key"),
+        stringPreferencesKey("firebase_app_id"), stringPreferencesKey("firebase_project_id"),
+        stringPreferencesKey("traffic_day"), longPreferencesKey("traffic_mobile_acc"),
+        longPreferencesKey("traffic_wifi_acc"), longPreferencesKey("traffic_last_mobile"),
+        longPreferencesKey("traffic_last_other")
+    )
+
     private companion object {
         const val FREE_ATTEMPTS = 3
         const val LOCK_BASE_MS = 30_000L
         const val LOCK_MAX_MS = 15 * 60_000L
+        const val EVENT_QUEUE_MAX = 100
     }
 
     val settingsFlow: Flow<AppSettings> = context.dataStore.data.map { prefs ->
@@ -81,45 +96,50 @@ class SettingsRepository @Inject constructor(
             overagePricePerMoEuro = prefs[Keys.OVERAGE_PRICE_PER_MO] ?: defaults.overagePricePerMoEuro,
             planStartDateEpochDay = prefs[Keys.PLAN_START_DATE_EPOCH_DAY] ?: defaults.planStartDateEpochDay,
             autoResetEnabled = prefs[Keys.AUTO_RESET_ENABLED] ?: defaults.autoResetEnabled,
-            cutoffIntervalMinutes = prefs[Keys.CUTOFF_INTERVAL_MINUTES] ?: defaults.cutoffIntervalMinutes,
             baselineMobileBytesAtReset = prefs[Keys.BASELINE_MOBILE_BYTES] ?: defaults.baselineMobileBytesAtReset,
-            whitelistedPackages = prefs[Keys.WHITELISTED_PACKAGES] ?: defaults.whitelistedPackages,
-            whitelistedPackagesWifi = prefs[Keys.WHITELISTED_PACKAGES_WIFI] ?: defaults.whitelistedPackagesWifi,
-            wifiFilterEnabled = prefs[Keys.WIFI_FILTER_ENABLED] ?: defaults.wifiFilterEnabled,
-            showSystemApps = prefs[Keys.SHOW_SYSTEM_APPS] ?: defaults.showSystemApps,
             passwordHash = prefs[Keys.PASSWORD_HASH],
             passwordSalt = prefs[Keys.PASSWORD_SALT],
-            cutoffCycleAnchorMillis = prefs[Keys.CUTOFF_ANCHOR_MILLIS],
-            cutoffInPulse = prefs[Keys.CUTOFF_IN_PULSE] ?: defaults.cutoffInPulse,
-            cutoffPulseStartMillis = prefs[Keys.CUTOFF_PULSE_START_MILLIS] ?: defaults.cutoffPulseStartMillis,
-            familyId = prefs[Keys.FAMILY_ID],
-            deviceId = prefs[Keys.DEVICE_ID],
-            remoteConfigVersion = prefs[Keys.REMOTE_CONFIG_VERSION] ?: defaults.remoteConfigVersion,
             rulesJson = prefs[Keys.RULES_JSON],
-            firebase = run {
+            link = FamilyLink.fromJson(prefs[Keys.LINK_JSON]),
-                val k = prefs[Keys.FIREBASE_API_KEY]; val a = prefs[Keys.FIREBASE_APP_ID]; val p = prefs[Keys.FIREBASE_PROJECT_ID]
+            serverMode = prefs[Keys.SERVER_MODE] ?: defaults.serverMode,
-                if (k.isNullOrBlank() || a.isNullOrBlank() || p.isNullOrBlank()) null
+            serverModeReason = prefs[Keys.SERVER_MODE_REASON] ?: defaults.serverModeReason,
-                else com.jttools.datacontrol.remote.FirebaseConfig(k, a, p)
+            policyVersion = prefs[Keys.POLICY_VERSION] ?: defaults.policyVersion,
-            }
+            parentalLocked = prefs[Keys.PARENTAL_LOCKED] ?: defaults.parentalLocked,
+            blockInstalls = prefs[Keys.BLOCK_INSTALLS] ?: defaults.blockInstalls
         )
     }
 
+    /** Passage à la v0.2 : l'ancien appairage Firebase et le filtrage local ne servent plus. */
+    suspend fun migrateToV02() {
+        context.dataStore.edit { prefs ->
+            if (prefs[Keys.MIGRATED_V02] == true) return@edit
+            obsoleteKeys.forEach { prefs.remove(it) }
+            prefs.remove(Keys.RULES_JSON)
+            // L'ancien contrôle (pare-feu local) est remplacé par le tunnel : à réactiver après appairage.
+            prefs[Keys.CONTROL_ENABLED] = false
+            prefs[Keys.MIGRATED_V02] = true
+        }
+    }
+
     suspend fun setControlEnabled(enabled: Boolean) {
         context.dataStore.edit { it[Keys.CONTROL_ENABLED] = enabled }
     }
 
+    /** Verrouillage parental plein écran (commande « plock » du parent, levé par un code du serveur). */
+    suspend fun setParentalLocked(locked: Boolean) {
+        context.dataStore.edit { it[Keys.PARENTAL_LOCKED] = locked }
+    }
+
     suspend fun updatePlan(
         planLimitMo: Long,
         planPriceEuro: Double,
         overagePricePerMoEuro: Double,
-        cutoffIntervalMinutes: Int,
         autoResetEnabled: Boolean
     ) {
         context.dataStore.edit { prefs ->
             prefs[Keys.PLAN_LIMIT_MO] = planLimitMo
             prefs[Keys.PLAN_PRICE_EURO] = planPriceEuro
             prefs[Keys.OVERAGE_PRICE_PER_MO] = overagePricePerMoEuro
-            prefs[Keys.CUTOFF_INTERVAL_MINUTES] = cutoffIntervalMinutes
             prefs[Keys.AUTO_RESET_ENABLED] = autoResetEnabled
         }
     }
@@ -129,22 +149,6 @@ class SettingsRepository @Inject constructor(
         context.dataStore.edit { it[Keys.PLAN_START_DATE_EPOCH_DAY] = date.toEpochDay() }
     }
 
-    suspend fun setWhitelistedPackages(packages: Set<String>) {
-        context.dataStore.edit { it[Keys.WHITELISTED_PACKAGES] = packages }
-    }
-
-    suspend fun setWhitelistedPackagesWifi(packages: Set<String>) {
-        context.dataStore.edit { it[Keys.WHITELISTED_PACKAGES_WIFI] = packages }
-    }
-
-    suspend fun setWifiFilterEnabled(enabled: Boolean) {
-        context.dataStore.edit { it[Keys.WIFI_FILTER_ENABLED] = enabled }
-    }
-
-    suspend fun setShowSystemApps(show: Boolean) {
-        context.dataStore.edit { it[Keys.SHOW_SYSTEM_APPS] = show }
-    }
-
     /** Réinitialise le compteur de consommation : nouvelle date de début + nouvelle base de référence. */
     suspend fun resetPlan(currentMobileBytes: Long, startDate: LocalDate = LocalDate.now()) {
         context.dataStore.edit { prefs ->
@@ -161,18 +165,15 @@ class SettingsRepository @Inject constructor(
     /**
      * Force la consommation affichée à [consumedMo] sans changer la date de début du cycle, en
      * recalculant la base de référence à partir du compteur système actuel ([currentTotalBytes]).
-     * Utile pour recaler l'app sur le décompte opérateur réel.
+     * La base peut devenir négative : c'est volontaire (voir [UsageRepository.consumedBytesSince]).
-     *
-     * La base peut devenir négative (ex: valeur saisie supérieure au compteur TrafficStats depuis
-     * le dernier redémarrage de l'appareil) : c'est volontaire, ne pas la borner à 0 sous peine
-     * d'écraser silencieusement la valeur saisie par l'utilisateur. [UsageRepository.consumedBytesSince]
-     * et [UsageRepository.hasCounterReset] gèrent correctement une base négative.
      */
     suspend fun setConsumedMo(consumedMo: Long, currentTotalBytes: Long) {
         val baseline = currentTotalBytes - UsageRepository.moToBytes(consumedMo)
         context.dataStore.edit { it[Keys.BASELINE_MOBILE_BYTES] = baseline }
     }
 
+    // --- Mot de passe ----------------------------------------------------------------------
+
     /** Définit (ou supprime, si [password] est vide/null) le mot de passe de verrouillage. */
     suspend fun setPassword(password: String?) {
         if (password.isNullOrBlank()) {
@@ -192,19 +193,6 @@ class SettingsRepository @Inject constructor(
         }
     }
 
-    /** Horloge de référence de [com.jttools.datacontrol.guard.GuardEngine] : décalage (ms) et fuseau retenus. */
-    suspend fun trustedClock(): Pair<Long, String?> {
-        val prefs = context.dataStore.data.first()
-        return (prefs[Keys.CLOCK_SKEW_MS] ?: 0L) to prefs[Keys.CLOCK_ZONE]
-    }
-
-    suspend fun setTrustedClock(skewMs: Long, zoneId: String) {
-        context.dataStore.edit {
-            if (skewMs == 0L) it.remove(Keys.CLOCK_SKEW_MS) else it[Keys.CLOCK_SKEW_MS] = skewMs
-            it[Keys.CLOCK_ZONE] = zoneId
-        }
-    }
-
     /**
      * Réinitialisation unique (v0.1.2) du mot de passe de verrouillage : le supprime une seule fois,
      * puis mémorise qu'elle a eu lieu pour ne pas effacer un mot de passe défini ensuite.
@@ -278,88 +266,20 @@ class SettingsRepository @Inject constructor(
         return if (s < 60) "Trop d'essais : réessayez dans $s s." else "Trop d'essais : réessayez dans ${(s + 59) / 60} min."
     }
 
-    /**
+    // --- Horloge de référence et temps d'écran --------------------------------------------------
-     * Persiste l'état du cycle de coupure automatique, pour que le minuteur ne reparte pas de
+
-     * zéro si [DataMonitorService] est tué puis relancé par le système avant la fin de l'intervalle
+    /** Horloge de référence de [com.jttools.datacontrol.guard.GuardEngine] : décalage (ms) et fuseau retenus. */
-     * (fréquent sur les ROM qui tuent agressivement les apps en arrière-plan sans exemption batterie).
+    suspend fun trustedClock(): Pair<Long, String?> {
-     */
+        val prefs = context.dataStore.data.first()
-    suspend fun setCutoffCycleState(anchorMillis: Long?, inPulse: Boolean, pulseStartMillis: Long) {
+        return (prefs[Keys.CLOCK_SKEW_MS] ?: 0L) to prefs[Keys.CLOCK_ZONE]
-        context.dataStore.edit { prefs ->
-            if (anchorMillis == null) prefs.remove(Keys.CUTOFF_ANCHOR_MILLIS) else prefs[Keys.CUTOFF_ANCHOR_MILLIS] = anchorMillis
-            prefs[Keys.CUTOFF_IN_PULSE] = inPulse
-            prefs[Keys.CUTOFF_PULSE_START_MILLIS] = pulseStartMillis
-        }
     }
 
-    suspend fun setPairing(familyId: String?, deviceId: String?) {
+    suspend fun setTrustedClock(skewMs: Long, zoneId: String) {
         context.dataStore.edit {
-            if (familyId == null || deviceId == null) {
+            if (skewMs == 0L) it.remove(Keys.CLOCK_SKEW_MS) else it[Keys.CLOCK_SKEW_MS] = skewMs
-                it.remove(Keys.FAMILY_ID)
+            it[Keys.CLOCK_ZONE] = zoneId
-                it.remove(Keys.DEVICE_ID)
-                it.remove(Keys.REMOTE_CONFIG_VERSION)
-                it.remove(Keys.RULES_JSON)
-            } else {
-                it[Keys.FAMILY_ID] = familyId
-                it[Keys.DEVICE_ID] = deviceId
-                it[Keys.REMOTE_CONFIG_VERSION] = 0L
         }
     }
-    }
-
-    /**
-     * Applique une configuration envoyée par FamilyControl. Chaque champ null est ignoré.
-     * [version] (horodatage de l'écriture côté parent) évite de ré-appliquer une ancienne
-     * configuration au redémarrage et d'écraser un réglage local plus récent.
-     */
-    suspend fun applyRemoteConfig(
-        version: Long,
-        controlEnabled: Boolean?,
-        whitelistedPackages: Set<String>?,
-        whitelistedPackagesWifi: Set<String>?,
-        wifiFilterEnabled: Boolean?,
-        planLimitMo: Long?,
-        cutoffIntervalMinutes: Int?,
-        rulesJson: String?
-    ) {
-        context.dataStore.edit { prefs ->
-            if ((prefs[Keys.REMOTE_CONFIG_VERSION] ?: 0L) >= version) return@edit
-            rulesJson?.let { prefs[Keys.RULES_JSON] = it }
-            prefs[Keys.REMOTE_CONFIG_VERSION] = version
-            controlEnabled?.let { prefs[Keys.CONTROL_ENABLED] = it }
-            whitelistedPackages?.let { prefs[Keys.WHITELISTED_PACKAGES] = it }
-            whitelistedPackagesWifi?.let { prefs[Keys.WHITELISTED_PACKAGES_WIFI] = it }
-            wifiFilterEnabled?.let { prefs[Keys.WIFI_FILTER_ENABLED] = it }
-            planLimitMo?.takeIf { it > 0 }?.let { prefs[Keys.PLAN_LIMIT_MO] = it }
-            cutoffIntervalMinutes?.takeIf { it > 0 }?.let { prefs[Keys.CUTOFF_INTERVAL_MINUTES] = it }
-        }
-    }
-
-    /**
-     * Cumule le trafic de la journée à partir des compteurs système (qui repartent de zéro au
-     * redémarrage : un compteur inférieur au précédent est traité comme un redémarrage).
-     * [otherBytes] = trafic non mobile (Wi-Fi, etc.) = total - mobile.
-     */
-    suspend fun accumulateTraffic(today: String, mobileBytes: Long, otherBytes: Long): TrafficDay {
-        var result = TrafficDay(today, 0L, 0L)
-        context.dataStore.edit { prefs ->
-            val sameDay = prefs[Keys.TRAFFIC_DAY] == today
-            var mobileAcc = if (sameDay) prefs[Keys.TRAFFIC_MOBILE_ACC] ?: 0L else 0L
-            var wifiAcc = if (sameDay) prefs[Keys.TRAFFIC_WIFI_ACC] ?: 0L else 0L
-            val lastMobile = prefs[Keys.TRAFFIC_LAST_MOBILE]
-            val lastOther = prefs[Keys.TRAFFIC_LAST_OTHER]
-            if (lastMobile != null && lastOther != null) {
-                mobileAcc += if (mobileBytes >= lastMobile) mobileBytes - lastMobile else mobileBytes
-                wifiAcc += if (otherBytes >= lastOther) otherBytes - lastOther else otherBytes
-            }
-            prefs[Keys.TRAFFIC_DAY] = today
-            prefs[Keys.TRAFFIC_MOBILE_ACC] = mobileAcc
-            prefs[Keys.TRAFFIC_WIFI_ACC] = wifiAcc
-            prefs[Keys.TRAFFIC_LAST_MOBILE] = mobileBytes
-            prefs[Keys.TRAFFIC_LAST_OTHER] = otherBytes
-            result = TrafficDay(today, mobileAcc, wifiAcc)
-        }
-        return result
-    }
 
     suspend fun loadUsage(): Pair<String, String>? {
         val prefs = context.dataStore.data.first()
@@ -375,16 +295,90 @@ class SettingsRepository @Inject constructor(
         }
     }
 
-    /** Enregistre (ou efface, si null) la configuration Firebase saisie dans l'application. */
+    // --- Liaison familyd --------------------------------------------------------------------
-    suspend fun setFirebaseConfig(config: com.jttools.datacontrol.remote.FirebaseConfig?) {
+
+    /** Enregistre l'appairage. Le jeton et la clé privée sont chiffrés par l'Android Keystore. */
+    suspend fun savePairing(link: FamilyLink, deviceToken: String, wgPrivateKey: String) {
+        val token = SecretBox.encrypt(deviceToken)
+        val key = SecretBox.encrypt(wgPrivateKey)
         context.dataStore.edit {
-            if (config == null) {
+            it[Keys.LINK_JSON] = link.toJson()
-                it.remove(Keys.FIREBASE_API_KEY); it.remove(Keys.FIREBASE_APP_ID); it.remove(Keys.FIREBASE_PROJECT_ID)
+            it[Keys.LINK_TOKEN_ENC] = token
-            } else {
+            it[Keys.WG_PRIVATE_ENC] = key
-                it[Keys.FIREBASE_API_KEY] = config.apiKey
+            it[Keys.SERVER_MODE] = "open"
-                it[Keys.FIREBASE_APP_ID] = config.appId
+            it[Keys.SERVER_MODE_REASON] = ""
-                it[Keys.FIREBASE_PROJECT_ID] = config.projectId
+            it[Keys.POLICY_VERSION] = 0L
+            it.remove(Keys.RULES_JSON)
+            it.remove(Keys.EVENT_QUEUE)
         }
     }
+
+    suspend fun clearPairing() {
+        context.dataStore.edit {
+            listOf(Keys.LINK_JSON, Keys.LINK_TOKEN_ENC, Keys.WG_PRIVATE_ENC, Keys.SERVER_MODE,
+                Keys.SERVER_MODE_REASON, Keys.POLICY_VERSION, Keys.RULES_JSON, Keys.EVENT_QUEUE).forEach { k -> it.remove(k) }
+            it[Keys.CONTROL_ENABLED] = false
         }
+    }
+
+    suspend fun deviceToken(): String? = SecretBox.decrypt(context.dataStore.data.first()[Keys.LINK_TOKEN_ENC])
+
+    suspend fun wgPrivateKey(): String? = SecretBox.decrypt(context.dataStore.data.first()[Keys.WG_PRIVATE_ENC])
+
+    /** Consigne reçue du serveur (mode réseau en cours et règles d'applications). */
+    suspend fun applyServerPolicy(version: Long, mode: String, reason: String, rulesJson: String?, blockInstalls: Boolean) {
+        context.dataStore.edit {
+            it[Keys.POLICY_VERSION] = version
+            it[Keys.SERVER_MODE] = mode
+            it[Keys.SERVER_MODE_REASON] = reason
+            it[Keys.BLOCK_INSTALLS] = blockInstalls
+            if (rulesJson.isNullOrBlank() || rulesJson == "{}") it.remove(Keys.RULES_JSON) else it[Keys.RULES_JSON] = rulesJson
+        }
+    }
+
+    // --- Appairage prévu par le QR de provisionnement -------------------------------------------
+
+    /** (serveur, code, nom) reçus du QR de provisionnement, en attente d'appairage. */
+    suspend fun pendingProvision(): Triple<String, String, String>? = runCatching {
+        val o = JSONObject(context.dataStore.data.first()[Keys.PENDING_PROVISION] ?: return null)
+        Triple(o.getString("url"), o.getString("code"), o.optString("name"))
+    }.getOrNull()
+
+    suspend fun setPendingProvision(url: String, code: String, name: String) {
+        context.dataStore.edit {
+            it[Keys.PENDING_PROVISION] = JSONObject().put("url", url).put("code", code).put("name", name).toString()
+        }
+    }
+
+    suspend fun clearPendingProvision() {
+        context.dataStore.edit { it.remove(Keys.PENDING_PROVISION) }
+    }
+
+    // --- File des évènements --------------------------------------------------------------------
+
+    suspend fun queueEvent(event: PendingEvent) {
+        context.dataStore.edit {
+            val list = parseQueue(it[Keys.EVENT_QUEUE]) + event
+            it[Keys.EVENT_QUEUE] = serializeQueue(list.takeLast(EVENT_QUEUE_MAX))
+        }
+    }
+
+    suspend fun pendingEvents(): List<PendingEvent> = parseQueue(context.dataStore.data.first()[Keys.EVENT_QUEUE])
+
+    /** Retire de la file les [count] premiers évènements (envoyés avec succès). */
+    suspend fun dropEvents(count: Int) {
+        context.dataStore.edit {
+            val rest = parseQueue(it[Keys.EVENT_QUEUE]).drop(count)
+            if (rest.isEmpty()) it.remove(Keys.EVENT_QUEUE) else it[Keys.EVENT_QUEUE] = serializeQueue(rest)
+        }
+    }
+
+    private fun parseQueue(json: String?): List<PendingEvent> = runCatching {
+        val a = JSONArray(json ?: return emptyList())
+        (0 until a.length()).map { a.getJSONObject(it) }
+            .map { PendingEvent(it.getString("type"), it.optString("detail"), it.getLong("at")) }
+    }.getOrDefault(emptyList())
+
+    private fun serializeQueue(list: List<PendingEvent>): String =
+        JSONArray(list.map { JSONObject().put("type", it.type).put("detail", it.detail).put("at", it.at) }).toString()
 }

app/src/main/java/com/jttools/datacontrol/guard/AppGuardService.kt

@@ -1,6 +1,13 @@
 package com.jttools.datacontrol.guard
 
 import android.accessibilityservice.AccessibilityService
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.PixelFormat
+import android.os.Build
+import android.view.Gravity
+import android.view.WindowManager
+import android.widget.TextView
 import android.content.BroadcastReceiver
 import android.content.ComponentName
 import android.content.Context
@@ -11,8 +18,13 @@ import android.os.PowerManager
 import android.provider.Settings
 import android.telecom.TelecomManager
 import android.view.accessibility.AccessibilityEvent
+import android.view.accessibility.AccessibilityNodeInfo
 import android.view.inputmethod.InputMethodManager
+import com.jttools.datacontrol.data.SettingsRepository
 import com.jttools.datacontrol.log.AppLog
+import com.jttools.datacontrol.remote.RemoteControl
+import com.jttools.datacontrol.remote.RemoteSync
+import kotlinx.coroutines.flow.map
 import com.jttools.datacontrol.service.MonitorStateHolder
 import com.jttools.datacontrol.service.NetworkTransport
 import dagger.hilt.android.AndroidEntryPoint
@@ -22,8 +34,11 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.launch
+import java.io.ByteArrayOutputStream
 import javax.inject.Inject
+import kotlin.coroutines.resume
 
 /**
  * Détecte l'application au premier plan (service d'accessibilité, sans lire le contenu des écrans)
@@ -35,6 +50,13 @@ class AppGuardService : AccessibilityService() {
 
     @Inject lateinit var engine: GuardEngine
     @Inject lateinit var stateHolder: MonitorStateHolder
+    @Inject lateinit var remoteControl: RemoteControl
+    @Inject lateinit var remoteSync: RemoteSync
+    @Inject lateinit var settings: SettingsRepository
+
+    @Volatile private var parentalLocked = false
+
+    private var shareBanner: TextView? = null
 
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
     private var exempt: Set<String> = emptySet()
@@ -62,14 +84,119 @@ class AppGuardService : AccessibilityService() {
             while (isActive) {
                 delay(CHECK_INTERVAL_MS)
                 engine.tick()
-                currentPkg?.let { enforce(it) }
+                if (parentalLocked) enforceParentalLock() else currentPkg?.let { enforce(it) }
             }
         }
+        // Suit le verrouillage parental demandé par le parent (ramène l'écran de blocage si l'enfant le quitte).
+        scope.launch {
+            settings.settingsFlow.map { it.parentalLocked }.collect { locked ->
+                parentalLocked = locked
+                if (locked) enforceParentalLock()
+            }
+        }
+        startScreenShareLoop()
+    }
+
+    /**
+     * Partage d'écran demandé par le parent : capture l'écran (API 30+) et l'envoie au serveur, tant que
+     * [RemoteControl.screenShareUntil] n'est pas atteint. Un bandeau « Écran partagé » reste affiché.
+     */
+    private fun startScreenShareLoop() = scope.launch {
+        while (isActive) {
+            if (!remoteControl.screenSharing) {
+                hideBanner()
+                delay(1_000)
+                continue
+            }
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+                AppLog.w("Écran", "Partage d'écran indisponible (Android 11 minimum)")
+                remoteSync.pushEvent("screen_unsupported", "Partage d'écran impossible : Android 11 minimum")
+                delay(5_000)
+                continue
+            }
+            showBanner()
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                val jpeg = captureJpeg()
+                if (jpeg != null) remoteSync.pushScreen(jpeg)
+            }
+            delay(SCREEN_INTERVAL_MS)
+        }
+    }
+
+    @androidx.annotation.RequiresApi(Build.VERSION_CODES.R)
+    private suspend fun captureJpeg(): ByteArray? {
+        val bitmap = suspendCancellableCoroutine<Bitmap?> { cont ->
+            runCatching {
+                takeScreenshot(android.view.Display.DEFAULT_DISPLAY, mainExecutor,
+                    object : TakeScreenshotCallback {
+                        override fun onSuccess(result: ScreenshotResult) {
+                            val bmp = runCatching {
+                                Bitmap.wrapHardwareBuffer(result.hardwareBuffer, result.colorSpace)
+                                    ?.copy(Bitmap.Config.ARGB_8888, false)
+                            }.getOrNull()
+                            result.hardwareBuffer.close()
+                            if (cont.isActive) cont.resume(bmp)
+                        }
+                        override fun onFailure(errorCode: Int) {
+                            if (cont.isActive) cont.resume(null)
+                        }
+                    })
+            }.onFailure { if (cont.isActive) cont.resume(null) }
+        } ?: return null
+        return runCatching {
+            val scaled = scaleDown(bitmap, MAX_WIDTH)
+            if (scaled !== bitmap) bitmap.recycle()
+            ByteArrayOutputStream().use { out ->
+                scaled.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, out)
+                scaled.recycle()
+                out.toByteArray()
+            }
+        }.getOrNull()
+    }
+
+    private fun scaleDown(bmp: Bitmap, maxWidth: Int): Bitmap {
+        if (bmp.width <= maxWidth) return bmp
+        val h = bmp.height * maxWidth / bmp.width
+        return Bitmap.createScaledBitmap(bmp, maxWidth, h, true)
+    }
+
+    private fun showBanner() {
+        if (shareBanner != null) return
+        val wm = getSystemService(WindowManager::class.java)
+        val tv = TextView(this).apply {
+            text = getString(com.jttools.datacontrol.R.string.screen_shared_banner)
+            setBackgroundColor(Color.parseColor("#C62828"))
+            setTextColor(Color.WHITE)
+            setPadding(24, 12, 24, 12)
+            textSize = 13f
+        }
+        val lp = WindowManager.LayoutParams(
+            WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.WRAP_CONTENT,
+            WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
+            WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE,
+            PixelFormat.TRANSLUCENT
+        ).apply { gravity = Gravity.TOP }
+        runCatching { wm.addView(tv, lp); shareBanner = tv }
+    }
+
+    private fun hideBanner() {
+        shareBanner?.let { runCatching { getSystemService(WindowManager::class.java).removeView(it) } }
+        shareBanner = null
     }
 
     override fun onAccessibilityEvent(event: AccessibilityEvent?) {
         if (event?.eventType != AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) return
         val pkg = event.packageName?.toString() ?: return
+        // Auto-validation du consentement au partage d'écran (dialogue système), en mode propriétaire.
+        if (remoteControl.awaitingScreenConsent && confirmProjectionConsent()) {
+            remoteControl.awaitingScreenConsent = false
+            return
+        }
+        // Verrouillage parental : toute tentative de passer à une autre application ramène l'écran de blocage.
+        if (parentalLocked && pkg != packageName) {
+            enforceParentalLock()
+            return
+        }
         if (pkg in exemptPackages()) {
             currentPkg = null
             lastLoggedPkg = null   // revenir ensuite dans la même application compte comme une nouvelle utilisation
@@ -90,6 +217,28 @@ class AppGuardService : AccessibilityService() {
         engine.check(pkg)?.let { enforce(pkg, it) }
     }
 
+    /** Ramène l'écran de verrouillage parental au premier plan tant que le parent n'a pas levé le verrou. */
+    private fun enforceParentalLock() {
+        runCatching { startActivity(ParentalLockActivity.intent(this)) }
+    }
+
+    /** Clique « Démarrer maintenant » sur le dialogue système de partage d'écran (MediaProjection). */
+    private fun confirmProjectionConsent(): Boolean {
+        val root = rootInActiveWindow ?: return false
+        val btn = findClickableByText(root, CONSENT_WORDS)
+        return btn != null && btn.performAction(AccessibilityNodeInfo.ACTION_CLICK)
+    }
+
+    private fun findClickableByText(node: AccessibilityNodeInfo?, re: Regex): AccessibilityNodeInfo? {
+        if (node == null) return null
+        val text = (node.text?.toString() ?: "") + " " + (node.contentDescription?.toString() ?: "")
+        if (node.isClickable && re.containsMatchIn(text)) return node
+        for (i in 0 until node.childCount) {
+            findClickableByText(node.getChild(i), re)?.let { return it }
+        }
+        return null
+    }
+
     private fun enforce(pkg: String, block: Block) {
         val now = System.currentTimeMillis()
         if (now - lastBlockAt < 2_000) return
@@ -118,12 +267,12 @@ class AppGuardService : AccessibilityService() {
         }
         if (pkg == packageName) return "AUTORISÉ (DataControl, toujours exempté) [$net]" to false
         if (!snap.serviceRunning) return "libre (contrôle désactivé) [$net]" to false
-        return when (snap.appliedMode) {
+        if (!snap.tunnelUp) return "NON FILTRÉ (tunnel coupé) [$net]" to false
-            "BLOCK_ALL" -> "BLOQUÉ (coupure totale en cours) [$net]" to true
+        return when (snap.serverMode) {
-            "FILTER" ->
+            "cut" -> "BLOQUÉ (Internet coupé par le serveur) [$net]" to true
-                if (pkg in snap.effectiveWhitelist) "AUTORISÉ (liste blanche) [$net]" to false
+            "allowlist" -> "LIMITÉ (liste blanche du serveur) [$net]" to true
-                else "BLOQUÉ (hors liste blanche) [$net]" to true
+            "blocklist" -> "filtré (liste noire du serveur) [$net]" to false
-            else -> "libre (aucun filtrage sur ce réseau) [$net]" to false
+            else -> "filtré par le serveur (accès libre) [$net]" to false
         }
     }
 
@@ -153,14 +302,19 @@ class AppGuardService : AccessibilityService() {
     override fun onInterrupt() = Unit
 
     override fun onDestroy() {
+        hideBanner()
         runCatching { unregisterReceiver(screenReceiver) }
         scope.cancel()
         super.onDestroy()
     }
 
     companion object {
+        private val CONSENT_WORDS = Regex("démarrer|commencer|autoriser|accepter|start now|\\ballow\\b", RegexOption.IGNORE_CASE)
         private const val CHECK_INTERVAL_MS = 10_000L
         private const val EXEMPT_TTL_MS = 5 * 60_000L
+        private const val SCREEN_INTERVAL_MS = 1_500L
+        private const val MAX_WIDTH = 720
+        private const val JPEG_QUALITY = 50
 
         fun isEnabled(context: Context): Boolean {
             val enabled = Settings.Secure.getString(

app/src/main/java/com/jttools/datacontrol/guard/ParentalLockActivity.kt

@@ -0,0 +1,183 @@
+package com.jttools.datacontrol.guard
+
+import android.app.admin.DevicePolicyManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.view.WindowManager
+import androidx.activity.ComponentActivity
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Lock
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.lifecycleScope
+import com.jttools.datacontrol.R
+import com.jttools.datacontrol.admin.AdminController
+import com.jttools.datacontrol.data.SettingsRepository
+import com.jttools.datacontrol.remote.RemoteSync
+import com.jttools.datacontrol.ui.theme.DataControlTheme
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * Écran de verrouillage parental plein écran : affiché sur commande du parent (« plock »), il reste
+ * au premier plan jusqu'à la saisie d'un code à usage unique généré par le serveur (action "unlock").
+ *
+ * Le code remplace le mot de passe local : seul le parent, en dictant le code, peut déverrouiller.
+ * En mode propriétaire de l'appareil, l'écran est épinglé (lock task) : accueil et récents neutralisés.
+ * Sinon, l'activité se remet d'elle-même au premier plan si l'enfant tente de la quitter.
+ */
+@AndroidEntryPoint
+class ParentalLockActivity : ComponentActivity() {
+
+    @Inject lateinit var remoteSync: RemoteSync
+    @Inject lateinit var settings: SettingsRepository
+
+    private var unlocked = false
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+            setShowWhenLocked(true)
+            setTurnScreenOn(true)
+        }
+        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        // Le bouton Retour ne ferme pas le verrou.
+        onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
+            override fun handleOnBackPressed() = Unit
+        })
+
+        setContent {
+            DataControlTheme {
+                var code by remember { mutableStateOf("") }
+                var error by remember { mutableStateOf<String?>(null) }
+                var busy by remember { mutableStateOf(false) }
+                val scope = androidx.compose.runtime.rememberCoroutineScope()
+
+                Surface(Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.errorContainer) {
+                    Column(
+                        Modifier.fillMaxSize().padding(32.dp),
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.Center
+                    ) {
+                        Icon(Icons.Filled.Lock, contentDescription = null, modifier = Modifier.size(72.dp))
+                        Spacer(Modifier.height(20.dp))
+                        Text(
+                            getString(R.string.parental_lock_title),
+                            style = MaterialTheme.typography.headlineSmall, textAlign = TextAlign.Center
+                        )
+                        Spacer(Modifier.height(10.dp))
+                        Text(
+                            getString(R.string.parental_lock_message),
+                            style = MaterialTheme.typography.bodyLarge, textAlign = TextAlign.Center
+                        )
+                        Spacer(Modifier.height(24.dp))
+                        OutlinedTextField(
+                            value = code,
+                            onValueChange = { code = it.take(20); error = null },
+                            label = { Text(getString(R.string.parental_lock_code_label)) },
+                            keyboardOptions = KeyboardOptions(capitalization = KeyboardCapitalization.Characters),
+                            isError = error != null,
+                            singleLine = true,
+                            modifier = Modifier.fillMaxWidth()
+                        )
+                        error?.let {
+                            Spacer(Modifier.height(6.dp))
+                            Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+                        }
+                        Spacer(Modifier.height(20.dp))
+                        Button(
+                            enabled = !busy,
+                            onClick = {
+                                busy = true
+                                scope.launch {
+                                    val result = remoteSync.verifyUnlock(code, "unlock")
+                                    if (result == null) {
+                                        settings.setParentalLocked(false)   // l'observateur ferme l'écran
+                                    } else {
+                                        error = result
+                                        busy = false
+                                    }
+                                }
+                            },
+                            modifier = Modifier.fillMaxWidth()
+                        ) { Text(getString(R.string.parental_lock_unlock)) }
+                    }
+                }
+            }
+        }
+
+        // Le parent peut aussi déverrouiller à distance (« punlock ») : on ferme dès que l'état repasse à faux.
+        lifecycleScope.launch {
+            settings.settingsFlow.map { it.parentalLocked }.collect { locked ->
+                if (!locked) {
+                    unlocked = true
+                    stopPinning()
+                    finish()
+                }
+            }
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        startPinning()
+    }
+
+    override fun onStop() {
+        super.onStop()
+        // Tant que le verrou tient, toute tentative de quitter (Accueil, bascule) ramène l'écran.
+        if (!unlocked && !isFinishing) {
+            startActivity(intent(this))
+        }
+    }
+
+    /** Épingle l'écran en mode propriétaire : l'accueil et les récents ne peuvent plus l'écarter. */
+    private fun startPinning() {
+        if (!AdminController.isDeviceOwner(this)) return
+        runCatching {
+            val dpm = getSystemService(DevicePolicyManager::class.java)
+            dpm.setLockTaskPackages(AdminController.component(this), arrayOf(packageName))
+            startLockTask()
+        }
+    }
+
+    private fun stopPinning() {
+        runCatching { stopLockTask() }
+    }
+
+    companion object {
+        fun intent(context: Context): Intent =
+            Intent(context, ParentalLockActivity::class.java)
+                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+    }
+}

app/src/main/java/com/jttools/datacontrol/remote/AppDeployer.kt

@@ -0,0 +1,193 @@
+package com.jttools.datacontrol.remote
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageInstaller
+import android.os.Build
+import android.os.SystemClock
+import androidx.core.app.NotificationCompat
+import com.jttools.datacontrol.BuildConfig
+import com.jttools.datacontrol.R
+import com.jttools.datacontrol.data.UpdateManager
+import com.jttools.datacontrol.log.AppLog
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Mise à jour de DataControl poussée depuis le serveur familyd (bouton « Déployer » de l'espace parents).
+ *
+ * L'APK est téléchargé dans le tunnel, son empreinte SHA-256 vérifiée, puis confié à l'installateur
+ * d'Android : installation silencieuse en mode propriétaire de l'appareil ; sinon, une notification
+ * « Touchez pour installer » (Android impose alors une confirmation). Android refuse de toute façon un
+ * APK qui ne porte pas la signature de l'application installée.
+ */
+@Singleton
+class AppDeployer @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    private var lastVersion: String? = null
+    private var lastAttemptAt = 0L
+
+    /** [order] : {"version", "url", "sha256", "size"} reçu dans la consigne du serveur. */
+    suspend fun handle(order: JSONObject, apiBase: String, report: suspend (String, String) -> Unit) =
+        withContext(Dispatchers.IO) {
+            val version = order.optString("version")
+            if (version.isBlank()) return@withContext
+            // Déploiement forcé (option du parent) : réinstalle même version comprise, en ignorant les garde-fous.
+            val force = order.optBoolean("force", false)
+            if (!force && !UpdateManager.isNewer(version, BuildConfig.VERSION_NAME)) return@withContext
+            val now = SystemClock.elapsedRealtime()
+            if (!force && version == lastVersion && now - lastAttemptAt < RETRY_MS) return@withContext
+            lastVersion = version
+            lastAttemptAt = now
+            AppLog.i("Mise à jour", "Déploiement de DataControl $version demandé par le serveur" + if (force) " (forcé)" else "")
+            try {
+                val file = download(apiBase + order.getString("url"), order.getString("sha256").lowercase(), version)
+                install(file, version)
+            } catch (e: Exception) {
+                AppLog.e("Mise à jour", "Déploiement de $version impossible", e)
+                report("update_failed", "DataControl $version : ${e.message ?: e.javaClass.simpleName}")
+            }
+        }
+
+    private fun download(url: String, sha256: String, version: String): File {
+        val dir = File(context.cacheDir, "updates").apply { mkdirs() }
+        dir.listFiles()?.forEach { it.delete() }
+        val file = File(dir, "DataControl-$version.apk")
+        val conn = (URL(url).openConnection() as HttpURLConnection).apply {
+            connectTimeout = 15_000
+            readTimeout = 60_000
+        }
+        val digest = MessageDigest.getInstance("SHA-256")
+        try {
+            if (conn.responseCode != HttpURLConnection.HTTP_OK) error("téléchargement refusé (HTTP ${conn.responseCode})")
+            var total = 0L
+            conn.inputStream.use { input ->
+                file.outputStream().use { out ->
+                    val buf = ByteArray(64 * 1024)
+                    while (true) {
+                        val n = input.read(buf)
+                        if (n < 0) break
+                        total += n
+                        if (total > MAX_SIZE) error("APK trop volumineux")
+                        digest.update(buf, 0, n)
+                        out.write(buf, 0, n)
+                    }
+                }
+            }
+        } finally {
+            conn.disconnect()
+        }
+        val got = digest.digest().joinToString("") { "%02x".format(it) }
+        if (got != sha256) {
+            file.delete()
+            error("empreinte SHA-256 différente de celle annoncée par le serveur")
+        }
+        return file
+    }
+
+    private fun install(file: File, version: String) {
+        val installer = context.packageManager.packageInstaller
+        val params = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL).apply {
+            setAppPackageName(context.packageName)
+            setSize(file.length())
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                setRequireUserAction(PackageInstaller.SessionParams.USER_ACTION_NOT_REQUIRED)
+            }
+        }
+        val id = installer.createSession(params)
+        installer.openSession(id).use { session ->
+            session.openWrite("base.apk", 0, file.length()).use { out ->
+                file.inputStream().use { it.copyTo(out) }
+                session.fsync(out)
+            }
+            val result = Intent(context, InstallResultReceiver::class.java).putExtra(EXTRA_VERSION, version)
+            val flags = PendingIntent.FLAG_UPDATE_CURRENT or
+                (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) PendingIntent.FLAG_MUTABLE else 0)
+            session.commit(PendingIntent.getBroadcast(context, id, result, flags).intentSender)
+        }
+        AppLog.i("Mise à jour", "DataControl $version confié à l'installateur d'Android")
+    }
+
+    companion object {
+        const val EXTRA_VERSION = "version"
+        private const val RETRY_MS = 30 * 60_000L
+        private const val MAX_SIZE = 100L * 1024 * 1024
+    }
+}
+
+/** Résultat de l'installation : confirmation à demander à l'utilisateur, succès ou échec (signalé au parent). */
+class InstallResultReceiver : BroadcastReceiver() {
+
+    @EntryPoint
+    @InstallIn(SingletonComponent::class)
+    interface Deps {
+        fun remoteSync(): RemoteSync
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val version = intent.getStringExtra(AppDeployer.EXTRA_VERSION).orEmpty()
+        when (val status = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE)) {
+            PackageInstaller.STATUS_PENDING_USER_ACTION -> {
+                val confirm = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
+                } else {
+                    @Suppress("DEPRECATION") intent.getParcelableExtra(Intent.EXTRA_INTENT)
+                } ?: return
+                AppLog.i("Mise à jour", "DataControl $version : confirmation de l'utilisateur demandée")
+                notifyConfirm(context, confirm.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK), version)
+            }
+            PackageInstaller.STATUS_SUCCESS -> AppLog.i("Mise à jour", "DataControl $version installé")
+            else -> {
+                val msg = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE) ?: "code $status"
+                AppLog.e("Mise à jour", "Installation de DataControl $version refusée : $msg")
+                val pending = goAsync()
+                val remote = EntryPointAccessors.fromApplication(context.applicationContext, Deps::class.java).remoteSync()
+                CoroutineScope(Dispatchers.IO).launch {
+                    try {
+                        remote.pushEvent("update_failed", "DataControl $version : $msg")
+                    } finally {
+                        pending.finish()
+                    }
+                }
+            }
+        }
+    }
+
+    private fun notifyConfirm(context: Context, confirm: Intent, version: String) {
+        val nm = context.getSystemService(NotificationManager::class.java)
+        nm.createNotificationChannel(NotificationChannel(CHANNEL, "Mises à jour", NotificationManager.IMPORTANCE_HIGH))
+        val pi = PendingIntent.getActivity(context, 0, confirm, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
+        nm.notify(NOTIF_ID, NotificationCompat.Builder(context, CHANNEL)
+            .setSmallIcon(R.drawable.ic_notification)
+            .setContentTitle("Mise à jour de DataControl $version")
+            .setContentText("Touchez pour installer la version envoyée par le parent.")
+            .setContentIntent(pi)
+            .setAutoCancel(true)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .build())
+    }
+
+    private companion object {
+        const val CHANNEL = "datacontrol_updates"
+        const val NOTIF_ID = 3101
+    }
+}

app/src/main/java/com/jttools/datacontrol/remote/DeviceReporter.kt

@@ -9,31 +9,36 @@ import android.content.pm.PackageManager
 import android.location.Location
 import android.location.LocationListener
 import android.location.LocationManager
-import android.net.TrafficStats
 import android.os.BatteryManager
+import android.os.Build
 import android.os.Looper
+import android.provider.Settings
 import androidx.core.content.ContextCompat
 import com.jttools.datacontrol.BuildConfig
 import com.jttools.datacontrol.admin.AdminController
 import com.jttools.datacontrol.data.SettingsRepository
 import com.jttools.datacontrol.guard.AppGuardService
 import com.jttools.datacontrol.guard.GuardEngine
-import com.jttools.datacontrol.service.FirewallVpnService
 import com.jttools.datacontrol.service.MonitorStateHolder
+import com.jttools.datacontrol.service.NetworkTransport
+import com.jttools.datacontrol.vpn.TunnelManager
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
-import java.time.LocalDate
+import org.json.JSONObject
 import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Envoie à FamilyControl (via [RemoteSync]) l'état de l'appareil : batterie, position,
+ * Envoie au serveur familyd l'état du téléphone : batterie, position, réseau, protections actives,
- * état du pare-feu, historique de trafic. Ne fait rien tant que l'appareil n'est pas associé.
+ * temps d'écran, applications installées. Le volume de données n'est plus envoyé : le serveur le
+ * mesure lui-même sur le tunnel. Ne fait rien tant que l'appareil n'est pas associé.
  */
 @Singleton
 class DeviceReporter @Inject constructor(
@@ -41,18 +46,20 @@ class DeviceReporter @Inject constructor(
     private val remote: RemoteSync,
     private val settingsRepository: SettingsRepository,
     private val stateHolder: MonitorStateHolder,
-    private val guardEngine: GuardEngine
+    private val guardEngine: GuardEngine,
+    private val tunnel: TunnelManager
 ) {
     private var started = false
-    private var lastBatterySent = -1 to false
+    private var battery: JSONObject? = null
-    private var lastBatterySentAt = 0L
+    private var location: JSONObject? = null
-    private var lastLocationSentAt = 0L
+    private var lastSignature = ""
-    private var lastStateSignature = ""
+    private var lastSentAt = 0L
-    private var lastStateSentAt = 0L
+    private var lastLocationAt = 0L
     private var locationRegistered = false
     private var lastGuardEnabled: Boolean? = null
     private var lastUsageSentTotal = -1L
     private var appsPushJob: Job? = null
+    private var appsSent = false
 
     fun start(scope: CoroutineScope) {
         if (started) return
@@ -61,7 +68,13 @@ class DeviceReporter @Inject constructor(
 
         val batteryReceiver = object : BroadcastReceiver() {
             override fun onReceive(c: Context?, intent: Intent?) {
-                if (intent != null) scope.launch { pushBattery(intent) }
+                intent ?: return
+                val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
+                val scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100)
+                if (level < 0 || scale <= 0) return
+                val status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1)
+                val charging = status == BatteryManager.BATTERY_STATUS_CHARGING || status == BatteryManager.BATTERY_STATUS_FULL
+                battery = JSONObject().put("level", level * 100 / scale).put("charging", charging)
             }
         }
         // Récepteur enregistré dynamiquement : ACTION_BATTERY_CHANGED n'est pas livrable via le manifeste.
@@ -90,92 +103,68 @@ class DeviceReporter @Inject constructor(
             ContextCompat.RECEIVER_NOT_EXPORTED
         )
 
+        // Changement de réseau : envoyé tout de suite (le forfait et la coupure cyclique en dépendent).
+        scope.launch {
+            stateHolder.snapshot.map { it.transport }.distinctUntilChanged().collect {
+                if (settingsRepository.settingsFlow.first().isPaired) pushState(force = true)
+            }
+        }
+
         scope.launch {
             while (isActive) {
                 val s = settingsRepository.settingsFlow.first()
-                if (s.isPaired) {
+                if (s.isPaired && tunnel.up.value) {
-                    registerLocationUpdates(scope)
+                    registerLocationUpdates()
-                    pushState()
+                    pushState(force = false)
-                    pushTraffic()
                     pushUsage()
+                    if (!appsSent) appsSent = remote.pushApps()
                 }
                 delay(REPORT_INTERVAL_MS)
             }
         }
     }
 
-    private suspend fun pushBattery(intent: Intent) {
+    private suspend fun pushState(force: Boolean) {
-        if (!settingsRepository.settingsFlow.first().isPaired) return
-        val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
-        val scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100)
-        if (level < 0 || scale <= 0) return
-        val percent = level * 100 / scale
-        val status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1)
-        val charging = status == BatteryManager.BATTERY_STATUS_CHARGING || status == BatteryManager.BATTERY_STATUS_FULL
-        val now = System.currentTimeMillis()
-        val changed = (percent to charging) != lastBatterySent
-        if (!changed || now - lastBatterySentAt < BATTERY_MIN_INTERVAL_MS && percent > LOW_BATTERY) return
-        lastBatterySent = percent to charging
-        lastBatterySentAt = now
-        remote.pushDevice(mapOf("battery" to mapOf("level" to percent, "charging" to charging, "at" to now)))
-    }
-
-    private suspend fun pushState() {
-        val s = settingsRepository.settingsFlow.first()
-        val snap = stateHolder.snapshot.value
         val guardEnabled = AppGuardService.isEnabled(context)
         if (lastGuardEnabled == true && !guardEnabled) {
             remote.pushEvent("guard_disabled", "Service d'accessibilité désactivé : les limites d'applications ne sont plus appliquées")
         }
         lastGuardEnabled = guardEnabled
-        val state = mapOf(
+        val state = JSONObject()
-            "controlEnabled" to s.controlEnabled,
+            .put("transport", when (stateHolder.snapshot.value.transport) {
-            "transport" to snap.transport.name,
+                NetworkTransport.CELLULAR -> "mobile"
-            "firewallFault" to snap.firewallFault,
+                NetworkTransport.WIFI -> "wifi"
-            "vpnPrepared" to FirewallVpnService.isPrepared(context),
+                else -> "none"
-            "tunnelActive" to FirewallVpnService.tunnelActive,
+            })
-            "adminActive" to AdminController.isActive(context),
+            .put("app_version", BuildConfig.VERSION_NAME)
-            "guardEnabled" to guardEnabled,
+            .put("android", Build.VERSION.RELEASE)
-            "autoTime" to (android.provider.Settings.Global.getInt(
+            .put("guard_enabled", guardEnabled)
-                context.contentResolver, android.provider.Settings.Global.AUTO_TIME, 1
+            .put("admin_active", AdminController.isActive(context))
-            ) == 1),
+            .put("device_owner", AdminController.isDeviceOwner(context))
-            "rulesActive" to !guardEngine.rules.isEmpty,
+            .put("always_on_vpn", com.jttools.datacontrol.admin.OwnerPolicy.alwaysOnState(context).let { (on, lock) ->
-            "consumedMo" to snap.consumedMo,
+                JSONObject().put("enabled", on).put("lockdown", lock)
-            "planLimitMo" to s.planLimitMo,
+            })
-            "cutoffIntervalMinutes" to s.cutoffIntervalMinutes,
+            .put("auto_time", Settings.Global.getInt(context.contentResolver, Settings.Global.AUTO_TIME, 1) == 1)
-            "wifiFilterEnabled" to s.wifiFilterEnabled,
+        battery?.let { state.put("battery", it) }
-            "whitelistedPackages" to s.whitelistedPackages.sorted(),
+        location?.let { state.put("location", it) }
-            "whitelistedPackagesWifi" to s.whitelistedPackagesWifi.sorted(),
-            "appliedConfigAt" to s.remoteConfigVersion,
-            "appVersion" to BuildConfig.VERSION_NAME
-        )
         val signature = state.toString()
         val now = System.currentTimeMillis()
-        // Évite les écritures inutiles ; un battement toutes les 5 min indique que l'appareil est vivant.
+        // Évite les envois inutiles ; un battement toutes les 5 min suffit quand rien ne change.
-        if (signature == lastStateSignature && now - lastStateSentAt < HEARTBEAT_MS) return
+        if (!force && signature == lastSignature && now - lastSentAt < HEARTBEAT_MS) return
-        lastStateSignature = signature
+        if (remote.pushState(state)) {
-        lastStateSentAt = now
+            lastSignature = signature
-        remote.pushDevice(mapOf("state" to (state + ("at" to now))))
+            lastSentAt = now
         }
-
-    private suspend fun pushTraffic() {
-        val mobile = TrafficStats.getMobileRxBytes() + TrafficStats.getMobileTxBytes()
-        val total = TrafficStats.getTotalRxBytes() + TrafficStats.getTotalTxBytes()
-        if (mobile < 0 || total < 0) return
-        val day = settingsRepository.accumulateTraffic(LocalDate.now().toString(), mobile, (total - mobile).coerceAtLeast(0L))
-        remote.pushTraffic(day)
     }
 
     private suspend fun pushUsage() {
         val u = guardEngine.usage()
-        // Ne renvoie que si le temps d'écran a évolué (ou changement de jour).
         if (u.totalMs == lastUsageSentTotal) return
-        lastUsageSentTotal = u.totalMs
+        if (remote.pushUsage(u.date, u.totalMs, u.appMs)) lastUsageSentTotal = u.totalMs
-        remote.pushUsage(u.date, u.totalMs, u.appMs)
     }
 
     @SuppressLint("MissingPermission")
-    private fun registerLocationUpdates(scope: CoroutineScope) {
+    private fun registerLocationUpdates() {
         if (locationRegistered) return
         val fine = ContextCompat.checkSelfPermission(context, android.Manifest.permission.ACCESS_FINE_LOCATION) ==
             PackageManager.PERMISSION_GRANTED
@@ -183,7 +172,7 @@ class DeviceReporter @Inject constructor(
             PackageManager.PERMISSION_GRANTED
         if (!fine && !coarse) return
         val lm = context.getSystemService(LocationManager::class.java)
-        val listener = LocationListener { loc -> scope.launch { pushLocation(loc) } }
+        val listener = LocationListener { loc -> onLocation(loc) }
         var registered = false
         for (provider in listOf(LocationManager.NETWORK_PROVIDER, LocationManager.GPS_PROVIDER)) {
             if (provider == LocationManager.GPS_PROVIDER && !fine) continue
@@ -196,25 +185,17 @@ class DeviceReporter @Inject constructor(
         locationRegistered = registered
     }
 
-    private suspend fun pushLocation(loc: Location) {
+    private fun onLocation(loc: Location) {
         val now = System.currentTimeMillis()
-        if (now - lastLocationSentAt < LOCATION_MIN_SEND_MS) return
+        if (now - lastLocationAt < LOCATION_MIN_SEND_MS) return
-        lastLocationSentAt = now
+        lastLocationAt = now
-        remote.pushDevice(
+        location = JSONObject().put("lat", loc.latitude).put("lng", loc.longitude)
-            mapOf(
+            .put("accuracy", loc.accuracy.toDouble()).put("at", now)
-                "location" to mapOf(
-                    "lat" to loc.latitude, "lng" to loc.longitude,
-                    "accuracy" to loc.accuracy.toDouble(), "at" to now
-                )
-            )
-        )
     }
 
     private companion object {
         const val REPORT_INTERVAL_MS = 60_000L
         const val HEARTBEAT_MS = 5 * 60_000L
-        const val BATTERY_MIN_INTERVAL_MS = 2 * 60_000L
-        const val LOW_BATTERY = 20
         const val LOCATION_INTERVAL_MS = 5 * 60_000L
         const val LOCATION_MIN_DISTANCE_M = 50f
         const val LOCATION_MIN_SEND_MS = 60_000L

app/src/main/java/com/jttools/datacontrol/remote/FamilyApi.kt

@@ -0,0 +1,120 @@
+package com.jttools.datacontrol.remote
+
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URL
+
+/** Erreur renvoyée par le serveur ([code] HTTP) ou réseau ([code] = 0), avec un message lisible. */
+class ApiException(val code: Int, message: String) : IOException(message)
+
+/**
+ * Client de l'API familyd. Appels bloquants : à lancer sur Dispatchers.IO.
+ * Les routes des appareils passent par le tunnel ([FamilyLink.apiBase], http://10.78.0.1:8100,
+ * déjà chiffré par WireGuard) ; l'appairage passe par l'adresse publique en HTTPS.
+ */
+class FamilyApi(private val apiBase: String, private val token: String) {
+
+    fun policy(): JSONObject = JSONObject(request("GET", "$apiBase/api/device/policy", token, null))
+
+    fun serverTime(): Long = JSONObject(request("GET", "$apiBase/api/device/time", token, null)).getLong("time")
+
+    fun state(state: JSONObject) {
+        request("POST", "$apiBase/api/device/state", token, state)
+    }
+
+    fun usage(date: String, totalMs: Long, apps: Map<String, Long>) {
+        request("POST", "$apiBase/api/device/usage", token,
+            JSONObject().put("date", date).put("total_ms", totalMs).put("apps", JSONObject(apps as Map<*, *>)))
+    }
+
+    fun event(type: String, detail: String, at: Long) {
+        request("POST", "$apiBase/api/device/events", token,
+            JSONObject().put("type", type).put("detail", detail.take(500)).put("at", at))
+    }
+
+    fun apps(apps: JSONArray) {
+        request("POST", "$apiBase/api/device/apps", token, JSONObject().put("apps", apps))
+    }
+
+    /** Attente longue des commandes du parent (verrouillage, son, partage d'écran). */
+    fun commands(waitSeconds: Int): JSONArray =
+        JSONObject(request("GET", "$apiBase/api/device/commands?wait=$waitSeconds", token, null, waitSeconds * 1000 + 5000))
+            .optJSONArray("commands") ?: JSONArray()
+
+    /** Envoie une image de l'écran (JPEG) pendant un partage. */
+    fun screen(jpeg: ByteArray) {
+        request("POST", "$apiBase/api/device/screen", token, jpeg, "image/jpeg")
+    }
+
+    /**
+     * Vérifie auprès du serveur le code dicté par le parent (désactivation / déverrouillage).
+     * Renvoie sans erreur si le code est accepté ; lève [ApiException] (404) sinon.
+     */
+    fun unlock(code: String, action: String) {
+        request("POST", "$apiBase/api/device/unlock", token,
+            JSONObject().put("code", code).put("action", action))
+    }
+
+    /** Signale au serveur qu'une commande a été exécutée (audit). */
+    fun commandAck(id: String, status: String, detail: String) {
+        request("POST", "$apiBase/api/device/command-ack", token,
+            JSONObject().put("id", id).put("status", status).put("detail", detail.take(300)))
+    }
+
+    companion object {
+        private const val CONNECT_TIMEOUT_MS = 10_000
+        private const val READ_TIMEOUT_MS = 15_000
+
+        /** Appairage (public, HTTPS) : renvoie la réponse brute, à lire avec [FamilyLink.fromPairResponse]. */
+        fun pair(serverUrl: String, code: String, publicKey: String, name: String, model: String, appVersion: String): String {
+            require(serverUrl.startsWith("https://")) { "L'adresse du serveur doit commencer par https://" }
+            val body = JSONObject().put("code", code).put("public_key", publicKey).put("name", name)
+                .put("model", model).put("app_version", appVersion)
+            return request("POST", "${serverUrl.trimEnd('/')}/api/pair", null, body)
+        }
+
+        fun request(method: String, url: String, token: String?, body: JSONObject?, readTimeoutMs: Int = READ_TIMEOUT_MS): String {
+            return request(method, url, token, body?.toString()?.toByteArray(Charsets.UTF_8),
+                "application/json; charset=utf-8", readTimeoutMs)
+        }
+
+        fun request(method: String, url: String, token: String?, body: ByteArray?, contentType: String,
+                    readTimeoutMs: Int = READ_TIMEOUT_MS): String {
+            val conn = try {
+                (URL(url).openConnection() as HttpURLConnection).apply {
+                    requestMethod = method
+                    connectTimeout = CONNECT_TIMEOUT_MS
+                    readTimeout = readTimeoutMs
+                    setRequestProperty("Accept", "application/json")
+                    token?.let { setRequestProperty("Authorization", "Bearer $it") }
+                    if (body != null) {
+                        doOutput = true
+                        setRequestProperty("Content-Type", contentType)
+                        setFixedLengthStreamingMode(body.size)
+                    }
+                }
+            } catch (e: IOException) {
+                throw ApiException(0, "Serveur injoignable : ${e.message}")
+            }
+            try {
+                if (body != null) conn.outputStream.use { it.write(body) }
+                val code = conn.responseCode
+                val text = (if (code in 200..299) conn.inputStream else conn.errorStream)
+                    ?.bufferedReader()?.use { it.readText() }.orEmpty()
+                if (code !in 200..299) {
+                    val detail = runCatching { JSONObject(text).optString("detail") }.getOrNull()
+                    throw ApiException(code, detail?.takeIf { it.isNotBlank() } ?: "Erreur du serveur ($code)")
+                }
+                return text
+            } catch (e: ApiException) {
+                throw e
+            } catch (e: IOException) {
+                throw ApiException(0, "Serveur injoignable : ${e.message}")
+            } finally {
+                conn.disconnect()
+            }
+        }
+    }
+}

app/src/main/java/com/jttools/datacontrol/remote/FamilyLink.kt

@@ -0,0 +1,113 @@
+package com.jttools.datacontrol.remote
+
+import org.json.JSONArray
+import org.json.JSONObject
+import java.net.URI
+import java.net.URLDecoder
+
+/**
+ * Liaison avec le serveur familyd, reçue à l'appairage (sans les secrets : jeton de l'appareil et clé
+ * privée WireGuard sont stockés à part, chiffrés par l'Android Keystore, voir SecretBox).
+ */
+data class FamilyLink(
+    val serverUrl: String,
+    val deviceId: String,
+    val name: String,
+    val address: String,
+    val dns: String,
+    val mtu: Int,
+    val serverPublicKey: String,
+    val endpoint: String,
+    val allowedIps: List<String>,
+    val keepalive: Int,
+    val apiBase: String
+) {
+    /** Adresse du téléphone dans le tunnel, sans le /32. */
+    val tunnelIp: String get() = address.substringBefore('/')
+
+    fun toJson(): String = JSONObject()
+        .put("serverUrl", serverUrl).put("deviceId", deviceId).put("name", name)
+        .put("address", address).put("dns", dns).put("mtu", mtu)
+        .put("serverPublicKey", serverPublicKey).put("endpoint", endpoint)
+        .put("allowedIps", JSONArray(allowedIps)).put("keepalive", keepalive).put("apiBase", apiBase)
+        .toString()
+
+    /** Configuration WireGuard au format wg-quick (lue par la bibliothèque officielle). */
+    fun wgQuickConfig(privateKey: String): String = buildString {
+        appendLine("[Interface]")
+        appendLine("PrivateKey = $privateKey")
+        appendLine("Address = $address")
+        appendLine("DNS = $dns")
+        appendLine("MTU = $mtu")
+        appendLine()
+        appendLine("[Peer]")
+        appendLine("PublicKey = $serverPublicKey")
+        appendLine("Endpoint = $endpoint")
+        appendLine("AllowedIPs = ${allowedIps.joinToString(", ")}")
+        appendLine("PersistentKeepalive = $keepalive")
+    }
+
+    companion object {
+        fun fromJson(json: String?): FamilyLink? {
+            if (json.isNullOrBlank()) return null
+            return runCatching {
+                val o = JSONObject(json)
+                val ips = o.getJSONArray("allowedIps")
+                FamilyLink(
+                    serverUrl = o.getString("serverUrl"), deviceId = o.getString("deviceId"),
+                    name = o.optString("name"), address = o.getString("address"), dns = o.getString("dns"),
+                    mtu = o.optInt("mtu", 1280), serverPublicKey = o.getString("serverPublicKey"),
+                    endpoint = o.getString("endpoint"),
+                    allowedIps = (0 until ips.length()).map { ips.getString(it) },
+                    keepalive = o.optInt("keepalive", 25), apiBase = o.getString("apiBase")
+                )
+            }.getOrNull()
+        }
+
+        /** Réponse de POST /api/pair → liaison + jeton de l'appareil. */
+        fun fromPairResponse(serverUrl: String, json: String): Pair<FamilyLink, String> {
+            val o = JSONObject(json)
+            val wg = o.getJSONObject("wireguard")
+            val ips = wg.getJSONArray("allowed_ips")
+            val link = FamilyLink(
+                serverUrl = serverUrl, deviceId = o.getString("device_id"), name = o.optString("name"),
+                address = wg.getString("address"), dns = wg.getString("dns"), mtu = wg.optInt("mtu", 1280),
+                serverPublicKey = wg.getString("server_public_key"), endpoint = wg.getString("endpoint"),
+                allowedIps = (0 until ips.length()).map { ips.getString(it) },
+                keepalive = wg.optInt("persistent_keepalive", 25), apiBase = o.getString("api").trimEnd('/')
+            )
+            require(link.serverPublicKey.isNotBlank()) { "Le serveur n'a pas fourni sa clé WireGuard." }
+            return link to o.getString("token")
+        }
+    }
+}
+
+/**
+ * Ce que l'utilisateur saisit pour s'associer : le code seul (« ABCD 2345 »), ou le lien
+ * « familyd://pair?url=https://…&code=… » affiché par l'interface des parents.
+ */
+data class PairingInput(val serverUrl: String, val code: String) {
+    companion object {
+        const val DEFAULT_SERVER = "https://family.tuxtech.fr"
+        private val CODE = Regex("^[A-HJ-NP-Z2-9]{8}$")   // même alphabet que le serveur (sans I, O, 0, 1)
+
+        fun parse(input: String, defaultServer: String = DEFAULT_SERVER): PairingInput? {
+            val text = input.trim()
+            if (text.startsWith("familyd://", ignoreCase = true)) {
+                val query = runCatching { URI(text).rawQuery }.getOrNull() ?: return null
+                val params = query.split('&').mapNotNull {
+                    val (k, v) = it.split('=', limit = 2).takeIf { p -> p.size == 2 } ?: return@mapNotNull null
+                    k to URLDecoder.decode(v, "UTF-8")
+                }.toMap()
+                val url = params["url"]?.trimEnd('/') ?: return null
+                val code = normalize(params["code"] ?: return null) ?: return null
+                if (!url.startsWith("https://")) return null
+                return PairingInput(url, code)
+            }
+            return normalize(text)?.let { PairingInput(defaultServer, it) }
+        }
+
+        private fun normalize(code: String): String? =
+            code.uppercase().replace(" ", "").replace("-", "").takeIf { CODE.matches(it) }
+    }
+}

app/src/main/java/com/jttools/datacontrol/remote/FirebaseConfig.kt

@@ -1,29 +0,0 @@
-package com.jttools.datacontrol.remote
-
-import org.json.JSONObject
-
-/** Identifiants d'un projet Firebase (ceux du bloc `firebaseConfig` de la console). */
-data class FirebaseConfig(val apiKey: String, val appId: String, val projectId: String) {
-    companion object {
-        /**
-         * Lit ce que l'utilisateur colle : le bloc `firebaseConfig` de la console (JavaScript), un JSON,
-         * ou une chaîne « fc1:… » partagée par FamilyControl. Renvoie null si apiKey, appId ou projectId manque.
-         */
-        fun parse(input: String): FirebaseConfig? {
-            val text = input.trim()
-            if (text.startsWith("fc1:")) {
-                return runCatching {
-                    val json = JSONObject(String(java.util.Base64.getMimeDecoder().decode(text.removePrefix("fc1:")), Charsets.UTF_8))
-                    build(json.optString("apiKey"), json.optString("appId"), json.optString("projectId"))
-                }.getOrNull()
-            }
-            fun pick(name: String) =
-                Regex("""["']?$name["']?\s*[:=]\s*["']([^"']+)["']""").find(text)?.groupValues?.get(1)
-            return build(pick("apiKey"), pick("appId"), pick("projectId"))
-        }
-
-        private fun build(apiKey: String?, appId: String?, projectId: String?): FirebaseConfig? =
-            if (apiKey.isNullOrBlank() || appId.isNullOrBlank() || projectId.isNullOrBlank()) null
-            else FirebaseConfig(apiKey.trim(), appId.trim(), projectId.trim())
-    }
-}

app/src/main/java/com/jttools/datacontrol/remote/FirebaseGateway.kt

@@ -1,81 +0,0 @@
-package com.jttools.datacontrol.remote
-
-import android.content.Context
-import com.google.firebase.FirebaseApp
-import com.google.firebase.FirebaseOptions
-import com.google.firebase.auth.FirebaseAuth
-import com.google.firebase.firestore.FirebaseFirestore
-import com.jttools.datacontrol.BuildConfig
-import com.jttools.datacontrol.log.AppLog
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.tasks.await
-import javax.inject.Inject
-import javax.inject.Singleton
-
-/** État du lien Firebase : [generation] change à chaque (ré)initialisation, pour relancer les écoutes. */
-data class GatewayState(val generation: Int = 0, val enabled: Boolean = false, val projectId: String? = null)
-
-/**
- * Accès à Firebase (Auth anonyme + Firestore). La configuration se saisit dans l'application
- * (Réglages → Contrôle parental) et peut changer à tout moment ; à défaut, on retombe sur
- * `firebase.properties` (compilation). Sans configuration, [enabled] est faux et tout reste inerte.
- */
-@Singleton
-class FirebaseGateway @Inject constructor(
-    @ApplicationContext private val context: Context
-) {
-    private val _state = MutableStateFlow(GatewayState())
-    val state: StateFlow<GatewayState> = _state.asStateFlow()
-    val enabled: Boolean get() = _state.value.enabled
-
-    @Volatile private var app: FirebaseApp? = null
-    private var currentKey: String? = null
-
-    private fun buildConfigFallback(): FirebaseConfig? =
-        if (BuildConfig.FIREBASE_API_KEY.isNotBlank() && BuildConfig.FIREBASE_APP_ID.isNotBlank() &&
-            BuildConfig.FIREBASE_PROJECT_ID.isNotBlank()
-        ) FirebaseConfig(BuildConfig.FIREBASE_API_KEY, BuildConfig.FIREBASE_APP_ID, BuildConfig.FIREBASE_PROJECT_ID)
-        else null
-
-    /** Applique la configuration saisie [saved] (ou, à défaut, celle de compilation). Sans effet si elle n'a pas changé. */
-    @Synchronized
-    fun apply(saved: FirebaseConfig?) {
-        val cfg = saved ?: buildConfigFallback()
-        val key = cfg?.let { "${it.apiKey}|${it.appId}|${it.projectId}" }
-        if (key == currentKey && (key == null || app != null)) return
-
-        app?.let { runCatching { it.delete() } }
-        app = null
-        currentKey = key
-        if (cfg != null) {
-            app = runCatching {
-                FirebaseApp.initializeApp(
-                    context,
-                    FirebaseOptions.Builder()
-                        .setApiKey(cfg.apiKey)
-                        .setApplicationId(cfg.appId)
-                        .setProjectId(cfg.projectId)
-                        .build()
-                )
-            }.onFailure { AppLog.e("Firebase", "Initialisation impossible", it) }.getOrNull()
-        }
-        val ok = app != null
-        AppLog.i("Firebase", if (ok) "Configuré (projet ${cfg?.projectId})" else "Non configuré")
-        _state.value = GatewayState(_state.value.generation + 1, ok, cfg?.projectId?.takeIf { ok })
-    }
-
-    val db: FirebaseFirestore? get() = app?.let { FirebaseFirestore.getInstance(it) }
-    private val auth: FirebaseAuth? get() = app?.let { FirebaseAuth.getInstance(it) }
-
-    /** Identifiant de l'appareil côté Firebase (connexion anonyme, persistante). Null si indisponible. */
-    suspend fun ensureSignedIn(): String? {
-        val a = auth ?: return null
-        a.currentUser?.let { return it.uid }
-        return runCatching { a.signInAnonymously().await().user?.uid }
-            .onFailure { AppLog.w("Firebase", "Connexion anonyme impossible : ${it.message}") }
-            .getOrNull()
-    }
-}

app/src/main/java/com/jttools/datacontrol/remote/RemoteControl.kt

@@ -0,0 +1,175 @@
+package com.jttools.datacontrol.remote
+
+import android.app.admin.DevicePolicyManager
+import android.content.Context
+import android.media.AudioManager
+import android.os.Build
+import android.os.SystemClock
+import com.jttools.datacontrol.admin.AdminController
+import com.jttools.datacontrol.guard.AppGuardService
+import com.jttools.datacontrol.data.SettingsRepository
+import com.jttools.datacontrol.guard.ParentalLockActivity
+import com.jttools.datacontrol.log.AppLog
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Actions à distance demandées par le parent (via le serveur familyd) : verrouiller / mettre en veille,
+ * couper ou rétablir le son, partager l'écran. La boucle interroge le serveur en attente longue ; le
+ * partage d'écran est réalisé par le service d'accessibilité ([com.jttools.datacontrol.guard.AppGuardService]),
+ * qui observe [screenShareUntil].
+ *
+ * Le partage d'écran est toujours visible du téléphone (notification + bandeau « Écran partagé avec le parent »).
+ */
+@Singleton
+class RemoteControl @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val remote: RemoteSync,
+    private val settings: SettingsRepository,
+    private val ringer: Ringer
+) {
+    /** Instant (temps monotone) jusqu'auquel l'écran est partagé ; 0 = pas de partage. */
+    private val _screenShareUntil = MutableStateFlow(0L)
+    val screenShareUntil: StateFlow<Long> = _screenShareUntil.asStateFlow()
+
+    val screenSharing: Boolean get() = _screenShareUntil.value > SystemClock.elapsedRealtime()
+
+    /** Vrai pendant qu'on attend le consentement MediaProjection (le dialogue système est à l'écran). */
+    @Volatile var awaitingScreenConsent = false
+
+    private var started = false
+
+    fun start(scope: CoroutineScope) {
+        if (started) return
+        started = true
+        scope.launch(Dispatchers.IO) {
+            while (isActive) {
+                if (!settings.settingsFlow.first().isPaired) {
+                    delay(10_000)
+                    continue
+                }
+                val commands = remote.pollCommands(WAIT_SECONDS)
+                if (commands == null) {
+                    delay(5_000)       // tunnel coupé / serveur injoignable : on réessaie posément
+                    continue
+                }
+                for (i in 0 until commands.length()) {
+                    val cmd = commands.getJSONObject(i)
+                    val outcome = runCatching { handle(cmd) }
+                    val (status, detail) = outcome.getOrNull()
+                        ?: ("failed" to (outcome.exceptionOrNull()?.message ?: "erreur"))
+                    remote.ackCommand(cmd.optString("id"), status, detail)
+                }
+            }
+        }
+        // Fin automatique du partage d'écran à l'échéance.
+        scope.launch {
+            while (isActive) {
+                if (screenSharing) {
+                    delay(1_000)
+                } else {
+                    if (_screenShareUntil.value != 0L) _screenShareUntil.value = 0L
+                    delay(2_000)
+                }
+            }
+        }
+    }
+
+    /** Renvoie (statut, détail) pour l'audit : "done" ou "failed". */
+    private suspend fun handle(cmd: JSONObject): Pair<String, String> = when (cmd.optString("type")) {
+        "lock" -> lock()
+        "plock" -> parentalLock(true)
+        "punlock" -> parentalLock(false)
+        "mute" -> setMuted(true)
+        "unmute" -> setMuted(false)
+        "screen_start" -> startScreenShare(cmd.optInt("seconds", 120).coerceIn(10, 300))
+        "screen_stop" -> {
+            _screenShareUntil.value = 0L
+            awaitingScreenConsent = false
+            ScreenCaptureService.stop(context)
+            AppLog.i("Commande", "Partage d'écran arrêté")
+            "done" to ""
+        }
+        "ring" -> ringer.start(cmd.optInt("seconds", 60))
+        "ring_stop" -> {
+            ringer.stop(silent = false)
+            "done" to ""
+        }
+        else -> "failed" to "commande inconnue"
+    }
+
+    /**
+     * Verrouillage parental plein écran : affiche [ParentalLockActivity], que seul un code du serveur
+     * (dicté par le parent) peut lever. [lock] = false lève le verrou à distance.
+     */
+    private suspend fun parentalLock(lock: Boolean): Pair<String, String> {
+        settings.setParentalLocked(lock)
+        return if (lock) {
+            runCatching { context.startActivity(ParentalLockActivity.intent(context)) }
+            AppLog.w("Commande", "Verrouillage parental activé (code du serveur requis pour déverrouiller)")
+            "done" to "téléphone verrouillé"
+        } else {
+            AppLog.i("Commande", "Verrouillage parental levé par le parent")
+            "done" to "téléphone déverrouillé"
+        }
+    }
+
+    /** Démarre le partage d'écran : capture silencieuse par l'accessibilité (Android 11+) ou MediaProjection. */
+    private fun startScreenShare(seconds: Int): Pair<String, String> {
+        _screenShareUntil.value = SystemClock.elapsedRealtime() + seconds * 1000L
+        val silent = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && AppGuardService.isEnabled(context)
+        if (silent) {
+            awaitingScreenConsent = false
+            AppLog.i("Commande", "Partage d'écran démarré ($seconds s, accessibilité)")
+        } else if (!ScreenCaptureService.running) {
+            awaitingScreenConsent = true
+            runCatching { context.startActivity(ScreenConsentActivity.intent(context)) }
+                .onFailure { AppLog.w("Commande", "Lancement du partage MediaProjection impossible : ${it.message}") }
+            AppLog.i("Commande", "Partage d'écran démarré ($seconds s, MediaProjection)")
+        }
+        return "done" to "partage démarré"
+    }
+
+    private fun lock(): Pair<String, String> {
+        val dpm = context.getSystemService(DevicePolicyManager::class.java)
+        if (!AdminController.isActive(context)) {
+            AppLog.w("Commande", "Verrouillage impossible : DataControl n'est pas administrateur de l'appareil")
+            return "failed" to "DataControl n'est pas administrateur de l'appareil"
+        }
+        return runCatching { dpm.lockNow() }.fold(
+            onSuccess = { AppLog.i("Commande", "Téléphone verrouillé / mis en veille"); "done" to "" },
+            onFailure = { AppLog.w("Commande", "Verrouillage refusé : ${it.message}"); "failed" to (it.message ?: "refusé") }
+        )
+    }
+
+    private fun setMuted(muted: Boolean): Pair<String, String> {
+        val am = context.getSystemService(AudioManager::class.java)
+        val dir = if (muted) AudioManager.ADJUST_MUTE else AudioManager.ADJUST_UNMUTE
+        val streams = intArrayOf(
+            AudioManager.STREAM_MUSIC, AudioManager.STREAM_RING,
+            AudioManager.STREAM_NOTIFICATION, AudioManager.STREAM_SYSTEM
+        )
+        var any = false
+        for (s in streams) {
+            // Le son de la sonnerie peut exiger l'accès « Ne pas déranger » : on n'échoue pas pour autant.
+            if (runCatching { am.adjustStreamVolume(s, dir, 0) }.isSuccess) any = true
+        }
+        AppLog.i("Commande", if (muted) "Son coupé (${if (any) "ok" else "refusé"})" else "Son rétabli")
+        return if (any) "done" to "" else "failed" to "aucun flux audio modifiable (accès « Ne pas déranger » ?)"
+    }
+
+    private companion object {
+        const val WAIT_SECONDS = 25
+    }
+}

app/src/main/java/com/jttools/datacontrol/remote/RemoteSync.kt

@@ -1,237 +1,207 @@
 package com.jttools.datacontrol.remote
 
 import android.os.Build
-import android.util.Log
+import com.jttools.datacontrol.BuildConfig
-import com.google.firebase.firestore.DocumentReference
-import com.google.firebase.firestore.SetOptions
-import com.jttools.datacontrol.data.AppSettings
 import com.jttools.datacontrol.data.InstalledAppsRepository
+import com.jttools.datacontrol.data.PendingEvent
 import com.jttools.datacontrol.data.SettingsRepository
-import com.jttools.datacontrol.data.TrafficDay
 import com.jttools.datacontrol.log.AppLog
+import com.jttools.datacontrol.vpn.TunnelManager
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.delay
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.isActive
-import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.tasks.await
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
-import java.util.UUID
+import org.json.JSONArray
+import org.json.JSONObject
 import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Liaison avec FamilyControl via Firestore.
+ * Liaison avec le serveur familyd : appairage, consignes (mode réseau, règles d'applications),
+ * remontées (état, temps d'écran, applications installées, évènements).
  *
- * Modèle (voir FamilyControl/firebase/firestore.rules) :
+ * Tout passe par le tunnel WireGuard, sauf l'appairage (HTTPS public). Les évènements sont d'abord
- *  - pairings/{code}                                  : créé par le parent, lu une fois par l'enfant
+ * enregistrés sur le téléphone, puis envoyés dès que le serveur répond : aucun ne se perd quand le
- *  - families/{fid}/devices/{did}                     : état, batterie, position (écrit par l'appareil)
+ * tunnel est coupé.
- *  - families/{fid}/devices/{did}/config/remote       : consignes du parent (lues par l'appareil)
- *  - families/{fid}/devices/{did}/traffic/{yyyy-MM-dd}: historique de trafic
- *  - families/{fid}/devices/{did}/events/{auto}       : journal d'évènements
- *
- * L'appareil ne s'auto-bloque jamais : l'app DataControl est toujours exclue du tunnel VPN
- * (cf. FirewallVpnService), donc ces échanges passent même quand le réseau est coupé.
  */
 @Singleton
 class RemoteSync @Inject constructor(
-    private val gateway: FirebaseGateway,
+    private val settings: SettingsRepository,
-    private val settingsRepository: SettingsRepository,
+    private val installedApps: InstalledAppsRepository,
-    private val installedApps: InstalledAppsRepository
+    private val tunnel: TunnelManager,
+    private val deployer: AppDeployer
 ) {
-    val available: Boolean get() = gateway.enabled
+    private val flushLock = Mutex()
-    val gatewayState = gateway.state
+    private var started = false
 
-    private fun deviceDoc(s: AppSettings): DocumentReference? {
+    private suspend fun api(): FamilyApi? {
-        val db = gateway.db ?: return null
+        val link = settings.settingsFlow.first().link ?: return null
-        val fid = s.familyId ?: return null
+        val token = settings.deviceToken() ?: return null
-        val did = s.deviceId ?: return null
+        return FamilyApi(link.apiBase, token)
-        return db.collection("families").document(fid).collection("devices").document(did)
     }
 
-    /** Associe cet appareil à la famille correspondant au [code] affiché dans FamilyControl. */
+    /** Attend les commandes du parent (bloquant jusqu'à [waitSeconds] s). null si le tunnel est coupé ou en erreur. */
-    suspend fun pair(code: String, deviceName: String): Result<Unit> = runCatching {
+    suspend fun pollCommands(waitSeconds: Int): JSONArray? = withContext(Dispatchers.IO) {
-        check(gateway.enabled) { "Firebase non configuré dans cette version" }
+        if (!tunnel.up.value) return@withContext null
-        val db = gateway.db!!
+        val api = api() ?: return@withContext null
-        val uid = gateway.ensureSignedIn() ?: error("Connexion Firebase impossible (réseau ?)")
+        try { api.commands(waitSeconds) } catch (_: ApiException) { null }
-        val clean = code.trim().uppercase()
-        val pairing = db.collection("pairings").document(clean).get().await()
-        check(pairing.exists()) { "Code inconnu ou expiré" }
-        val familyId = pairing.getString("familyId") ?: error("Code invalide")
-        check((pairing.getLong("expiresAt") ?: 0L) > System.currentTimeMillis()) { "Code expiré" }
-        val deviceId = UUID.randomUUID().toString()
-        db.collection("families").document(familyId).collection("devices").document(deviceId).set(
-            mapOf(
-                "deviceUid" to uid,
-                "name" to deviceName.ifBlank { Build.MODEL },
-                "model" to "${Build.MANUFACTURER} ${Build.MODEL}",
-                "pairingCode" to clean,
-                "pairedAt" to System.currentTimeMillis()
-            )
-        ).await()
-        // Code à usage unique : supprimé une fois consommé (sans effet si les règles Firestore déployées
-        // ne l'autorisent pas encore — il expire de toute façon au bout de 10 min).
-        runCatching { db.collection("pairings").document(clean).delete().await() }
-            .onFailure { AppLog.w("FamilyControl", "Code d'appairage non supprimé : ${it.message}") }
-        settingsRepository.setPairing(familyId, deviceId)
     }
 
-    suspend fun unpair() {
+    /** Envoie une image de l'écran pendant un partage. */
-        val s = settingsRepository.settingsFlow.first()
+    suspend fun pushScreen(jpeg: ByteArray): Boolean = withContext(Dispatchers.IO) {
-        pushEvent("unpaired", "Appareil dissocié depuis DataControl")
+        if (!tunnel.up.value) return@withContext false
-        deviceDoc(s)?.let { runCatching { it.update("unpairedAt", System.currentTimeMillis()) } }
+        val api = api() ?: return@withContext false
-        settingsRepository.setPairing(null, null)
+        try { api.screen(jpeg); true } catch (_: ApiException) { false }
     }
 
-    /** Écoute les consignes du parent et les applique ; relancé à chaque (ré)initialisation de Firebase. */
+    /**
-    @OptIn(ExperimentalCoroutinesApi::class)
+     * Vérifie auprès du serveur un code dicté par le parent. [action] vaut "deactivate" (couper la
-    fun start(scope: CoroutineScope) {
+     * protection, se dissocier, sortir du mode propriétaire) ou "unlock" (lever le blocage parental).
-        scope.launch {
+     * Renvoie null si le code est accepté, sinon le message d'erreur à afficher.
-            gateway.state.collectLatest { st ->
+     */
-                if (!st.enabled) return@collectLatest
+    suspend fun verifyUnlock(code: String, action: String): String? = withContext(Dispatchers.IO) {
-                coroutineScope {
+        val clean = code.trim()
-                    launch {
+        if (clean.isBlank()) return@withContext "Entrez le code fourni par le parent."
-                        settingsRepository.settingsFlow
+        val api = api() ?: return@withContext "Ce téléphone n'est pas associé à un serveur."
-                            .map { it.familyId to it.deviceId }
+        try {
-                            .distinctUntilChanged()
+            api.unlock(clean, action)
-                            .flatMapLatest { (fid, did) ->
+            null
-                                if (fid == null || did == null) flowOf(null) else configFlow(fid, did)
+        } catch (e: ApiException) {
-                            }
+            when (e.code) {
-                            .collect { cfg -> if (cfg != null) apply(cfg) }
+                404 -> "Code incorrect, déjà utilisé ou expiré."
-                    }
+                0 -> "Serveur injoignable : vérifiez que le téléphone est connecté."
-                    launch {
+                else -> e.message ?: "Vérification impossible."
-                        // Si le parent supprime l'appareil de la famille, on se dissocie localement (plus de règles,
-                        // plus d'envois qui échoueraient en silence).
-                        settingsRepository.settingsFlow
-                            .map { it.familyId to it.deviceId }
-                            .distinctUntilChanged()
-                            .flatMapLatest { (fid, did) -> if (fid == null || did == null) flowOf(null) else existenceFlow(fid, did) }
-                            .collect { exists ->
-                                if (exists == false) {
-                                    AppLog.w("FamilyControl", "Appareil supprimé par le parent : dissociation locale")
-                                    settingsRepository.setPairing(null, null)
-                                }
-                            }
-                    }
-                    launch {
-                        // Liste des applications installées, pour que le parent puisse choisir lesquelles autoriser.
-                        settingsRepository.settingsFlow.map { it.isPaired }.distinctUntilChanged().collect { paired ->
-                            if (paired) pushApps()
-                        }
-                    }
-                }
             }
         }
     }
 
-    /** Vrai/faux selon que le document de l'appareil existe côté serveur (ignore le cache local). */
+    /** Accuse réception/exécution d'une commande (audit côté parent). */
-    private fun existenceFlow(fid: String, did: String) = callbackFlow<Boolean?> {
+    suspend fun ackCommand(id: String, status: String, detail: String = "") = withContext(Dispatchers.IO) {
-        val db = gateway.db
+        if (id.isBlank() || !tunnel.up.value) return@withContext
-        if (db == null || gateway.ensureSignedIn() == null) { trySend(null); close(); return@callbackFlow }
+        val api = api() ?: return@withContext
-        val reg = db.collection("families").document(fid).collection("devices").document(did)
+        runCatching { api.commandAck(id, status, detail) }
-            .addSnapshotListener { snap, err ->
-                if (err != null || snap == null || snap.metadata.isFromCache) return@addSnapshotListener
-                trySend(snap.exists())
-            }
-        awaitClose { reg.remove() }
     }
 
-    private class Config(val map: Map<String, Any?>)
+    /** Associe le téléphone au serveur : clés WireGuard générées ici, la clé privée ne quitte jamais l'appareil. */
-
+    suspend fun pair(input: PairingInput, deviceName: String): Result<FamilyLink> = withContext(Dispatchers.IO) {
-    private fun configFlow(fid: String, did: String) = callbackFlow<Config?> {
-        val db = gateway.db
-        if (db == null || gateway.ensureSignedIn() == null) { trySend(null); close(); return@callbackFlow }
-        val reg = db.collection("families").document(fid).collection("devices").document(did)
-            .collection("config").document("remote")
-            .addSnapshotListener { snap, err ->
-                if (err != null) { Log.w(TAG, "config listener", err); return@addSnapshotListener }
-                if (snap != null && snap.exists()) trySend(Config(snap.data.orEmpty()))
-            }
-        awaitClose { reg.remove() }
-    }
-
-    private suspend fun apply(cfg: Config) {
-        val m = cfg.map
-        val version = (m["updatedAt"] as? Number)?.toLong() ?: return
-        fun strings(key: String) = (m[key] as? List<*>)?.filterIsInstance<String>()?.toSet()
-        settingsRepository.applyRemoteConfig(
-            version = version,
-            controlEnabled = m["controlEnabled"] as? Boolean,
-            whitelistedPackages = strings("whitelistedPackages"),
-            whitelistedPackagesWifi = strings("whitelistedPackagesWifi"),
-            wifiFilterEnabled = m["wifiFilterEnabled"] as? Boolean,
-            planLimitMo = (m["planLimitMo"] as? Number)?.toLong(),
-            cutoffIntervalMinutes = (m["cutoffIntervalMinutes"] as? Number)?.toInt(),
-            rulesJson = (m["rules"] as? Map<*, *>)?.let { org.json.JSONObject(it).toString() }
-        )
-    }
-
-    /** Envoie la liste des applications installées (au parent de choisir lesquelles autoriser). */
-    suspend fun pushApps() {
-        val s = settingsRepository.settingsFlow.first()
-        val ref = deviceDoc(s) ?: return
-        val apps = installedApps.listInstalledApps(withIcons = false).map {
-            mapOf("pkg" to it.packageName, "label" to it.label, "system" to it.isSystemApp)
-        }
-        write(ref.collection("meta").document("apps"), mapOf("apps" to apps, "at" to System.currentTimeMillis()))
-    }
-
-    /** Fusionne [data] dans le document de l'appareil (état, batterie, position…). */
-    suspend fun pushDevice(data: Map<String, Any?>) {
-        val s = settingsRepository.settingsFlow.first()
-        val ref = deviceDoc(s) ?: return
-        write(ref, data + ("lastSeen" to System.currentTimeMillis()))
-    }
-
-    suspend fun pushTraffic(day: TrafficDay) {
-        val s = settingsRepository.settingsFlow.first()
-        val ref = deviceDoc(s) ?: return
-        write(
-            ref.collection("traffic").document(day.date),
-            mapOf("date" to day.date, "mobileBytes" to day.mobileBytes, "wifiBytes" to day.wifiBytes,
-                "at" to System.currentTimeMillis())
-        )
-    }
-
-    suspend fun pushUsage(date: String, totalMs: Long, appMs: Map<String, Long>) {
-        val s = settingsRepository.settingsFlow.first()
-        val ref = deviceDoc(s) ?: return
-        write(
-            ref.collection("usage").document(date),
-            mapOf("date" to date, "totalMs" to totalMs, "apps" to appMs, "at" to System.currentTimeMillis())
-        )
-    }
-
-    suspend fun pushEvent(type: String, detail: String) {
-        val s = settingsRepository.settingsFlow.first()
-        val ref = deviceDoc(s) ?: return
-        if (gateway.ensureSignedIn() == null) return
-        // Attente bornée de l'accusé du serveur : appelé depuis un récepteur (goAsync), le processus
-        // peut être arrêté juste après ; hors ligne, l'écriture reste en file dans le SDK.
         runCatching {
-            withTimeoutOrNull(EVENT_TIMEOUT_MS) {
+            val (privateKey, publicKey) = TunnelManager.newKeyPair()
-                ref.collection("events").add(
+            val raw = FamilyApi.pair(
-                    mapOf("type" to type, "detail" to detail, "at" to System.currentTimeMillis())
+                input.serverUrl, input.code, publicKey, deviceName.trim().ifBlank { Build.MODEL },
-                ).await()
+                "${Build.MANUFACTURER} ${Build.MODEL}", BuildConfig.VERSION_NAME
+            )
+            val (link, token) = FamilyLink.fromPairResponse(input.serverUrl, raw)
+            settings.savePairing(link, token, privateKey)
+            AppLog.i("Liaison", "Associé à ${input.serverUrl} : appareil ${link.name} (${link.tunnelIp})")
+            link
+        }.onFailure { AppLog.w("Liaison", "Appairage refusé : ${it.message}") }
+    }
+
+    /** Oubli local de la liaison (le parent retire l'appareil côté serveur). */
+    suspend fun forget() {
+        pushEvent("unpaired", "Liaison supprimée depuis DataControl")
+        tunnel.down()
+        settings.clearPairing()
+        AppLog.w("Liaison", "Liaison avec le serveur supprimée sur le téléphone")
+    }
+
+    fun start(scope: CoroutineScope) {
+        if (started) return
+        started = true
+        scope.launch(Dispatchers.IO) {
+            while (isActive) {
+                runCatching { syncOnce() }
+                delay(SYNC_INTERVAL_MS)
             }
         }
     }
 
-    private suspend fun write(ref: DocumentReference, data: Map<String, Any?>) {
+    /** Récupère la consigne en cours et vide la file des évènements. Faux si le serveur est injoignable. */
-        if (gateway.ensureSignedIn() == null) return
+    suspend fun syncOnce(): Boolean = withContext(Dispatchers.IO) {
-        // Les écritures sont mises en file par le SDK hors-ligne : pas d'attente bloquante du réseau.
+        if (!tunnel.up.value) return@withContext false
-        ref.set(data, SetOptions.merge())
+        val api = api() ?: return@withContext false
+        val p = try {
+            api.policy()
+        } catch (e: ApiException) {
+            if (e.code == 401) AppLog.w("Liaison", "Le serveur ne reconnaît plus ce téléphone (dissocié par le parent ?)")
+            return@withContext false
+        }
+        val current = settings.settingsFlow.first()
+        val version = p.optLong("version")
+        val mode = p.optString("mode", "open")
+        val reason = p.optString("mode_reason")
+        val blockInstalls = p.optBoolean("block_installs", false)
+        if (version != current.policyVersion || mode != current.serverMode || reason != current.serverModeReason
+            || blockInstalls != current.blockInstalls) {
+            val rules = p.optJSONObject("app_rules")?.takeIf { it.length() > 0 }?.toString()
+            settings.applyServerPolicy(version, mode, reason, rules, blockInstalls)
+            if (mode != current.serverMode) AppLog.i("Liaison", "Mode réseau : $mode${if (reason.isNotBlank()) " ($reason)" else ""}")
+            if (blockInstalls != current.blockInstalls) AppLog.i("Liaison", "Blocage des installations : $blockInstalls")
+        }
+        // Mise à jour de DataControl poussée par le parent.
+        p.optJSONObject("deploy")?.let { order ->
+            current.link?.let { link -> deployer.handle(order, link.apiBase) { t, d -> pushEvent(t, d) } }
+        }
+        flushEvents()
+        true
     }
 
-    companion object {
+    /** Enregistre l'évènement puis tente de l'envoyer (8 s au plus : appelable depuis un récepteur goAsync). */
-        private const val TAG = "RemoteSync"
+    suspend fun pushEvent(type: String, detail: String) {
-        private const val EVENT_TIMEOUT_MS = 8_000L
+        if (!settings.settingsFlow.first().isPaired) return
+        settings.queueEvent(PendingEvent(type, detail, System.currentTimeMillis()))
+        withTimeoutOrNull(EVENT_TIMEOUT_MS) { flushEvents() }
+    }
+
+    private suspend fun flushEvents() = withContext(Dispatchers.IO) {
+        if (!tunnel.up.value) return@withContext
+        flushLock.withLock {
+            val api = api() ?: return@withLock
+            val pending = settings.pendingEvents()
+            var sent = 0
+            for (e in pending) {
+                try {
+                    api.event(e.type, e.detail, e.at)
+                    sent++
+                } catch (_: ApiException) {
+                    break
+                }
+            }
+            if (sent > 0) settings.dropEvents(sent)
+        }
+    }
+
+    suspend fun pushState(state: JSONObject): Boolean = call { it.state(state) }
+
+    suspend fun pushUsage(date: String, totalMs: Long, apps: Map<String, Long>): Boolean = call { it.usage(date, totalMs, apps) }
+
+    /** Liste des applications installées, pour que le parent choisisse lesquelles limiter. */
+    suspend fun pushApps(): Boolean {
+        val list = installedApps.listInstalledApps(withIcons = false)
+        val arr = JSONArray(list.map { JSONObject().put("pkg", it.packageName).put("label", it.label.take(100)).put("system", it.isSystemApp) })
+        return call { it.apps(arr) }
+    }
+
+    private suspend fun call(block: (FamilyApi) -> Unit): Boolean = withContext(Dispatchers.IO) {
+        if (!tunnel.up.value) return@withContext false
+        val api = api() ?: return@withContext false
+        try {
+            block(api)
+            true
+        } catch (e: ApiException) {
+            AppLog.w("Liaison", "Envoi au serveur impossible : ${e.message}")
+            false
+        }
+    }
+
+    private companion object {
+        const val SYNC_INTERVAL_MS = 30_000L
+        const val EVENT_TIMEOUT_MS = 8_000L
     }
 }

app/src/main/java/com/jttools/datacontrol/remote/Ringer.kt

@@ -0,0 +1,162 @@
+package com.jttools.datacontrol.remote
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.media.AudioAttributes
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.media.RingtoneManager
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
+import androidx.core.app.NotificationCompat
+import com.jttools.datacontrol.R
+import com.jttools.datacontrol.log.AppLog
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import java.util.Timer
+import java.util.TimerTask
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * « Faire sonner » demandé par le parent : joue une sonnerie d'alarme à plein volume, même si le
+ * téléphone est en silencieux (le flux d'alarme n'est pas concerné par le mode silencieux), vibre et
+ * affiche une notification « Appuyez pour arrêter ». S'arrête tout seul au bout de la durée demandée,
+ * à la demande du parent (commande ring_stop), ou quand l'enfant touche la notification.
+ */
+@Singleton
+class Ringer @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    private var player: MediaPlayer? = null
+    private var previousVolume = -1
+    private var stopTimer: Timer? = null
+
+    @Synchronized
+    fun start(seconds: Int): Pair<String, String> {
+        stop(silent = true)              // repart proprement si une sonnerie était déjà en cours
+        val am = context.getSystemService(AudioManager::class.java)
+        val uri = RingtoneManager.getActualDefaultRingtoneUri(context, RingtoneManager.TYPE_ALARM)
+            ?: RingtoneManager.getActualDefaultRingtoneUri(context, RingtoneManager.TYPE_RINGTONE)
+            ?: return "failed" to "aucune sonnerie disponible"
+        return try {
+            previousVolume = am.getStreamVolume(AudioManager.STREAM_ALARM)
+            am.setStreamVolume(AudioManager.STREAM_ALARM, am.getStreamMaxVolume(AudioManager.STREAM_ALARM), 0)
+            player = MediaPlayer().apply {
+                setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_ALARM)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                        .build()
+                )
+                setDataSource(context, uri)
+                isLooping = true
+                prepare()
+                start()
+            }
+            vibrate(true)
+            notify(context)
+            val secs = seconds.coerceIn(5, 300)
+            stopTimer = Timer().apply {
+                schedule(object : TimerTask() {
+                    override fun run() = stop(silent = false)
+                }, secs * 1000L)
+            }
+            AppLog.i("Commande", "Sonnerie déclenchée ($secs s)")
+            "done" to "sonnerie déclenchée"
+        } catch (e: Exception) {
+            AppLog.e("Commande", "Sonnerie impossible", e)
+            stop(silent = true)
+            "failed" to (e.message ?: "sonnerie impossible")
+        }
+    }
+
+    @Synchronized
+    fun stop(silent: Boolean) {
+        stopTimer?.cancel(); stopTimer = null
+        runCatching { player?.stop() }
+        runCatching { player?.release() }
+        player = null
+        vibrate(false)
+        if (previousVolume >= 0) {
+            runCatching {
+                context.getSystemService(AudioManager::class.java)
+                    .setStreamVolume(AudioManager.STREAM_ALARM, previousVolume, 0)
+            }
+            previousVolume = -1
+        }
+        context.getSystemService(NotificationManager::class.java).cancel(NOTIF_ID)
+        if (!silent) AppLog.i("Commande", "Sonnerie arrêtée")
+    }
+
+    private fun vibrate(on: Boolean) {
+        val vib = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            context.getSystemService(VibratorManager::class.java)?.defaultVibrator
+        } else {
+            @Suppress("DEPRECATION") context.getSystemService(Vibrator::class.java)
+        } ?: return
+        if (!on) { runCatching { vib.cancel() }; return }
+        runCatching {
+            val pattern = longArrayOf(0, 600, 400)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                vib.vibrate(VibrationEffect.createWaveform(pattern, 0))
+            } else {
+                @Suppress("DEPRECATION") vib.vibrate(pattern, 0)
+            }
+        }
+    }
+
+    private fun notify(context: Context) {
+        val nm = context.getSystemService(NotificationManager::class.java)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            nm.createNotificationChannel(
+                NotificationChannel(CHANNEL, "Sonnerie", NotificationManager.IMPORTANCE_HIGH).apply {
+                    setSound(null, null)          // le son est joué par le lecteur (flux d'alarme)
+                    enableVibration(false)
+                }
+            )
+        }
+        val stop = PendingIntent.getBroadcast(
+            context, 0, Intent(context, RingStopReceiver::class.java),
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+        )
+        nm.notify(NOTIF_ID, NotificationCompat.Builder(context, CHANNEL)
+            .setSmallIcon(R.drawable.ic_notification)
+            .setContentTitle("DataControl sonne")
+            .setContentText("Demandé par le parent — touchez pour arrêter.")
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setCategory(NotificationCompat.CATEGORY_ALARM)
+            .setOngoing(true)
+            .setAutoCancel(true)
+            .setContentIntent(stop)
+            .setFullScreenIntent(stop, true)
+            .build())
+    }
+
+    companion object {
+        private const val CHANNEL = "datacontrol_ring"
+        private const val NOTIF_ID = 3102
+    }
+}
+
+/** Arrêt de la sonnerie depuis la notification (touche de l'enfant). */
+class RingStopReceiver : BroadcastReceiver() {
+    @EntryPoint
+    @InstallIn(SingletonComponent::class)
+    interface Deps {
+        fun ringer(): Ringer
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        EntryPointAccessors.fromApplication(context.applicationContext, Deps::class.java).ringer().stop(silent = false)
+    }
+}

app/src/main/java/com/jttools/datacontrol/remote/ScreenCaptureService.kt

@@ -0,0 +1,193 @@
+package com.jttools.datacontrol.remote
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.graphics.Bitmap
+import android.graphics.PixelFormat
+import android.hardware.display.DisplayManager
+import android.hardware.display.VirtualDisplay
+import android.media.ImageReader
+import android.media.projection.MediaProjection
+import android.media.projection.MediaProjectionManager
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.IBinder
+import android.os.SystemClock
+import android.util.DisplayMetrics
+import android.view.WindowManager
+import androidx.core.app.NotificationCompat
+import com.jttools.datacontrol.R
+import com.jttools.datacontrol.log.AppLog
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import java.io.ByteArrayOutputStream
+import javax.inject.Inject
+
+/**
+ * Partage d'écran par MediaProjection — fonctionne dès Android 5, contrairement à la capture par le
+ * service d'accessibilité ([com.jttools.datacontrol.guard.AppGuardService]) réservée à Android 11+.
+ *
+ * Démarré par [ScreenConsentActivity] après le consentement du système (ou son auto-validation par
+ * l'accessibilité en mode propriétaire). Capture l'écran tant que le parent partage
+ * ([RemoteControl.screenSharing]), redimensionne et envoie les images au serveur par le tunnel.
+ */
+@AndroidEntryPoint
+class ScreenCaptureService : Service() {
+
+    @Inject lateinit var remoteSync: RemoteSync
+    @Inject lateinit var remoteControl: RemoteControl
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private var projection: MediaProjection? = null
+    private var virtualDisplay: VirtualDisplay? = null
+    private var imageReader: ImageReader? = null
+    private var thread: HandlerThread? = null
+    private var lastSent = 0L
+    @Volatile private var busy = false
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        if (intent?.action == ACTION_STOP) { stop(); return START_NOT_STICKY }
+        startForegroundNotif()
+        val code = intent?.getIntExtra(EXTRA_CODE, 0) ?: 0
+        val data: Intent? = intent?.let {
+            if (Build.VERSION.SDK_INT >= 33) it.getParcelableExtra(EXTRA_DATA, Intent::class.java)
+            else @Suppress("DEPRECATION") it.getParcelableExtra(EXTRA_DATA)
+        }
+        if (data == null || code == 0) { stop(); return START_NOT_STICKY }
+        running = true
+        val mpm = getSystemService(MediaProjectionManager::class.java)
+        projection = try {
+            mpm.getMediaProjection(code, data)
+        } catch (e: Exception) {
+            AppLog.e("Écran", "MediaProjection impossible", e); stop(); return START_NOT_STICKY
+        }
+        projection?.registerCallback(object : MediaProjection.Callback() {
+            override fun onStop() { stop() }
+        }, Handler(mainLooper))
+        startCapture()
+        scope.launch {                           // s'arrête dès que le parent cesse de partager
+            while (running) {
+                if (!remoteControl.screenSharing) { stop(); break }
+                delay(1000)
+            }
+        }
+        return START_NOT_STICKY
+    }
+
+    private fun startCapture() {
+        val metrics = DisplayMetrics()
+        @Suppress("DEPRECATION")
+        getSystemService(WindowManager::class.java).defaultDisplay.getRealMetrics(metrics)
+        val scale = if (metrics.widthPixels > MAX_WIDTH) MAX_WIDTH.toFloat() / metrics.widthPixels else 1f
+        val w = (metrics.widthPixels * scale).toInt().coerceAtLeast(1)
+        val h = (metrics.heightPixels * scale).toInt().coerceAtLeast(1)
+        thread = HandlerThread("screencap").apply { start() }
+        val handler = Handler(thread!!.looper)
+        val reader = ImageReader.newInstance(w, h, PixelFormat.RGBA_8888, 2)
+        imageReader = reader
+        virtualDisplay = projection?.createVirtualDisplay(
+            "datacontrol-screen", w, h, metrics.densityDpi,
+            DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR, reader.surface, null, handler
+        )
+        reader.setOnImageAvailableListener({ r ->
+            val image = r.acquireLatestImage() ?: return@setOnImageAvailableListener
+            val now = SystemClock.elapsedRealtime()
+            if (busy || now - lastSent < CAPTURE_INTERVAL_MS) { image.close(); return@setOnImageAvailableListener }
+            lastSent = now
+            busy = true
+            try {
+                val plane = image.planes[0]
+                val pixelStride = plane.pixelStride
+                val rowPadding = plane.rowStride - pixelStride * w
+                val bmp = Bitmap.createBitmap(w + rowPadding / pixelStride, h, Bitmap.Config.ARGB_8888)
+                bmp.copyPixelsFromBuffer(plane.buffer)
+                image.close()
+                val frame = if (rowPadding == 0) bmp else Bitmap.createBitmap(bmp, 0, 0, w, h).also { bmp.recycle() }
+                scope.launch {
+                    val jpeg = ByteArrayOutputStream().use { out ->
+                        frame.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, out); out.toByteArray()
+                    }
+                    frame.recycle()
+                    runCatching { remoteSync.pushScreen(jpeg) }
+                    busy = false
+                }
+            } catch (e: Exception) {
+                runCatching { image.close() }
+                busy = false
+                AppLog.w("Écran", "Capture impossible : ${e.message}")
+            }
+        }, handler)
+        AppLog.i("Écran", "Partage d'écran (MediaProjection) démarré — $w×$h")
+    }
+
+    private fun stop() {
+        running = false
+        runCatching { virtualDisplay?.release() }
+        runCatching { imageReader?.close() }
+        runCatching { projection?.stop() }
+        virtualDisplay = null; imageReader = null; projection = null
+        thread?.quitSafely(); thread = null
+        scope.cancel()
+        runCatching { stopForeground(STOP_FOREGROUND_REMOVE) }
+        stopSelf()
+    }
+
+    override fun onDestroy() { running = false; super.onDestroy() }
+
+    private fun startForegroundNotif() {
+        val nm = getSystemService(NotificationManager::class.java)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            nm.createNotificationChannel(
+                NotificationChannel(CHANNEL, "Partage d'écran", NotificationManager.IMPORTANCE_LOW)
+            )
+        }
+        val notif = NotificationCompat.Builder(this, CHANNEL)
+            .setSmallIcon(R.drawable.ic_notification)
+            .setContentTitle("Écran partagé avec le parent")
+            .setContentText("DataControl partage l'écran de ce téléphone.")
+            .setOngoing(true)
+            .build()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(NOTIF_ID, notif, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION)
+        } else {
+            startForeground(NOTIF_ID, notif)
+        }
+    }
+
+    companion object {
+        @Volatile var running = false
+            private set
+        private const val CHANNEL = "screen_share"
+        private const val NOTIF_ID = 4242
+        private const val EXTRA_CODE = "code"
+        private const val EXTRA_DATA = "data"
+        private const val ACTION_STOP = "stop"
+        private const val MAX_WIDTH = 720
+        private const val JPEG_QUALITY = 50
+        private const val CAPTURE_INTERVAL_MS = 1200L
+
+        fun start(context: Context, resultCode: Int, data: Intent) {
+            val i = Intent(context, ScreenCaptureService::class.java)
+                .putExtra(EXTRA_CODE, resultCode).putExtra(EXTRA_DATA, data)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) context.startForegroundService(i)
+            else context.startService(i)
+        }
+
+        fun stop(context: Context) {
+            if (!running) return
+            context.startService(Intent(context, ScreenCaptureService::class.java).setAction(ACTION_STOP))
+        }
+    }
+}

app/src/main/java/com/jttools/datacontrol/remote/ScreenConsentActivity.kt

@@ -0,0 +1,43 @@
+package com.jttools.datacontrol.remote
+
+import android.content.Context
+import android.content.Intent
+import android.media.projection.MediaProjectionManager
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.result.contract.ActivityResultContracts
+import com.jttools.datacontrol.log.AppLog
+
+/**
+ * Demande le consentement du système au partage d'écran (MediaProjection) puis lance
+ * [ScreenCaptureService]. Transparente et sans interface : en mode propriétaire, le service
+ * d'accessibilité peut valider seul le dialogue « Démarrer la capture » (sinon un appui est requis).
+ */
+class ScreenConsentActivity : ComponentActivity() {
+
+    private val launcher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { res ->
+        val data = res.data
+        if (res.resultCode == RESULT_OK && data != null) {
+            ScreenCaptureService.start(this, res.resultCode, data)
+        } else {
+            AppLog.w("Écran", "Partage d'écran refusé sur le téléphone")
+        }
+        finish()
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val mpm = getSystemService(MediaProjectionManager::class.java)
+        try {
+            launcher.launch(mpm.createScreenCaptureIntent())
+        } catch (e: Exception) {
+            AppLog.e("Écran", "Demande de partage d'écran impossible", e)
+            finish()
+        }
+    }
+
+    companion object {
+        fun intent(context: Context): Intent =
+            Intent(context, ScreenConsentActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+}

app/src/main/java/com/jttools/datacontrol/service/BootReceiver.kt

@@ -23,7 +23,8 @@ class BootReceiver : BroadcastReceiver() {
     }
 
     override fun onReceive(context: Context, intent: Intent?) {
-        if (intent?.action != Intent.ACTION_BOOT_COMPLETED) return
+        // Redémarrage de l'appareil, ou DataControl vient d'être mis à jour (déploiement depuis le serveur).
+        if (intent?.action != Intent.ACTION_BOOT_COMPLETED && intent?.action != Intent.ACTION_MY_PACKAGE_REPLACED) return
         val appContext = context.applicationContext
         val entryPoint = EntryPointAccessors.fromApplication(appContext, BootReceiverEntryPoint::class.java)
         val pendingResult = goAsync()

app/src/main/java/com/jttools/datacontrol/service/DataMonitorService.kt

@@ -4,10 +4,8 @@ import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
-import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import android.content.IntentFilter
 import android.graphics.Color
 import android.os.SystemClock
 import androidx.core.app.NotificationCompat
@@ -16,6 +14,7 @@ import androidx.lifecycle.LifecycleService
 import androidx.lifecycle.lifecycleScope
 import com.jttools.datacontrol.MainActivity
 import com.jttools.datacontrol.R
+import com.jttools.datacontrol.admin.OwnerPolicy
 import com.jttools.datacontrol.data.AppSettings
 import com.jttools.datacontrol.data.DataState
 import com.jttools.datacontrol.data.SettingsRepository
@@ -24,7 +23,11 @@ import com.jttools.datacontrol.guard.GuardEngine
 import com.jttools.datacontrol.log.AppLog
 import com.jttools.datacontrol.remote.DeviceReporter
 import com.jttools.datacontrol.remote.RemoteSync
+import com.jttools.datacontrol.vpn.TunnelManager
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import java.time.LocalDate
@@ -32,15 +35,12 @@ import javax.inject.Inject
 import kotlin.math.max
 
 /**
- * Service de premier plan qui surveille en continu la consommation de données mobiles,
+ * Service de premier plan : garde le tunnel WireGuard vers le serveur familyd monté tant que le
- * pilote le pare-feu [FirewallVpnService] et met à jour la notification permanente.
+ * contrôle est activé (le serveur décide de ce qui passe), suit la consommation de données mobiles
+ * et met à jour la notification permanente.
  *
- * Règles appliquées (voir README) :
+ * Si le tunnel tombe (VPN retiré, autre VPN, réseau), le contrôle reste ACTIVÉ : la notification
- *  - Sur Wi-Fi : aucun filtrage par défaut (le pare-feu est arrêté), sauf si le filtrage Wi-Fi
+ * passe en rouge, le parent est prévenu, et le tunnel est remonté dès que possible.
- *    est explicitement activé (Liste blanche Wi-Fi).
- *  - Sur données mobiles : liste blanche active en permanence (seules les apps cochées ont accès),
- *    ET une coupure totale cyclique (même liste blanche) se déclenche automatiquement toutes les
- *    X minutes pendant une courte pulsation, que le forfait soit dépassé ou non.
  */
 @AndroidEntryPoint
 class DataMonitorService : LifecycleService() {
@@ -52,85 +52,71 @@ class DataMonitorService : LifecycleService() {
     @Inject lateinit var deviceReporter: DeviceReporter
     @Inject lateinit var remoteSync: RemoteSync
     @Inject lateinit var guardEngine: GuardEngine
+    @Inject lateinit var tunnel: TunnelManager
+    @Inject lateinit var remoteControl: com.jttools.datacontrol.remote.RemoteControl
 
     private var latestSettings: AppSettings = AppSettings()
     private var latestTransport: NetworkTransport = NetworkTransport.NONE
-    /**
-     * Instant (temps monotone) du dernier retrait du VPN. Le contrôle reste ACTIVÉ : retirer le VPN
-     * ne doit pas suffire à lever la protection sans mot de passe. On laisse un délai avant de
-     * remonter le tunnel, pour ne pas se battre en boucle avec un autre VPN.
-     */
-    private var vpnRevokedAt: Long? = null
-    private val vpnRevoked: Boolean
-        get() = vpnRevokedAt?.let { SystemClock.elapsedRealtime() - it < VPN_RETRY_AFTER_REVOKE_MS } ?: false
-
-    private var lastAppliedMode: VpnMode? = null
-    private var lastAppliedWhitelist: Set<String> = emptySet()
-    private var lastApplyMillis = 0L
-
-    private var cutoffCycleAnchorMillis: Long? = null
-    private var inPulse = false
-    private var pulseStartMillis: Long = 0L
-    private var settingsLoaded = false
     private var lastControlEnabled: Boolean? = null
+    private var lastTunnelAttempt = 0L
+    private var tunnelJob: Job? = null
     private var lastDiagnostic = ""
-
+    /** Dernière poignée de main récente avec le serveur (temps monotone), pour le garde-fou du mode propriétaire. */
-    private val vpnRevokedReceiver = object : BroadcastReceiver() {
+    private var serverSeenAt = SystemClock.elapsedRealtime()
-        override fun onReceive(context: Context?, intent: Intent?) {
+    private var lockdownRelaxed = false
-            vpnRevokedAt = SystemClock.elapsedRealtime()
+    private var lastProvisionAttempt = 0L
-            AppLog.w("Pare-feu", "VPN retiré : contrôle maintenu, nouvelle tentative dans ${VPN_RETRY_AFTER_REVOKE_MS / 1000} s")
+    private var provisionJob: Job? = null
-            lifecycleScope.launch {
-                remoteSync.pushEvent("vpn_revoked", "Autorisation VPN retirée : données mobiles non filtrées tant qu'elle n'est pas rétablie")
-            }
-            tick()
-        }
-    }
-
-    private enum class VpnMode { FILTER, BLOCK_ALL, STOPPED }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         super.onStartCommand(intent, flags, startId)
-        // START_STICKY : si le système tue ce service (mémoire faible), il le relance
+        // START_STICKY : si le système tue ce service, il le relance dès que possible (Intent null).
-        // automatiquement (avec un Intent null) dès que les ressources redeviennent disponibles.
         return START_STICKY
     }
 
     override fun onCreate() {
         super.onCreate()
-        ContextCompat.registerReceiver(
-            this, vpnRevokedReceiver, IntentFilter(FirewallVpnService.ACTION_VPN_REVOKED),
-            ContextCompat.RECEIVER_NOT_EXPORTED
-        )
         startForeground(NOTIF_ID, buildNotification(stateHolder.snapshot.value))
         AppLog.i("Service", "DataMonitorService démarré")
 
         lifecycleScope.launch {
             settingsRepository.settingsFlow.collect {
-                // Ne recopier l'état persisté du minuteur de coupure qu'à la toute première valeur
-                // réelle lue en base — pas question d'écraser avec les valeurs par défaut si un
-                // tick() déclenché par une autre coroutine s'exécute avant cette première émission.
-                if (!settingsLoaded) {
-                    cutoffCycleAnchorMillis = it.cutoffCycleAnchorMillis
-                    inPulse = it.cutoffInPulse
-                    pulseStartMillis = it.cutoffPulseStartMillis
-                    settingsLoaded = true
-                }
                 latestSettings = it
                 if (lastControlEnabled != null && lastControlEnabled != it.controlEnabled && it.isPaired) {
                     launch {
                         remoteSync.pushEvent(
                             "control_changed",
-                            if (it.controlEnabled) "Contrôle activé" else "Contrôle désactivé"
+                            if (it.controlEnabled) "Contrôle activé" else "Contrôle désactivé sur le téléphone"
                         )
                     }
                 }
                 lastControlEnabled = it.controlEnabled
-                if (!it.controlEnabled) vpnRevokedAt = null
+                tick()
+            }
+        }
+        lifecycleScope.launch {
+            var wasUp = false
+            tunnel.up.collect { up ->
+                val s = latestSettings
+                if (wasUp && !up && s.controlEnabled && s.isPaired) {
+                    // Retrait du VPN par l'utilisateur ou un autre VPN : le contrôle reste actif.
+                    lastTunnelAttempt = SystemClock.elapsedRealtime()
+                    remoteSync.pushEvent("vpn_revoked", "Tunnel coupé sur le téléphone : trafic non filtré tant qu'il n'est pas rétabli")
+                }
+                wasUp = up
                 tick()
             }
         }
         guardEngine.start()
         deviceReporter.start(lifecycleScope)
+        remoteControl.start(lifecycleScope)
+        // Verrouillage parental encore actif après un redémarrage : on le rétablit à l'ouverture.
+        lifecycleScope.launch {
+            if (settingsRepository.settingsFlow.first().parentalLocked) {
+                runCatching {
+                    startActivity(com.jttools.datacontrol.guard.ParentalLockActivity.intent(this@DataMonitorService))
+                }
+            }
+        }
         lifecycleScope.launch {
             connectivityObserver.observe().collect {
                 latestTransport = it
@@ -140,7 +126,7 @@ class DataMonitorService : LifecycleService() {
         lifecycleScope.launch {
             while (isActive) {
                 tick()
-                kotlinx.coroutines.delay(TICK_INTERVAL_MS)
+                delay(TICK_INTERVAL_MS)
             }
         }
     }
@@ -148,9 +134,7 @@ class DataMonitorService : LifecycleService() {
     private fun tick() {
         val settings = latestSettings
 
-        // Le calcul de la consommation doit rester à jour même quand le contrôle est désactivé
+        // Consommation de données mobiles (compteur local, pour le tableau de bord et le forfait affiché).
-        // (ex: pour refléter immédiatement une valeur définie manuellement dans Réglages), il ne
-        // doit donc pas dépendre de settings.controlEnabled.
         val consumedBytes = usageRepository.consumedBytesSince(settings.baselineMobileBytesAtReset)
         if (usageRepository.hasCounterReset(settings.baselineMobileBytesAtReset)) {
             lifecycleScope.launch { settingsRepository.rebaseline(usageRepository.totalMobileBytes()) }
@@ -159,97 +143,37 @@ class DataMonitorService : LifecycleService() {
         val overageMo = max(0L, consumedMo - settings.planLimitMo)
         val estimatedTotal = settings.planPriceEuro + overageMo * settings.overagePricePerMoEuro
         val percent = if (settings.planLimitMo > 0) consumedMo.toFloat() / settings.planLimitMo else 0f
-
+        if (settings.autoResetEnabled && !LocalDate.now().isBefore(settings.nextAutoResetDate())) {
-        if (!settings.controlEnabled) {
+            lifecycleScope.launch {
-            applyVpnMode(VpnMode.STOPPED, emptySet())
+                settingsRepository.resetPlan(usageRepository.totalMobileBytes(), settings.nextAutoResetDate())
-            stateHolder.update {
-                it.copy(
-                    consumedMo = consumedMo,
-                    planLimitMo = settings.planLimitMo,
-                    overageMo = overageMo,
-                    estimatedTotalPriceEuro = estimatedTotal,
-                    dataState = if (percent >= WARNING_THRESHOLD) DataState.WARNING else DataState.OK,
-                    nextAutoResetDate = settings.nextAutoResetDate(),
-                    serviceRunning = false,
-                    firewallFault = false,
-                    transport = latestTransport
-                )
             }
-            updateNotification(stateHolder.snapshot.value)
-            return
         }
 
-        maybeAutoReset(settings)
+        if (!settings.isPaired) maybeProvisionPairing()
-
-        val dataState: DataState
-        var nextCutoffAt: Long? = null
-        var firewallFault = false
 
+        // Tunnel : monté si contrôle activé + appareil associé ; sinon arrêté. En mode propriétaire, les
+        // verrous (dont l'autorisation VPN accordée par le système) passent avant la montée du tunnel.
+        val wanted = settings.controlEnabled && settings.isPaired
+        val up = tunnel.up.value
+        applyOwnerPolicy(wanted, up)
         when {
-            latestTransport == NetworkTransport.WIFI -> {
+            wanted && !up -> maybeBringUp(settings)
-                if (settings.wifiFilterEnabled && !vpnRevoked && FirewallVpnService.isPrepared(this)) {
+            !wanted && up && tunnelJob?.isActive != true -> {
-                    applyVpnMode(VpnMode.FILTER, settings.whitelistedPackagesWifi)
+                tunnelJob = lifecycleScope.launch { tunnel.down() }
-                } else {
-                    applyVpnMode(VpnMode.STOPPED, emptySet())
             }
-                resetCutoffCycle()
-                dataState = DataState.WIFI
         }
-            latestTransport == NetworkTransport.CELLULAR && !vpnRevoked && FirewallVpnService.isPrepared(this) -> {
+        val fault = wanted && !up
-                if (guardEngine.cutsMobileNow()) {
-                    // Hors plage horaire autorisée : couper les données mobiles (règle du parent).
-                    applyVpnMode(VpnMode.BLOCK_ALL, emptySet())
-                    resetCutoffCycle()
-                    firewallFault = !FirewallVpnService.tunnelActive &&
-                        System.currentTimeMillis() - lastApplyMillis > TUNNEL_RETRY_DELAY_MS
-                    dataState = DataState.CUT
-                } else {
-                    // La coupure cyclique tourne en continu sur données mobiles, indépendamment du
-                    // dépassement du forfait : elle ne doit pas attendre le hors-forfait pour se déclencher.
-                    val now = System.currentTimeMillis()
-                    val intervalMs = settings.cutoffIntervalMinutes * 60_000L
-                    if (cutoffCycleAnchorMillis == null) {
-                        cutoffCycleAnchorMillis = now
-                        persistCutoffState()
-                    }
-                    val anchor = cutoffCycleAnchorMillis!!
 
-                    if (inPulse) {
+        val dataState = when {
-                        if (now - pulseStartMillis >= PULSE_DURATION_MS) {
+            !settings.controlEnabled -> if (percent >= WARNING_THRESHOLD) DataState.WARNING else DataState.OK
-                            inPulse = false
+            // « blocklist » laisse tout passer (sauf la liste noire DNS) : traité comme « open », pas comme coupé.
-                            cutoffCycleAnchorMillis = now
+            settings.serverMode == "allowlist" || settings.serverMode == "cut" -> DataState.CUT
-                            persistCutoffState()
+            latestTransport == NetworkTransport.WIFI -> DataState.WIFI
-                            applyVpnMode(VpnMode.FILTER, settings.whitelistedPackages)
+            percent >= WARNING_THRESHOLD -> DataState.WARNING
-                        } else {
+            else -> DataState.OK
-                            applyVpnMode(VpnMode.BLOCK_ALL, emptySet())
-                        }
-                    } else if (now - anchor >= intervalMs) {
-                        inPulse = true
-                        pulseStartMillis = now
-                        persistCutoffState()
-                        applyVpnMode(VpnMode.BLOCK_ALL, emptySet())
-                    } else {
-                        applyVpnMode(VpnMode.FILTER, settings.whitelistedPackages)
-                    }
-                    nextCutoffAt = if (inPulse) pulseStartMillis + PULSE_DURATION_MS else anchor + intervalMs
-                    firewallFault = !FirewallVpnService.tunnelActive &&
-                        System.currentTimeMillis() - lastApplyMillis > TUNNEL_RETRY_DELAY_MS
-                    dataState = if (inPulse) DataState.CUT else if (percent >= WARNING_THRESHOLD) DataState.WARNING else DataState.OK
-            
-                }
-            }
-            else -> {
-                // Pas de réseau, transport inconnu, ou VPN non préparé/révoqué : rien à filtrer.
-                applyVpnMode(VpnMode.STOPPED, emptySet())
-                resetCutoffCycle()
-                // Sur données mobiles sans autorisation VPN valide, rien n'est filtré : à signaler.
-                firewallFault = latestTransport == NetworkTransport.CELLULAR
-                dataState = if (percent >= WARNING_THRESHOLD) DataState.WARNING else DataState.OK
-            }
         }
 
-        logDiagnostic(settings)
+        logDiagnostic(settings, up)
-
         stateHolder.update {
             it.copy(
                 consumedMo = consumedMo,
@@ -258,83 +182,106 @@ class DataMonitorService : LifecycleService() {
                 estimatedTotalPriceEuro = estimatedTotal,
                 dataState = dataState,
                 nextAutoResetDate = settings.nextAutoResetDate(),
-                nextCutoffAtMillis = nextCutoffAt,
+                serviceRunning = settings.controlEnabled,
-                serviceRunning = true,
+                firewallFault = fault,
-                firewallFault = firewallFault,
+                transport = latestTransport,
-                transport = latestTransport
+                paired = settings.isPaired,
+                tunnelUp = up,
+                lastHandshakeMs = if (up) tunnel.lastHandshakeMillis() else null,
+                serverMode = settings.serverMode,
+                serverModeReason = settings.serverModeReason,
+                tunnelError = tunnel.lastError
             )
         }
         updateNotification(stateHolder.snapshot.value)
     }
 
-    /** Écrit dans le journal POURQUOI le pare-feu est (ou n'est pas) actif, à chaque changement de situation. */
+    /**
-    private fun logDiagnostic(settings: AppSettings) {
+     * Appairage prévu par le QR de provisionnement : tenté toutes les minutes jusqu'à réussite ; la
-        val prepared = FirewallVpnService.isPrepared(this)
+     * protection s'active aussitôt. Un code refusé (expiré, déjà utilisé) est abandonné : appairage à la main.
+     */
+    private fun maybeProvisionPairing() {
+        val now = SystemClock.elapsedRealtime()
+        if (provisionJob?.isActive == true || (lastProvisionAttempt != 0L && now - lastProvisionAttempt < 60_000L)) return
+        lastProvisionAttempt = now
+        provisionJob = lifecycleScope.launch {
+            val (url, code, name) = settingsRepository.pendingProvision() ?: return@launch
+            val input = com.jttools.datacontrol.remote.PairingInput.parse("familyd://pair?url=$url&code=$code") ?: run {
+                settingsRepository.clearPendingProvision()
+                return@launch
+            }
+            remoteSync.pair(input, name.ifBlank { android.os.Build.MODEL }).fold(
+                onSuccess = {
+                    settingsRepository.clearPendingProvision()
+                    settingsRepository.setControlEnabled(true)
+                    AppLog.i("Propriétaire", "Associé automatiquement après provisionnement : protection activée")
+                },
+                onFailure = { e ->
+                    if ((e as? com.jttools.datacontrol.remote.ApiException)?.code in setOf(404, 409, 422)) {
+                        settingsRepository.clearPendingProvision()
+                        AppLog.w("Propriétaire", "Code du QR refusé (${e.message}) : associer à la main")
+                    }
+                }
+            )
+        }
+    }
+
+    /**
+     * Mode propriétaire : VPN toujours actif et réglages verrouillés tant que la protection est voulue.
+     * Garde-fou : sans poignée de main avec le serveur depuis [SERVER_LOST_MS], le blocage hors VPN est
+     * levé (l'enfant garde Internet si le serveur tombe) ; il revient dès que le serveur répond.
+     */
+    private fun applyOwnerPolicy(wanted: Boolean, up: Boolean) {
+        if (!OwnerPolicy.isDeviceOwner(this)) return
+        val now = SystemClock.elapsedRealtime()
+        val hs = if (up) tunnel.lastHandshakeMillis() else null
+        if (hs != null && System.currentTimeMillis() - hs < HANDSHAKE_FRESH_MS) serverSeenAt = now
+        val serverLost = now - serverSeenAt > SERVER_LOST_MS
+        if (wanted && serverLost != lockdownRelaxed) {
+            lockdownRelaxed = serverLost
+            lifecycleScope.launch {
+                if (serverLost) remoteSync.pushEvent("lockdown_relaxed", "Serveur injoignable depuis 15 min : blocage hors VPN levé")
+                else remoteSync.pushEvent("lockdown_restored", "Serveur de nouveau joignable : blocage hors VPN rétabli")
+            }
+        }
+        OwnerPolicy.sync(this, OwnerPolicy.Target(protect = wanted, lockdown = wanted && !serverLost,
+            blockInstalls = latestSettings.blockInstalls))
+    }
+
+    /** Monte le tunnel, au plus une tentative toutes les [TUNNEL_RETRY_MS] (évite de boucler contre un autre VPN). */
+    private fun maybeBringUp(settings: AppSettings) {
+        val link = settings.link ?: return
+        val now = SystemClock.elapsedRealtime()
+        if (tunnelJob?.isActive == true || (lastTunnelAttempt != 0L && now - lastTunnelAttempt < TUNNEL_RETRY_MS)) return
+        if (!TunnelManager.isPrepared(this)) return   // autorisation VPN à redonner à l'ouverture de l'appli
+        lastTunnelAttempt = now
+        tunnelJob = lifecycleScope.launch {
+            val key = settingsRepository.wgPrivateKey()
+            if (key == null) {
+                AppLog.e("Tunnel", "Clé WireGuard illisible (Keystore réinitialisé ?) : associer de nouveau le téléphone")
+                return@launch
+            }
+            if (tunnel.ensureUp(link, key)) remoteSync.syncOnce()
+            tick()
+        }
+    }
+
+    /** Écrit dans le journal POURQUOI le tunnel est (ou n'est pas) monté, à chaque changement de situation. */
+    private fun logDiagnostic(settings: AppSettings, up: Boolean) {
+        val prepared = TunnelManager.isPrepared(this)
         val expected = when {
+            !settings.isPaired -> "appareil non associé au serveur"
             !settings.controlEnabled -> "contrôle désactivé"
-            latestTransport == NetworkTransport.WIFI ->
+            !prepared -> "autorisation VPN absente"
-                if (settings.wifiFilterEnabled && prepared) "Wi-Fi filtré" else "Wi-Fi : pas de filtrage (normal, le VPN ne se monte que sur données mobiles)"
+            up -> "tunnel monté, filtrage par le serveur (mode ${settings.serverMode})"
-            latestTransport == NetworkTransport.CELLULAR ->
+            else -> "tunnel attendu mais non monté${tunnel.lastError?.let { " : $it" } ?: ""}"
-                if (!prepared) "données mobiles mais autorisation VPN absente" else if (vpnRevoked) "données mobiles mais VPN révoqué" else "données mobiles : pare-feu attendu"
-            else -> "aucun réseau actif (${latestTransport})"
         }
         val guard = com.jttools.datacontrol.guard.AppGuardService.isEnabled(this)
-        val diag = "réseau=$latestTransport contrôle=${settings.controlEnabled} vpnAutorisé=$prepared " +
+        val diag = "réseau=$latestTransport contrôle=${settings.controlEnabled} associé=${settings.isPaired} " +
-            "tunnelMonté=${FirewallVpnService.tunnelActive} accessibilité=$guard révoqué=$vpnRevoked " +
+            "vpnAutorisé=$prepared tunnel=$up accessibilité=$guard → $expected"
-            "mode=${lastAppliedMode ?: "—"} → $expected"
         if (diag != lastDiagnostic) {
             lastDiagnostic = diag
-            AppLog.i("Pare-feu", diag)
+            AppLog.i("Tunnel", diag)
-        }
-    }
-
-    private fun resetCutoffCycle() {
-        if (cutoffCycleAnchorMillis == null && !inPulse) return
-        cutoffCycleAnchorMillis = null
-        inPulse = false
-        persistCutoffState()
-    }
-
-    private fun persistCutoffState() {
-        val anchor = cutoffCycleAnchorMillis
-        val pulse = inPulse
-        val pulseStart = pulseStartMillis
-        lifecycleScope.launch { settingsRepository.setCutoffCycleState(anchor, pulse, pulseStart) }
-    }
-
-    private fun maybeAutoReset(settings: AppSettings) {
-        if (settings.autoResetEnabled && !LocalDate.now().isBefore(settings.nextAutoResetDate())) {
-            lifecycleScope.launch {
-                settingsRepository.resetPlan(usageRepository.totalMobileBytes(), settings.nextAutoResetDate())
-            }
-        }
-    }
-
-    private fun applyVpnMode(mode: VpnMode, whitelist: Set<String>) {
-        // Si le tunnel a disparu (service VPN tué/relancé, établissement échoué), on le remonte au
-        // tick suivant au lieu de croire qu'il est toujours actif.
-        val tunnelLost = mode != VpnMode.STOPPED && !FirewallVpnService.tunnelActive &&
-            System.currentTimeMillis() - lastApplyMillis > TUNNEL_RETRY_DELAY_MS
-        if (!tunnelLost && mode == lastAppliedMode && (mode != VpnMode.FILTER || whitelist == lastAppliedWhitelist)) return
-        lastAppliedMode = mode
-        lastAppliedWhitelist = whitelist
-        lastApplyMillis = System.currentTimeMillis()
-        AppLog.i("Pare-feu", "→ mode $mode (${whitelist.size} app(s) autorisée(s))")
-        stateHolder.update { it.copy(appliedMode = mode.name, effectiveWhitelist = whitelist) }
-        // Une exception ici (démarrage de service de premier plan refusé, par ex.) ne doit ni faire
-        // planter l'application ni rester invisible : elle est tracée dans le journal.
-        try {
-            when (mode) {
-                VpnMode.STOPPED -> ContextCompat.startForegroundService(this, FirewallVpnService.stopIntent(this))
-                VpnMode.FILTER -> ContextCompat.startForegroundService(
-                    this, FirewallVpnService.startFilterIntent(this, whitelist)
-                )
-                VpnMode.BLOCK_ALL -> ContextCompat.startForegroundService(
-                    this, FirewallVpnService.startBlockAllIntent(this)
-                )
-            }
-        } catch (e: Exception) {
-            AppLog.e("Pare-feu", "Impossible de démarrer FirewallVpnService pour le mode $mode", e)
         }
     }
 
@@ -347,13 +294,19 @@ class DataMonitorService : LifecycleService() {
         ).apply { description = getString(R.string.notification_channel_description) }
         nm.createNotificationChannel(channel)
 
+        val modeLabel = when (snapshot.serverMode) {
+            "cut" -> getString(R.string.mode_cut)
+            "allowlist" -> getString(R.string.mode_allowlist)
+            "blocklist" -> getString(R.string.mode_blocklist)
+            else -> getString(R.string.mode_open)
+        }
         val (emoji, stateLabel, color) = when {
-            snapshot.firewallFault -> Triple("⚠️", getString(R.string.dashboard_state_warning), Color.parseColor("#C62828"))
+            snapshot.firewallFault -> Triple("⚠️", getString(R.string.dashboard_tunnel_down), Color.parseColor("#C62828"))
             !snapshot.serviceRunning -> Triple("⚪", getString(R.string.dashboard_control_disabled), Color.parseColor("#757575"))
-            snapshot.dataState == DataState.OK -> Triple("🟢", getString(R.string.dashboard_state_ok), Color.parseColor("#2E7D32"))
+            snapshot.dataState == DataState.CUT -> Triple("🔴", modeLabel, Color.parseColor("#C62828"))
             snapshot.dataState == DataState.WARNING -> Triple("🟠", getString(R.string.dashboard_state_warning), Color.parseColor("#EF6C00"))
-            snapshot.dataState == DataState.CUT -> Triple("🔴", getString(R.string.dashboard_state_cut), Color.parseColor("#C62828"))
+            snapshot.dataState == DataState.WIFI -> Triple("🔵", getString(R.string.dashboard_state_wifi), Color.parseColor("#1565C0"))
-            else -> Triple("🔵", getString(R.string.dashboard_state_wifi), Color.parseColor("#1565C0"))
+            else -> Triple("🟢", getString(R.string.dashboard_state_ok), Color.parseColor("#2E7D32"))
         }
 
         val percentText = if (snapshot.planLimitMo > 0) {
@@ -361,12 +314,11 @@ class DataMonitorService : LifecycleService() {
         } else "—"
         val priceText = String.format(java.util.Locale.FRENCH, "%.2f", snapshot.estimatedTotalPriceEuro)
 
-        val warn = if (snapshot.firewallFault) "⚠️ PARE-FEU INACTIF — données non filtrées · " else ""
+        val usageText = "$emoji $stateLabel · ${snapshot.consumedMo}/${snapshot.planLimitMo} Mo ($percentText)"
-        val usageText = "$warn$emoji $stateLabel · ${snapshot.consumedMo}/${snapshot.planLimitMo} Mo ($percentText)"
         val costText = "${getString(R.string.dashboard_cost_total)} : $priceText €"
-        // Le total est aussi dans la vue repliée : sinon il n'est visible qu'une fois la notification dépliée.
         val contentText = "$usageText · $priceText €"
-        val bigText = "$usageText\n$costText"
+        val reason = snapshot.serverModeReason.takeIf { it.isNotBlank() && snapshot.serverMode != "open" }
+        val bigText = listOfNotNull(usageText, reason?.let { "Raison : $it" }, costText).joinToString("\n")
 
         val openApp = PendingIntent.getActivity(
             this, 0, Intent(this, MainActivity::class.java), PendingIntent.FLAG_IMMUTABLE
@@ -391,19 +343,15 @@ class DataMonitorService : LifecycleService() {
         nm.notify(NOTIF_ID, buildNotification(snapshot))
     }
 
-    override fun onDestroy() {
-        runCatching { unregisterReceiver(vpnRevokedReceiver) }
-        super.onDestroy()
-    }
-
     companion object {
         private const val CHANNEL_ID = "datacontrol_monitor"
         private const val NOTIF_ID = 1001
         private const val TICK_INTERVAL_MS = 20_000L
-        private const val PULSE_DURATION_MS = 30_000L
+        private const val TUNNEL_RETRY_MS = 30_000L
-        private const val TUNNEL_RETRY_DELAY_MS = 5_000L
-        private const val VPN_RETRY_AFTER_REVOKE_MS = 30_000L
         private const val WARNING_THRESHOLD = 0.8f
+        /** WireGuard renouvelle la poignée de main toutes les 2 min tant que du trafic passe (keepalive compris). */
+        private const val HANDSHAKE_FRESH_MS = 3 * 60_000L
+        private const val SERVER_LOST_MS = 15 * 60_000L
 
         /**
          * Démarre le service. Renvoie faux si Android refuse (Android 12+ interdit de démarrer un service

app/src/main/java/com/jttools/datacontrol/service/FirewallVpnService.kt

@@ -1,196 +0,0 @@
-package com.jttools.datacontrol.service
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.net.VpnService
-import android.os.ParcelFileDescriptor
-import android.util.Log
-import androidx.core.app.NotificationCompat
-import com.jttools.datacontrol.MainActivity
-import com.jttools.datacontrol.R
-import com.jttools.datacontrol.log.AppLog
-import java.io.FileInputStream
-
-/**
- * Pare-feu local basé sur [VpnService], sans root.
- *
- * Ce service ne route ni ne transmet aucun paquet : les applications "autorisées" sont
- * exclues du tunnel via [Builder.addDisallowedApplication] (leur trafic continue de
- * transiter normalement par la vraie interface réseau). Toutes les autres applications
- * voient leur trafic capturé dans le tunnel VPN puis silencieusement ignoré ("trou noir"),
- * ce qui coupe leur accès Internet sans jamais toucher au Wi-Fi : ce service n'est démarré
- * par [DataMonitorService] que lorsque le réseau actif est la donnée mobile.
- */
-class FirewallVpnService : VpnService() {
-
-    private var tunInterface: ParcelFileDescriptor? = null
-    private var readerThread: Thread? = null
-    @Volatile private var running = false
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        // Le service est toujours lancé via startForegroundService() (y compris pour ACTION_STOP,
-        // cf. DataMonitorService.applyVpnMode) : le système impose un appel à startForeground()
-        // dans les 5 secondes qui suivent, sous peine de crash (ForegroundServiceDidNotStartInTimeException
-        // sur Android 12+), même si le service s'arrête immédiatement après.
-        try {
-            startForeground(NOTIF_ID, buildNotification())
-        } catch (e: Exception) {
-            AppLog.e(TAG, "startForeground() refusé", e)
-        }
-        AppLog.i(TAG, "onStartCommand action=${intent?.action?.substringAfterLast('.') ?: "null (relance système)"}")
-        when (intent?.action) {
-            ACTION_STOP -> {
-                AppLog.i(TAG, "Arrêt du tunnel demandé")
-                stopTunnel()
-                stopSelf()
-                return START_NOT_STICKY
-            }
-            ACTION_START_FILTER, ACTION_START_BLOCK_ALL -> {
-                val allowed = intent.getStringArrayListExtra(EXTRA_ALLOWED_PACKAGES)?.toSet() ?: emptySet()
-                establishTunnel(allowed)
-            }
-        }
-        return START_STICKY
-    }
-
-    private fun establishTunnel(allowedPackages: Set<String>) {
-        stopTunnel(keepForeground = true)
-        AppLog.i(TAG, "Établissement du tunnel : ${allowedPackages.size} application(s) exclue(s) du filtrage")
-
-        val builder = Builder()
-            .setSession("DataControl")
-            .addAddress(TUNNEL_ADDRESS, 32)
-            .addRoute("0.0.0.0", 0)
-            // Sans route IPv6, le trafic IPv6 des applications bloquées contournerait le pare-feu.
-            .addAddress(TUNNEL_ADDRESS_V6, 128)
-            .addRoute("::", 0)
-            .setBlocking(true)
-
-        // Notre propre app doit toujours pouvoir communiquer normalement.
-        addDisallowed(builder, packageName)
-        allowedPackages.forEach { addDisallowed(builder, it) }
-
-        tunInterface = runCatching { builder.establish() }.getOrElse {
-            Log.e(TAG, "Échec établissement du tunnel VPN", it)
-            AppLog.e(TAG, "establish() a échoué", it)
-            null
-        }
-
-        val fd = tunInterface ?: run {
-            AppLog.e(TAG, "Tunnel NON monté : establish() a renvoyé null (autorisation VPN retirée ou autre VPN prioritaire)")
-            return
-        }
-        AppLog.i(TAG, "Tunnel VPN monté (l'icône clé doit apparaître)")
-        running = true
-        tunnelActive = true
-        readerThread = Thread({ blackhole(fd) }, "datacontrol-vpn-blackhole").apply {
-            isDaemon = true
-            start()
-        }
-    }
-
-    private fun addDisallowed(builder: Builder, packageName: String) {
-        try {
-            builder.addDisallowedApplication(packageName)
-        } catch (e: PackageManager.NameNotFoundException) {
-            // Application désinstallée entre-temps : rien à exclure.
-        }
-    }
-
-    /** Lit et jette tout paquet appartenant aux applications non-autorisées : leur trafic n'aboutit jamais. */
-    private fun blackhole(fd: ParcelFileDescriptor) {
-        val input = FileInputStream(fd.fileDescriptor)
-        val buffer = ByteArray(32_767)
-        try {
-            while (running) {
-                val read = input.read(buffer)
-                if (read < 0) break
-            }
-        } catch (_ : Exception) {
-            // Interface fermée depuis stopTunnel() : fin normale du thread.
-        }
-    }
-
-    private fun stopTunnel(keepForeground: Boolean = false) {
-        running = false
-        tunnelActive = false
-        readerThread?.interrupt()
-        readerThread = null
-        tunInterface?.let { runCatching { it.close() } }
-        tunInterface = null
-        if (!keepForeground) {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-        }
-    }
-
-    override fun onRevoke() {
-        AppLog.w(TAG, "onRevoke : le système ou un autre VPN a repris la main")
-        stopTunnel()
-        sendBroadcast(Intent(ACTION_VPN_REVOKED).setPackage(packageName))
-        super.onRevoke()
-    }
-
-    override fun onDestroy() {
-        stopTunnel()
-        super.onDestroy()
-    }
-
-    private fun buildNotification(): Notification {
-        val nm = getSystemService(NotificationManager::class.java)
-        val channel = NotificationChannel(
-            CHANNEL_ID,
-            getString(R.string.notification_channel_name),
-            NotificationManager.IMPORTANCE_MIN
-        )
-        nm.createNotificationChannel(channel)
-        val openApp = PendingIntent.getActivity(
-            this, 0, Intent(this, MainActivity::class.java),
-            PendingIntent.FLAG_IMMUTABLE
-        )
-        return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle(getString(R.string.notification_title))
-            .setSmallIcon(R.drawable.ic_notification)
-            .setPriority(NotificationCompat.PRIORITY_MIN)
-            .setContentIntent(openApp)
-            .setOngoing(true)
-            .build()
-    }
-
-    companion object {
-        private const val TAG = "FirewallVpnService"
-        private const val CHANNEL_ID = "datacontrol_vpn"
-        private const val NOTIF_ID = 2001
-        private const val TUNNEL_ADDRESS = "10.10.10.1"
-        private const val TUNNEL_ADDRESS_V6 = "fd00:10:10::1"
-
-        /** Vrai tant que le tunnel est réellement établi (faux si le service a été tué/relancé sans intent). */
-        @Volatile var tunnelActive = false
-            private set
-
-        const val ACTION_START_FILTER = "com.jttools.datacontrol.action.VPN_START_FILTER"
-        const val ACTION_START_BLOCK_ALL = "com.jttools.datacontrol.action.VPN_START_BLOCK_ALL"
-        const val ACTION_STOP = "com.jttools.datacontrol.action.VPN_STOP"
-        const val ACTION_VPN_REVOKED = "com.jttools.datacontrol.action.VPN_REVOKED"
-        const val EXTRA_ALLOWED_PACKAGES = "allowed_packages"
-
-        fun isPrepared(context: Context): Boolean = prepare(context) == null
-
-        fun startFilterIntent(context: Context, allowedPackages: Collection<String>): Intent =
-            Intent(context, FirewallVpnService::class.java)
-                .setAction(ACTION_START_FILTER)
-                .putStringArrayListExtra(EXTRA_ALLOWED_PACKAGES, ArrayList(allowedPackages))
-
-        fun startBlockAllIntent(context: Context): Intent =
-            Intent(context, FirewallVpnService::class.java)
-                .setAction(ACTION_START_BLOCK_ALL)
-                .putStringArrayListExtra(EXTRA_ALLOWED_PACKAGES, ArrayList())
-
-        fun stopIntent(context: Context): Intent =
-            Intent(context, FirewallVpnService::class.java).setAction(ACTION_STOP)
-    }
-}

app/src/main/java/com/jttools/datacontrol/service/MonitorStateHolder.kt

@@ -14,14 +14,19 @@ data class MonitorSnapshot(
     val estimatedTotalPriceEuro: Double = 0.0,
     val dataState: DataState = DataState.OK,
     val nextAutoResetDate: LocalDate = LocalDate.now(),
-    val nextCutoffAtMillis: Long? = null,
+    /** Contrôle activé (tunnel attendu). */
     val serviceRunning: Boolean = false,
-    /** Contrôle activé sur données mobiles mais tunnel VPN non monté : les données ne sont PAS filtrées. */
+    /** Contrôle activé et appareil associé, mais tunnel non monté : le trafic n'est PAS filtré. */
     val firewallFault: Boolean = false,
     val transport: NetworkTransport = NetworkTransport.NONE,
-    /** Mode réellement appliqué au pare-feu : FILTER, BLOCK_ALL ou STOPPED. */
+    val paired: Boolean = false,
-    val appliedMode: String = "STOPPED",
+    val tunnelUp: Boolean = false,
-    val effectiveWhitelist: Set<String> = emptySet()
+    /** Dernière poignée de main avec le serveur (ms), null si aucune. */
+    val lastHandshakeMs: Long? = null,
+    /** Mode appliqué par le serveur : open, allowlist ou cut. */
+    val serverMode: String = "open",
+    val serverModeReason: String = "",
+    val tunnelError: String? = null
 )
 
 /**

app/src/main/java/com/jttools/datacontrol/ui/SystemActions.kt

@@ -13,7 +13,7 @@ import androidx.activity.ComponentActivity
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.core.content.ContextCompat
-import com.jttools.datacontrol.service.FirewallVpnService
+import com.jttools.datacontrol.vpn.TunnelManager
 
 /**
  * Regroupe les autorisations système nécessaires (VPN, notifications, batterie) pour que
@@ -88,7 +88,7 @@ class SystemActions(private val activity: ComponentActivity) {
 
     fun deactivateAdmin() = com.jttools.datacontrol.admin.AdminController.deactivate(activity)
 
-    fun isVpnPrepared(): Boolean = FirewallVpnService.isPrepared(activity)
+    fun isVpnPrepared(): Boolean = TunnelManager.isPrepared(activity)
 
     fun requestVpnPermission(onResult: (Boolean) -> Unit) {
         val intent = VpnService.prepare(activity)

app/src/main/java/com/jttools/datacontrol/ui/about/AboutContent.kt

@@ -1,8 +1,8 @@
 package com.jttools.datacontrol.ui.about
 
 /**
- * Contenu des sous-onglets de « À propos ». Chaque affirmation a été relevée dans le code, le README
+ * Contenu des sous-onglets de « À propos ». Chaque affirmation doit se vérifier dans le code, le README
- * ou le CHANGELOG du dépôt (voir le compte rendu de la refonte) : ne rien ajouter ici qui ne s'y vérifie pas.
+ * ou le CHANGELOG du dépôt : ne rien ajouter ici qui ne s'y vérifie pas.
  * Le journal, lui, n'est pas dans ce fichier : il est lu depuis CHANGELOG.md (cf. ChangelogParser).
  */
 data class AboutEntry(val title: String, val body: String)
@@ -11,105 +11,109 @@ data class AboutSection(val heading: String?, val entries: List<AboutEntry>)
 object AboutContent {
 
     val features = listOf(
+        AboutSection("Protection par le serveur", listOf(
+            AboutEntry("Tunnel WireGuard permanent", "Une fois le téléphone associé et la protection activée, tout son trafic (Wi-Fi comme données mobiles) passe par le serveur du parent, qui le filtre."),
+            AboutEntry("Trois modes décidés par le parent", "Accès libre, liste blanche seulement (par exemple Pronote), ou Internet coupé — à la main, ou selon des plages horaires, un forfait de données mobiles ou une coupure cyclique."),
+            AboutEntry("Services bloqués", "Le parent bloque des services (réseaux sociaux, jeux, vidéo…) par le DNS filtrant du serveur."),
+            AboutEntry("Notification permanente", "Mode en cours et sa raison, consommation et total estimé. « PROTECTION INACTIVE » s'affiche si le tunnel est coupé.")
+        )),
+        AboutSection("Applications et temps d'écran", listOf(
+            AboutEntry("Plages horaires, temps d'écran, applications interdites", "Appliqués sur le téléphone par un service d'accessibilité : verrouillage hors plage, limite quotidienne globale ou par application, ajout de temps, lancement refusé."),
+            AboutEntry("Date et heure", "Changer à la main la date, l'heure ou le fuseau ne contourne pas les plages horaires ni le temps d'écran : le changement est ignoré et signalé au parent.")
+        )),
         AboutSection("Données mobiles", listOf(
             AboutEntry("Suivi de la consommation", "Mesure les Mo consommés depuis le début du cycle, sans permission spéciale (compteur système TrafficStats)."),
-            AboutEntry("Forfait et coût estimé", "Volume, prix, prix par Mo hors-forfait et date de début se règlent ; le total estimé se met à jour en direct, notification comprise."),
+            AboutEntry("Forfait et coût estimé", "Volume, prix, prix par Mo hors-forfait et date de début se règlent ; le total estimé se met à jour en direct."),
-            AboutEntry("Réinitialisation", "Automatique chaque mois à la date anniversaire, ou manuelle depuis le tableau de bord. La consommation peut aussi être recalée à la main sur le décompte de l'opérateur."),
+            AboutEntry("Réinitialisation", "Automatique chaque mois à la date anniversaire, ou manuelle depuis le tableau de bord.")
-            AboutEntry("Liste blanche", "Sur données mobiles, seules les applications cochées ont accès à Internet."),
-            AboutEntry("Filtrage Wi-Fi optionnel", "Le Wi-Fi n'est jamais filtré par défaut ; une liste blanche Wi-Fi distincte peut être activée."),
-            AboutEntry("Coupure cyclique", "Toutes les X minutes (réglable), une coupure totale de 30 secondes s'applique aux données mobiles, liste blanche comprise."),
-            AboutEntry("Notification permanente", "Consommation, état en couleur et total estimé. Une alerte « PARE-FEU INACTIF » s'affiche si les données mobiles ne sont plus filtrées."),
-            AboutEntry("Reprise automatique", "Le suivi redémarre après un redémarrage de l'appareil et est relancé périodiquement si le système l'a arrêté.")
         )),
-        AboutSection("Protection", listOf(
+        AboutSection("Sur le téléphone", listOf(
-            AboutEntry("Mot de passe de verrouillage", "Protège les Réglages, la Liste blanche, l'effacement du journal et la désactivation du contrôle."),
+            AboutEntry("Mot de passe de verrouillage", "Protège l'accès aux Réglages et l'effacement du journal. Sur un téléphone associé, la désactivation de la protection et la sortie du mode propriétaire exigent en plus un code du serveur dicté par le parent."),
-            AboutEntry("Date et heure", "Changer à la main la date, l'heure ou le fuseau ne contourne pas les plages horaires ni le temps d'écran : le changement est ignoré et signalé au parent. Laissez l'heure automatique activée."),
+            AboutEntry("Code de désactivation / déverrouillage", "Couper la protection, dissocier, quitter le mode propriétaire ou lever le verrouillage parental demande un code à usage unique généré par le parent dans l'espace parents : l'enfant ne peut rien désactiver seul."),
             AboutEntry("Anti-désinstallation", "DataControl peut devenir administrateur de l'appareil : Android refuse alors de le désinstaller tant que la protection est active."),
-            AboutEntry("Journal de diagnostic", "L'onglet Journal montre l'état du VPN, les décisions du pare-feu et, si le service d'accessibilité est activé, chaque application utilisée avec son verdict réseau et lancement. Conservé 15 jours, avec copie et partage."),
+            AboutEntry("Journal de diagnostic", "État du tunnel, mode appliqué et, si le service d'accessibilité est activé, chaque application utilisée. Conservé 15 jours, avec copie et partage."),
-            AboutEntry("Mise à jour intégrée", "Recherche et installation de la dernière version publiée, depuis l'onglet Journal de cette page.")
+            AboutEntry("Mise à jour intégrée", "Recherche et installation de la dernière version publiée, depuis l'onglet Journal de cette page."),
-        )),
+            AboutEntry("Mise à jour poussée par le parent", "Depuis l'espace parents : la nouvelle version arrive par le tunnel, son empreinte est vérifiée, puis elle s'installe toute seule en mode propriétaire (sinon, touchez la notification « Mise à jour de DataControl »)."),
-        AboutSection("Contrôle parental (avec FamilyControl)", listOf(
+            AboutEntry("Actions à distance du parent", "Depuis l'espace parents : verrouiller / mettre en veille, couper ou rétablir le son, faire sonner, voir l'écran en direct, et verrouiller le téléphone sur un écran de blocage que seul un code du serveur lève. Le partage d'écran fonctionne dès Android 5 (MediaProjection) ou, sur Android 11+, par le service d'accessibilité ; une notification « Écran partagé avec le parent » reste affichée et le partage s'arrête tout seul au bout de 5 minutes."),
-            AboutEntry("Appairage par code", "L'appareil s'associe à l'application parent FamilyControl avec un code d'appairage."),
+            AboutEntry("Blocage des installations", "Le parent peut interdire l'installation de nouvelles applications (Play Store compris) ; appliqué en mode propriétaire de l'appareil."),
-            AboutEntry("Suivi à distance", "Batterie, position (arrière-plan compris si autorisé), état du pare-feu, trafic quotidien mobile/Wi-Fi et journal d'événements."),
+            AboutEntry("Reprise automatique", "La surveillance et le tunnel redémarrent après un redémarrage de l'appareil, et sont relancés périodiquement si le système les a arrêtés.")
-            AboutEntry("Accès réseau par application", "Le parent autorise ou bloque Internet application par application, sur données mobiles comme sur Wi-Fi."),
-            AboutEntry("Plages horaires, temps d'écran, applications interdites", "Appliqués par un service d'accessibilité : verrouillage hors plage, limite quotidienne globale ou par application, ajout de temps, lancement refusé."),
-            AboutEntry("Condition", "Ces fonctions demandent une configuration Firebase saisie dans Réglages → Contrôle parental, puis l'association à un compte parent.")
         ))
     )
 
     val howTo = listOf(
-        "Ouvrez « Réglages » et renseignez le forfait : volume (Mo), prix, prix par Mo hors-forfait, intervalle de coupure. Touchez « Enregistrer ».",
+        "Sur l'espace parents (family.tuxtech.fr), touchez « Associer un téléphone » : un code de 8 caractères s'affiche pendant 10 minutes.",
-        "Ouvrez « Liste blanche » et cochez les applications qui doivent garder Internet en données mobiles.",
+        "Dans DataControl, ouvrez « Réglages » → « Contrôle parental », saisissez le code et touchez « Associer ».",
-        "Dans « Réglages » → « Autorisations », accordez « Pare-feu local (VPN) », « Notifications » et « Optimisation de la batterie ».",
+        "Sur le « Tableau de bord », activez la protection et acceptez la demande VPN d'Android : l'icône clé apparaît.",
-        "Sur le « Tableau de bord », activez « Activer le contrôle » et acceptez la demande VPN d'Android.",
+        "Dans « Réglages » → « Autorisations », accordez « Notifications » et « Optimisation de la batterie » ; dans « Contrôle parental », activez le service d'accessibilité et la position si besoin.",
-        "Coupez le Wi-Fi : l'icône clé du VPN apparaît en données mobiles et la notification affiche l'état.",
+        "Recommandé : définissez un mot de passe dans « Réglages » → « Sécurité », puis activez la protection anti-désinstallation."
-        "Recommandé : définissez un mot de passe dans « Réglages » → « Sécurité »."
     )
 
     val everyday = listOf(
-        AboutEntry("Consulter la consommation", "Le Tableau de bord affiche les Mo consommés, le restant, le dépassement et le total estimé."),
+        AboutEntry("Changer l'accès à Internet", "Depuis l'espace parents : Libre, Liste blanche ou Coupé, pour une durée ou sans limite ; le téléphone l'applique en quelques secondes."),
-        AboutEntry("Repartir à zéro", "« Réinitialiser le forfait maintenant » sur le Tableau de bord, ou « Consommation actuelle » dans les Réglages pour recaler sur l'opérateur."),
+        AboutEntry("Consulter la consommation", "Le Tableau de bord affiche les Mo consommés, le restant et le total estimé ; l'espace parents affiche le trafic mesuré par le serveur."),
-        AboutEntry("Changer une application autorisée", "Onglet « Liste blanche » : onglets « Données mobiles » et « Wi-Fi », recherche et sélection multiple.")
+        AboutEntry("Repartir à zéro", "« Réinitialiser le forfait maintenant » sur le Tableau de bord, ou « Consommation actuelle » dans les Réglages.")
     )
 
     val troubleshooting = listOf(
-        AboutEntry("Je ne vois pas l'icône VPN", "Le pare-feu ne se monte que sur données mobiles, contrôle activé. Sur Wi-Fi, il n'y en a jamais (sauf filtrage Wi-Fi activé). Consultez l'onglet Journal : il donne la raison exacte."),
+        AboutEntry("« PROTECTION INACTIVE » dans la notification", "Le tunnel est coupé : autorisation VPN retirée, autre VPN actif, ou serveur injoignable. Rouvrez DataControl pour redonner l'autorisation VPN ; le Journal donne la raison exacte."),
-        AboutEntry("« PARE-FEU INACTIF » dans la notification", "Les données mobiles ne sont pas filtrées : autorisation VPN retirée ou tunnel non monté. Rouvrez DataControl pour redonner l'autorisation VPN, et lisez le Journal."),
+        AboutEntry("Un autre VPN a pris la main", "Un seul VPN peut être actif sous Android. La protection reste activée mais ne filtre plus : la notification passe en rouge, le parent est alerté et DataControl retente toutes les 30 s."),
-        AboutEntry("Un autre VPN a pris la main", "Un seul VPN peut être actif sous Android. Le contrôle reste activé mais ne filtre plus : la notification passe en rouge, le parent est alerté et DataControl retente toutes les 30 s ; à l'ouverture, l'autorisation VPN est redemandée."),
+        AboutEntry("« Code inconnu, déjà utilisé ou expiré »", "Un code ne sert qu'une fois et vit 10 minutes : créez-en un nouveau dans l'espace parents."),
         AboutEntry("Le service d'accessibilité est grisé (Android 13+)", "Ouvrez Infos sur l'application → ⋮ → « Autoriser les paramètres restreints », puis réessayez.")
     )
 
     val prerequisites = listOf(
         AboutSection("Système", listOf(
             AboutEntry("Android 8.0 ou plus", "Version minimale déclarée par l'application (API 26) ; cible : Android 14 (API 34)."),
-            AboutEntry("Ni root, ni Shizuku", "Le filtrage repose sur le VPN local d'Android."),
+            AboutEntry("Ni root, ni Shizuku", "Le tunnel repose sur le VPN standard d'Android."),
-            AboutEntry("Un seul VPN à la fois", "Le pare-feu est incompatible avec un autre VPN actif en même temps.")
+            AboutEntry("Un seul VPN à la fois", "DataControl est incompatible avec un autre VPN actif en même temps.")
         )),
         AboutSection("Autorisations", listOf(
-            AboutEntry("VPN (obligatoire)", "Consentement système demandé à l'activation du contrôle."),
+            AboutEntry("VPN (obligatoire)", "Consentement système demandé à l'activation de la protection."),
             AboutEntry("Notifications (Android 13+)", "Pour l'état permanent."),
             AboutEntry("Optimisation de la batterie (recommandé)", "Évite que le système n'arrête la surveillance."),
-            AboutEntry("Liste des applications", "Permission QUERY_ALL_PACKAGES, pour afficher toutes les applications dans la Liste blanche."),
+            AboutEntry("Liste des applications", "Permission QUERY_ALL_PACKAGES, pour que le parent choisisse les applications à limiter."),
-            AboutEntry("Contrôle parental (facultatif)", "Position (avec « Toujours autoriser » pour l'arrière-plan), administrateur de l'appareil, service d'accessibilité.")
+            AboutEntry("Facultatif", "Position (avec « Toujours autoriser » pour l'arrière-plan), administrateur de l'appareil, service d'accessibilité.")
         )),
         AboutSection("Réseau", listOf(
-            AboutEntry("Sortant, HTTPS (TCP 443)", "Recherche de mise à jour (git.tuxtech.fr) et, si l'appareil est associé, échanges avec Firebase. Aucun port entrant, aucune redirection de port.")
+            AboutEntry("Sortant, UDP 51721", "Tunnel WireGuard vers le serveur du parent (fam-vpn.tuxtech.fr)."),
+            AboutEntry("Sortant, HTTPS (TCP 443)", "Appairage (family.tuxtech.fr) et recherche de mise à jour (git.tuxtech.fr). Aucun port entrant.")
         ))
     )
 
     val security = listOf(
-        AboutSection("Pare-feu", listOf(
+        AboutSection("Tunnel", listOf(
-            AboutEntry("Tunnel local sans transfert", "Le VPN ne route ni ne transmet aucun paquet : le trafic des applications non autorisées entre dans le tunnel et y est abandonné."),
+            AboutEntry("WireGuard officiel", "Bibliothèque com.wireguard.android (wireguard-go) : chiffrement moderne, aucune donnée en clair entre le téléphone et le serveur."),
-            AboutEntry("IPv4 et IPv6", "Les deux familles d'adresses sont capturées, pour qu'une application bloquée ne contourne pas le pare-feu en IPv6."),
+            AboutEntry("Clé privée sur le téléphone", "La paire de clés est générée sur le téléphone à l'appairage ; la clé privée ne le quitte jamais et est chiffrée par l'Android Keystore."),
-            AboutEntry("Reprise si le tunnel disparaît", "Si le service VPN est arrêté par le système, le tunnel est remonté automatiquement ; sinon la notification le signale."),
+            AboutEntry("Tout le trafic, IPv4 et IPv6", "Le tunnel couvre 0.0.0.0/0 et ::/0 : aucune application ne le contourne en IPv6."),
-            AboutEntry("DataControl jamais bloqué", "L'application est toujours exclue du tunnel : la liaison avec le parent ne peut pas être coupée par le pare-feu.")
+            AboutEntry("Reprise si le tunnel tombe", "La protection reste activée, le parent est prévenu et le tunnel est remonté dès que possible.")
+        )),
+        AboutSection("Liaison avec le serveur", listOf(
+            AboutEntry("Appairage", "Code aléatoire à usage unique, valable 10 minutes, créé par le parent ; l'appairage passe en HTTPS."),
+            AboutEntry("Jeton lié au tunnel", "Le jeton de l'appareil, chiffré par l'Android Keystore, n'est accepté par le serveur que depuis l'adresse du téléphone dans le tunnel."),
+            AboutEntry("Filtrage côté serveur", "Le téléphone ne peut pas lever lui-même une coupure décidée par le parent : elle s'applique sur le serveur.")
         )),
         AboutSection("Accès à l'application", listOf(
             AboutEntry("Mot de passe", "Haché avec PBKDF2-HMAC-SHA256 (100 000 itérations) et un sel aléatoire de 16 octets, jamais stocké en clair. Après 3 essais ratés, attente croissante de 30 s à 15 min."),
-            AboutEntry("Anti-désinstallation", "Administrateur d'appareil. Limite : la protection peut être retirée depuis les Réglages Android ; si l'appareil est associé, le parent en est alerté. La demande de mot de passe ne s'applique qu'au retrait fait depuis DataControl.")
+            AboutEntry("Anti-désinstallation", "Administrateur d'appareil. Limite : la protection peut être retirée depuis les Réglages Android ; le parent en est alerté."),
-        )),
-        AboutSection("Liaison FamilyControl", listOf(
-            AboutEntry("Appairage", "Code aléatoire à usage unique et à durée limitée (10 minutes) créé côté parent. Connexion anonyme Firebase côté appareil, compte e-mail côté parent."),
-            AboutEntry("Règles Firestore", "Fournies avec FamilyControl (firebase/firestore.rules) : l'appareil n'écrit que dans son propre espace et ne peut pas modifier les consignes du parent."),
             AboutEntry("Service d'accessibilité", "Détecte uniquement l'application au premier plan : la lecture du contenu des écrans est désactivée (canRetrieveWindowContent = false)."),
             AboutEntry("Applications exemptées", "Lanceur, téléphone, clavier et DataControl ne sont jamais bloqués, pour que l'appareil reste utilisable.")
         )),
         AboutSection("Limites connues", listOf(
-            AboutEntry("Signature de l'APK", "Le build release est actuellement signé avec la clé de debug d'Android. Android n'accepte une mise à jour que si elle porte la même signature que l'application installée."),
+            AboutEntry("Retrait du VPN", "Sans le mode « propriétaire de l'appareil » (prévu plus tard), le VPN peut être coupé dans les réglages Android : le serveur le voit et alerte le parent, sans pouvoir l'empêcher."),
-            AboutEntry("Téléchargement des mises à jour", "L'APK est récupéré en HTTPS depuis la release Gitea ; aucune empreinte supplémentaire n'est vérifiée par l'application.")
+            AboutEntry("Téléchargement des mises à jour", "L'APK est récupéré en HTTPS depuis la release Gitea ; Android vérifie qu'il porte la même signature que l'application installée.")
         ))
     )
 
     val guarantees = listOf(
         AboutSection("Vos données", listOf(
-            AboutEntry("Aucune télémétrie", "Le code ne contient ni analytique ni publicité. Les seuls accès réseau sont la recherche de mise à jour et, si l'appareil est associé, Firebase."),
+            AboutEntry("Aucune télémétrie", "Le code ne contient ni analytique ni publicité. Les seuls échanges sont avec le serveur du parent et la recherche de mise à jour."),
             AboutEntry("Sans appairage, rien ne sort", "Non associé, l'appareil n'envoie rien ; la recherche de mise à jour ne part que lorsque vous touchez le bouton."),
             AboutEntry("Le mot de passe reste sur l'appareil", "Il n'est jamais transmis, pas même haché."),
-            AboutEntry("Appareil associé : ce qui est envoyé", "Nom de l'appareil, batterie, position, état du pare-feu et du contrôle, listes d'applications autorisées, consommation du forfait, liste des applications installées, trafic quotidien mobile/Wi-Fi, temps d'écran par application, événements.")
+            AboutEntry("Appareil associé : ce qui est envoyé", "Nom et modèle, batterie, position (si autorisée), type de réseau, état des protections, liste des applications installées, temps d'écran par application, évènements.")
         )),
-        AboutSection("Ce qui n'est jamais lu", listOf(
+        AboutSection("Ce que voit le serveur", listOf(
-            AboutEntry("Contenu des écrans et messages", "Le service d'accessibilité ne lit pas le contenu des fenêtres."),
+            AboutEntry("Noms de domaine et volume", "Comme tout le trafic passe par le serveur du parent, celui-ci voit les sites demandés (journal DNS conservé 7 jours) et le volume échangé."),
-            AboutEntry("Contenu du trafic", "Le VPN ne route rien et n'inspecte aucun paquet.")
+            AboutEntry("Pas le contenu", "Les échanges chiffrés des applications (HTTPS) restent illisibles pour le serveur ; le service d'accessibilité ne lit pas le contenu des écrans."),
+            AboutEntry("Partage d'écran visible", "Le parent ne peut voir l'écran que pendant un partage qu'il déclenche ; le téléphone l'affiche alors en permanence (bandeau rouge) et le partage s'arrête seul au bout de 5 minutes. Aucune capture en dehors de ces moments.")
         )),
         AboutSection("Privilèges et licence", listOf(
             AboutEntry("Rien d'activé à votre insu", "VPN, position, administrateur d'appareil et accessibilité passent chacun par une autorisation explicite d'Android."),
@@ -118,15 +122,14 @@ object AboutContent {
     )
 
     val choices = listOf(
-        AboutEntry("VpnService plutôt qu'une coupure des données", "Android interdit aux applications normales de couper les données mobiles depuis Android 5. Le VPN local fonctionne sans root ni Shizuku, sur le principe de NetGuard."),
+        AboutEntry("Filtrage sur le serveur plutôt que sur le téléphone", "Le téléphone ne peut pas contourner une règle appliquée ailleurs ; le filtrage couvre aussi le Wi-Fi et se pilote depuis l'espace parents."),
-        AboutEntry("Exclusion d'applications plutôt que relais de paquets", "Les applications autorisées sont exclues du tunnel (addDisallowedApplication) : leur trafic passe normalement, sans passer par l'application."),
+        AboutEntry("WireGuard plutôt qu'un autre VPN", "Protocole léger et sobre en batterie, bibliothèque officielle ; un seul VPN sur le téléphone, donc aucun conflit."),
+        AboutEntry("Serveur auto-hébergé plutôt que Firebase", "Aucune dépendance à un service tiers : les données restent sur le serveur du parent."),
         AboutEntry("TrafficStats plutôt que NetworkStatsManager", "Le compteur système cumulé ne demande aucune permission spéciale. Contrepartie : il repart de zéro au redémarrage, l'application recale alors sa référence."),
         AboutEntry("Service de premier plan + relance périodique", "Un service permanent et une tâche WorkManager toutes les 15 minutes, car certains systèmes arrêtent agressivement les applications en arrière-plan."),
         AboutEntry("Kotlin, Jetpack Compose (Material 3), Hilt, DataStore", "Interface déclarative et thème dynamique (Android 12+) ; réglages dans DataStore Preferences."),
-        AboutEntry("HttpURLConnection plutôt qu'un client HTTP tiers", "Seule la mise à jour fait un appel HTTP : pas de dépendance réseau supplémentaire pour cela."),
+        AboutEntry("HttpURLConnection plutôt qu'un client HTTP tiers", "Quelques appels simples vers le serveur et Gitea : pas de dépendance réseau supplémentaire."),
-        AboutEntry("Firebase sans plugin google-services", "La configuration se saisit dans l'application (Réglages → Contrôle parental) et peut changer sans recompiler ; sans elle, le contrôle à distance est simplement désactivé. Un fichier firebase.properties à la compilation reste possible comme valeur par défaut."),
         AboutEntry("Service d'accessibilité plutôt que statistiques d'usage", "Permet de renvoyer à l'accueil et d'afficher un écran de blocage dès qu'une application interdite passe au premier plan."),
-        AboutEntry("Administrateur d'appareil plutôt que Device Owner", "Pas de réinitialisation d'usine ni de branchement à un PC ; en contrepartie, la protection est moins robuste."),
         AboutEntry("Journal embarqué", "Le journal de diagnostic est conservé 15 jours (20 000 lignes au plus) dans un fichier local ; le changelog de cette page est le CHANGELOG.md du dépôt, embarqué dans l'APK.")
     )
 

app/src/main/java/com/jttools/datacontrol/ui/components/PasswordComponents.kt

@@ -27,6 +27,7 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.unit.dp
@@ -136,3 +137,49 @@ fun PasswordPromptDialog(
         }
     )
 }
+
+/**
+ * Boîte de dialogue qui exige un code du serveur (dicté par le parent) pour une action sensible :
+ * désactiver le contrôle, se dissocier, sortir du mode propriétaire. Remplace le mot de passe local.
+ */
+@Composable
+fun UnlockCodeDialog(
+    title: String,
+    message: String,
+    error: String?,
+    busy: Boolean,
+    onDismiss: () -> Unit,
+    onConfirm: (String) -> Unit
+) {
+    var code by remember { mutableStateOf("") }
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(title) },
+        text = {
+            Column {
+                Text(message, style = MaterialTheme.typography.bodyMedium)
+                Spacer(Modifier.height(12.dp))
+                OutlinedTextField(
+                    value = code,
+                    onValueChange = { code = it.take(20) },
+                    label = { Text(stringResource(R.string.unlock_code_field)) },
+                    keyboardOptions = KeyboardOptions(capitalization = KeyboardCapitalization.Characters),
+                    isError = error != null,
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth()
+                )
+                error?.let {
+                    Spacer(Modifier.height(4.dp))
+                    Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+                }
+            }
+        },
+        confirmButton = {
+            Button(enabled = !busy, onClick = { onConfirm(code) }) { Text(stringResource(R.string.common_confirm)) }
+        },
+        dismissButton = {
+            OutlinedButton(onClick = onDismiss) { Text(stringResource(R.string.common_cancel)) }
+        }
+    )
+}

app/src/main/java/com/jttools/datacontrol/ui/dashboard/DashboardScreen.kt

@@ -42,6 +42,7 @@ import com.jttools.datacontrol.data.DataState
 import com.jttools.datacontrol.service.DataMonitorService
 import com.jttools.datacontrol.ui.SystemActions
 import com.jttools.datacontrol.ui.components.PasswordPromptDialog
+import com.jttools.datacontrol.ui.components.UnlockCodeDialog
 import com.jttools.datacontrol.ui.theme.StateCut
 import com.jttools.datacontrol.ui.theme.StateOk
 import com.jttools.datacontrol.ui.theme.StateWarning
@@ -60,6 +61,9 @@ fun DashboardScreen(systemActions: SystemActions) {
     var showResetDialog by remember { mutableStateOf(false) }
     var showDisablePasswordDialog by remember { mutableStateOf(false) }
     var disablePasswordError by remember { mutableStateOf<String?>(null) }
+    var showUnlockCodeDialog by remember { mutableStateOf(false) }
+    var unlockCodeError by remember { mutableStateOf<String?>(null) }
+    var unlockBusy by remember { mutableStateOf(false) }
     val scope = rememberCoroutineScope()
 
     val stateColor = when {
@@ -70,10 +74,12 @@ fun DashboardScreen(systemActions: SystemActions) {
         else -> StateCut
     }
     val stateLabel = when {
+        snapshot.firewallFault -> stringResource(R.string.dashboard_tunnel_down)
         !snapshot.serviceRunning -> stringResource(R.string.dashboard_control_disabled)
         snapshot.dataState == DataState.OK -> stringResource(R.string.dashboard_state_ok)
         snapshot.dataState == DataState.WARNING -> stringResource(R.string.dashboard_state_warning)
-        snapshot.dataState == DataState.CUT -> stringResource(R.string.dashboard_state_cut)
+        snapshot.dataState == DataState.CUT ->
+            stringResource(if (snapshot.serverMode == "cut") R.string.mode_cut else R.string.mode_allowlist)
         else -> stringResource(R.string.dashboard_state_wifi)
     }
 
@@ -161,7 +167,9 @@ fun DashboardScreen(systemActions: SystemActions) {
                     Switch(
                         checked = settings.controlEnabled,
                         onCheckedChange = { checked ->
-                            if (checked) {
+                            if (checked && !settings.isPaired) {
+                                android.widget.Toast.makeText(context, context.getString(R.string.dashboard_pair_first), android.widget.Toast.LENGTH_LONG).show()
+                            } else if (checked) {
                                 systemActions.requestNotificationPermission { _ ->
                                     systemActions.requestVpnPermission { granted ->
                                         com.jttools.datacontrol.log.AppLog.i("Tableau de bord", "Activation du contrôle : autorisation VPN ${if (granted) "accordée" else "REFUSÉE"}")
@@ -171,12 +179,19 @@ fun DashboardScreen(systemActions: SystemActions) {
                                         }
                                     }
                                 }
-                            } else if (passwordSet != null) {   // null : réglages pas encore chargés
+                            } else {   // désactivation du contrôle
-                                if (passwordSet == true) {
+                                when {
+                                    // Appareil associé : seul un code du serveur (dicté par le parent) l'autorise.
+                                    settings.isPaired -> {
+                                        unlockCodeError = null
+                                        unlockBusy = false
+                                        showUnlockCodeDialog = true
+                                    }
+                                    passwordSet == true -> {
                                         disablePasswordError = null
                                         showDisablePasswordDialog = true
-                                } else {
+                                    }
-                                    viewModel.setControlEnabled(false)
+                                    passwordSet != null -> viewModel.setControlEnabled(false)
                                 }
                             }
                         }
@@ -192,24 +207,30 @@ fun DashboardScreen(systemActions: SystemActions) {
                     style = MaterialTheme.typography.bodyMedium
                 )
 
-                val nextCutoffText = when {
+                // Mode décidé par le serveur familyd et état du tunnel.
+                val modeText = when (snapshot.serverMode) {
+                    "cut" -> stringResource(R.string.mode_cut)
+                    "allowlist" -> stringResource(R.string.mode_allowlist)
+                    "blocklist" -> stringResource(R.string.mode_blocklist)
+                    else -> stringResource(R.string.mode_open)
+                }
+                val tunnelText = when {
+                    !snapshot.paired -> stringResource(R.string.dashboard_not_paired)
                     !settings.controlEnabled -> stringResource(R.string.dashboard_control_disabled)
-                    snapshot.dataState == DataState.WIFI -> stringResource(R.string.dashboard_cutoff_wifi)
+                    snapshot.tunnelUp -> stringResource(R.string.dashboard_tunnel_up) +
-                    snapshot.dataState == DataState.CUT -> stringResource(R.string.dashboard_cutoff_in_progress)
+                        (snapshot.lastHandshakeMs?.let { " · " + DateTimeFormatter.ofPattern("HH:mm:ss")
-                    snapshot.nextCutoffAtMillis != null -> {
+                            .format(java.time.Instant.ofEpochMilli(it).atZone(java.time.ZoneId.systemDefault())) } ?: "")
-                        val remainingMs = (snapshot.nextCutoffAtMillis!! - System.currentTimeMillis()).coerceAtLeast(0L)
+                    else -> stringResource(R.string.dashboard_tunnel_down) + (snapshot.tunnelError?.let { " ($it)" } ?: "")
-                        stringResource(
-                            R.string.dashboard_cutoff_countdown,
-                            remainingMs / 60_000,
-                            (remainingMs / 1000) % 60
-                        )
-                    }
-                    else -> stringResource(R.string.dashboard_cutoff_unavailable)
                 }
+                Text("${stringResource(R.string.dashboard_tunnel)} : $tunnelText", style = MaterialTheme.typography.bodyMedium,
+                    color = if (snapshot.firewallFault) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface)
+                if (snapshot.paired) {
                     Text(
-                    "${stringResource(R.string.dashboard_next_cutoff)}: $nextCutoffText",
+                        "${stringResource(R.string.dashboard_server_mode)} : $modeText" +
+                            (snapshot.serverModeReason.takeIf { it.isNotBlank() && snapshot.serverMode != "open" }?.let { " ($it)" } ?: ""),
                         style = MaterialTheme.typography.bodyMedium
                     )
+                }
 
                 OutlinedButton(onClick = { showResetDialog = true }, modifier = Modifier.fillMaxWidth()) {
                     Text(stringResource(R.string.dashboard_reset_now))
@@ -237,6 +258,29 @@ fun DashboardScreen(systemActions: SystemActions) {
         )
     }
 
+    if (showUnlockCodeDialog) {
+        UnlockCodeDialog(
+            title = stringResource(R.string.unlock_code_title),
+            message = stringResource(R.string.unlock_code_message),
+            error = unlockCodeError,
+            busy = unlockBusy,
+            onDismiss = { showUnlockCodeDialog = false },
+            onConfirm = { code ->
+                unlockBusy = true
+                scope.launch {
+                    val error = viewModel.verifyUnlock(code)
+                    unlockBusy = false
+                    if (error == null) {
+                        viewModel.setControlEnabled(false)
+                        showUnlockCodeDialog = false
+                    } else {
+                        unlockCodeError = error
+                    }
+                }
+            }
+        )
+    }
+
     if (showDisablePasswordDialog) {
         PasswordPromptDialog(
             title = stringResource(R.string.password_gate_title),

app/src/main/java/com/jttools/datacontrol/ui/dashboard/DashboardViewModel.kt

@@ -5,6 +5,7 @@ import androidx.lifecycle.viewModelScope
 import com.jttools.datacontrol.data.AppSettings
 import com.jttools.datacontrol.data.SettingsRepository
 import com.jttools.datacontrol.data.UsageRepository
+import com.jttools.datacontrol.remote.RemoteSync
 import com.jttools.datacontrol.service.MonitorStateHolder
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.SharingStarted
@@ -18,6 +19,7 @@ import javax.inject.Inject
 class DashboardViewModel @Inject constructor(
     private val settingsRepository: SettingsRepository,
     private val usageRepository: UsageRepository,
+    private val remoteSync: RemoteSync,
     stateHolder: MonitorStateHolder
 ) : ViewModel() {
 
@@ -41,4 +43,7 @@ class DashboardViewModel @Inject constructor(
 
     /** null si le mot de passe est bon, sinon le message d'erreur. */
     suspend fun checkPassword(password: String): String? = settingsRepository.checkPassword(password)
+
+    /** Vérifie le code du serveur (action "deactivate") dicté par le parent. null = accepté. */
+    suspend fun verifyUnlock(code: String): String? = remoteSync.verifyUnlock(code, "deactivate")
 }

app/src/main/java/com/jttools/datacontrol/ui/family/FamilySection.kt

@@ -32,20 +32,18 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.LifecycleEventEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.jttools.datacontrol.R
+import com.jttools.datacontrol.admin.OwnerPolicy
 import com.jttools.datacontrol.ui.SystemActions
+import com.jttools.datacontrol.ui.components.UnlockCodeDialog
 import com.jttools.datacontrol.ui.theme.StateOk
 import kotlinx.coroutines.launch
 
-/** Carte « Contrôle parental » des réglages : appairage FamilyControl, anti-désinstallation, position. */
+/** Carte « Contrôle parental » des réglages : liaison avec le serveur familyd, anti-désinstallation, position. */
 @Composable
 fun FamilySection(systemActions: SystemActions) {
     val vm: FamilyViewModel = hiltViewModel()
     val settings by vm.settings.collectAsStateWithLifecycle()
     val pairing by vm.pairing.collectAsStateWithLifecycle()
-    val gw by vm.gatewayState.collectAsStateWithLifecycle()
-    var firebaseText by remember { mutableStateOf("") }
-    var firebaseError by remember { mutableStateOf<String?>(null) }
-    var editFirebase by remember { mutableStateOf(false) }
     val scope = rememberCoroutineScope()
 
     var adminActive by remember { mutableStateOf(systemActions.isAdminActive()) }
@@ -55,13 +53,23 @@ fun FamilySection(systemActions: SystemActions) {
     var code by remember { mutableStateOf("") }
     var deviceName by remember { mutableStateOf(android.os.Build.MODEL) }
 
-    // Action sensible en attente de confirmation par mot de passe : "admin" ou "unpair".
+    // Action sensible en attente de confirmation par mot de passe : "admin", "unpair" ou "owner".
     var pendingAction by remember { mutableStateOf<String?>(null) }
     var pwd by remember { mutableStateOf("") }
     var pwdError by remember { mutableStateOf<String?>(null) }
 
+    // Même action, mais confirmée par un code du serveur quand l'appareil est associé (remplace le mot de passe).
+    var pendingCodeAction by remember { mutableStateOf<String?>(null) }
+    var codeError by remember { mutableStateOf<String?>(null) }
+    var codeBusy by remember { mutableStateOf(false) }
+
     // Au retour des écrans système (accessibilité, permissions, admin), on relit l'état réel.
+    val context = androidx.compose.ui.platform.LocalContext.current
+    var owner by remember { mutableStateOf(OwnerPolicy.isDeviceOwner(context)) }
+    var ownerError by remember { mutableStateOf(false) }
+
     LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
+        owner = OwnerPolicy.isDeviceOwner(context)
         adminActive = systemActions.isAdminActive()
         locationGranted = systemActions.hasLocationPermission()
         backgroundGranted = systemActions.hasBackgroundLocationPermission()
@@ -69,13 +77,23 @@ fun FamilySection(systemActions: SystemActions) {
     }
 
     fun runProtected(action: String, block: () -> Unit) {
-        if (settings.hasPassword) { pendingAction = action; pwd = ""; pwdError = null } else block()
+        when {
+            // Appareil associé : un code du serveur (dicté par le parent) est exigé, pas le mot de passe local.
+            settings.isPaired -> { pendingCodeAction = action; codeError = null; codeBusy = false }
+            settings.hasPassword -> { pendingAction = action; pwd = ""; pwdError = null }
+            else -> block()
+        }
     }
 
     fun execute(action: String) {
         when (action) {
             "admin" -> { systemActions.deactivateAdmin(); adminActive = systemActions.isAdminActive() }
             "unpair" -> vm.unpair()
+            "owner" -> {
+                ownerError = !OwnerPolicy.release(context)
+                owner = OwnerPolicy.isDeviceOwner(context)
+                if (!owner) vm.reportOwnerRemoved()
+            }
         }
     }
 
@@ -87,70 +105,70 @@ fun FamilySection(systemActions: SystemActions) {
             )
             HorizontalDivider()
 
-            // --- Configuration Firebase (saisie ici, sans recompiler) ---
+            // --- Liaison avec le serveur familyd ---
-            Text(stringResource(R.string.family_firebase_title), fontWeight = FontWeight.Medium)
+            val link = settings.link
-            if (gw.enabled && !editFirebase) {
+            if (link != null) {
                 Text(
-                    stringResource(R.string.family_firebase_ok, gw.projectId ?: ""),
+                    stringResource(R.string.family_paired, link.serverUrl.removePrefix("https://"), link.tunnelIp),
                     color = StateOk, style = MaterialTheme.typography.bodyMedium
                 )
-                OutlinedButton(onClick = { editFirebase = true }) { Text(stringResource(R.string.family_firebase_edit)) }
-            } else {
                 Text(
-                    stringResource(R.string.family_firebase_help),
+                    "${stringResource(R.string.family_device_name)} : ${link.name}",
-                    style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant
+                    style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant
                 )
-                OutlinedTextField(
-                    value = firebaseText, onValueChange = { firebaseText = it; firebaseError = null },
-                    label = { Text(stringResource(R.string.family_firebase_field)) },
-                    minLines = 3, maxLines = 6, modifier = Modifier.fillMaxWidth()
-                )
-                firebaseError?.let {
-                    Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
-                }
-                Button(
-                    enabled = firebaseText.isNotBlank(),
-                    onClick = {
-                        firebaseError = vm.saveFirebaseConfig(firebaseText)
-                        if (firebaseError == null) { firebaseText = ""; editFirebase = false }
-                    }
-                ) { Text(stringResource(R.string.family_firebase_save)) }
-            }
-
-            HorizontalDivider()
-
-            // --- Appairage ---
-            when {
-                !gw.enabled -> Text(
-                    stringResource(R.string.family_unavailable),
-                    style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-                settings.isPaired -> {
-                    Text(stringResource(R.string.family_paired), color = StateOk, style = MaterialTheme.typography.bodyMedium)
                 OutlinedButton(onClick = { runProtected("unpair") { execute("unpair") } }) {
                     Text(stringResource(R.string.family_unpair))
                 }
-                }
+            } else {
-                else -> {
                 Text(stringResource(R.string.family_pair_help), style = MaterialTheme.typography.bodyMedium)
                 OutlinedTextField(
-                        value = code, onValueChange = { code = it.uppercase().take(8) },
+                    value = code, onValueChange = { code = it.take(300) },
-                        label = { Text(stringResource(R.string.family_code)) },
+                    label = { Text(stringResource(R.string.family_code_or_link)) },
                     singleLine = true, modifier = Modifier.fillMaxWidth()
                 )
                 OutlinedTextField(
-                        value = deviceName, onValueChange = { deviceName = it },
+                    value = deviceName, onValueChange = { deviceName = it.take(40) },
                     label = { Text(stringResource(R.string.family_device_name)) },
                     singleLine = true, modifier = Modifier.fillMaxWidth()
                 )
                 pairing.error?.let {
                     Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
                 }
+                if (pairing.busy) Text(stringResource(R.string.family_pairing), style = MaterialTheme.typography.bodySmall)
                 Button(
-                        enabled = code.length >= 6 && !pairing.busy,
+                    enabled = code.isNotBlank() && !pairing.busy,
                     onClick = { vm.pair(code, deviceName) }
                 ) { Text(stringResource(R.string.family_pair)) }
             }
+            pairing.done?.let {
+                Text(stringResource(R.string.family_paired_now), color = StateOk, style = MaterialTheme.typography.bodySmall)
+            }
+
+            HorizontalDivider()
+
+            // --- Mode propriétaire de l'appareil (Device Owner) ---
+            Text(stringResource(R.string.family_owner_title), fontWeight = FontWeight.Medium)
+            if (owner) {
+                Text(stringResource(R.string.family_owner_on), color = StateOk, style = MaterialTheme.typography.bodyMedium)
+                Text(
+                    stringResource(if (settings.controlEnabled && settings.isPaired) R.string.family_owner_rules_active
+                        else R.string.family_owner_rules_idle),
+                    style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+                OutlinedButton(onClick = { runProtected("owner") { execute("owner") } }) {
+                    Text(stringResource(R.string.family_owner_release))
+                }
+                if (ownerError) Text(stringResource(R.string.family_owner_release_error),
+                    color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+            } else {
+                Text(stringResource(R.string.family_owner_off), style = MaterialTheme.typography.bodyMedium)
+                androidx.compose.foundation.text.selection.SelectionContainer {
+                    Text(
+                        "adb shell dpm set-device-owner com.jttools.datacontrol/.admin.AppDeviceAdminReceiver",
+                        style = MaterialTheme.typography.bodySmall,
+                        fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace
+                    )
+                }
             }
 
             HorizontalDivider()
@@ -162,7 +180,9 @@ fun FamilySection(systemActions: SystemActions) {
                 style = MaterialTheme.typography.bodyMedium,
                 color = if (adminActive) StateOk else MaterialTheme.colorScheme.onSurfaceVariant
             )
-            if (adminActive) {
+            if (owner) {
+                // Le propriétaire de l'appareil ne peut pas être désinstallé : rien à retirer ici.
+            } else if (adminActive) {
                 OutlinedButton(onClick = { runProtected("admin") { execute("admin") } }) {
                     Text(stringResource(R.string.family_admin_disable))
                 }
@@ -220,6 +240,24 @@ fun FamilySection(systemActions: SystemActions) {
         }
     }
 
+    pendingCodeAction?.let { action ->
+        UnlockCodeDialog(
+            title = stringResource(R.string.unlock_code_title),
+            message = stringResource(R.string.unlock_code_message),
+            error = codeError,
+            busy = codeBusy,
+            onDismiss = { pendingCodeAction = null },
+            onConfirm = { code ->
+                codeBusy = true
+                scope.launch {
+                    val err = vm.verifyUnlock(code)
+                    codeBusy = false
+                    if (err == null) { pendingCodeAction = null; execute(action) } else codeError = err
+                }
+            }
+        )
+    }
+
     pendingAction?.let { action ->
         AlertDialog(
             onDismissRequest = { pendingAction = null },

app/src/main/java/com/jttools/datacontrol/ui/family/FamilyViewModel.kt

@@ -4,19 +4,19 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.jttools.datacontrol.data.AppSettings
 import com.jttools.datacontrol.data.SettingsRepository
-import com.jttools.datacontrol.remote.FirebaseConfig
+import com.jttools.datacontrol.remote.PairingInput
 import com.jttools.datacontrol.remote.RemoteSync
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.flow.map
 import javax.inject.Inject
 
-data class PairingUiState(val busy: Boolean = false, val error: String? = null)
+data class PairingUiState(val busy: Boolean = false, val error: String? = null, val done: String? = null)
 
 @HiltViewModel
 class FamilyViewModel @Inject constructor(
@@ -28,37 +28,42 @@ class FamilyViewModel @Inject constructor(
         viewModelScope, SharingStarted.WhileSubscribed(5_000), AppSettings()
     )
 
-    val gatewayState = remoteSync.gatewayState.stateIn(
-        viewModelScope, SharingStarted.WhileSubscribed(5_000), remoteSync.gatewayState.value
-    )
-
-    /** Enregistre la configuration Firebase collée ; renvoie un message d'erreur, ou null si elle est acceptée. */
-    fun saveFirebaseConfig(text: String): String? {
-        val cfg = FirebaseConfig.parse(text)
-            ?: return "Configuration non reconnue : il faut au minimum apiKey, appId et projectId (collez le bloc « firebaseConfig » complet, ou la chaîne « fc1:… » de FamilyControl)."
-        viewModelScope.launch { settingsRepository.setFirebaseConfig(cfg) }
-        return null
-    }
-
-    private val _pairing = MutableStateFlow(PairingUiState())
-    val pairing: StateFlow<PairingUiState> = _pairing.asStateFlow()
-
-    fun pair(code: String, deviceName: String) {
-        _pairing.value = PairingUiState(busy = true)
-        viewModelScope.launch {
-            val result = remoteSync.pair(code, deviceName)
-            _pairing.value = PairingUiState(error = result.exceptionOrNull()?.message)
-        }
-    }
-
-    fun unpair() {
-        viewModelScope.launch { remoteSync.unpair() }
-    }
-
     /** null tant que les réglages ne sont pas chargés, sinon vrai si un mot de passe est défini. */
     val passwordSet: StateFlow<Boolean?> = settingsRepository.settingsFlow.map<AppSettings, Boolean?> { it.hasPassword }
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
 
+    private val _pairing = MutableStateFlow(PairingUiState())
+    val pairing: StateFlow<PairingUiState> = _pairing.asStateFlow()
+
+    fun pair(input: String, deviceName: String) {
+        val parsed = PairingInput.parse(input)
+        if (parsed == null) {
+            _pairing.value = PairingUiState(error = "Code non reconnu : 8 caractères (lettres et chiffres), ou un lien familyd://…")
+            return
+        }
+        _pairing.value = PairingUiState(busy = true)
+        viewModelScope.launch {
+            val result = remoteSync.pair(parsed, deviceName)
+            _pairing.value = result.fold(
+                onSuccess = { PairingUiState(done = it.name) },
+                onFailure = { PairingUiState(error = it.message ?: "Association impossible.") }
+            )
+        }
+    }
+
+    fun unpair() {
+        viewModelScope.launch { remoteSync.forget() }
+    }
+
+    fun reportOwnerRemoved() {
+        viewModelScope.launch {
+            remoteSync.pushEvent("device_owner_removed", "Mode propriétaire de l'appareil retiré depuis DataControl")
+        }
+    }
+
     /** null si le mot de passe est bon, sinon le message d'erreur. */
     suspend fun checkPassword(password: String): String? = settingsRepository.checkPassword(password)
+
+    /** Vérifie le code du serveur (action "deactivate") dicté par le parent. null = accepté. */
+    suspend fun verifyUnlock(code: String): String? = remoteSync.verifyUnlock(code, "deactivate")
 }

app/src/main/java/com/jttools/datacontrol/ui/journal/JournalScreen.kt

@@ -32,7 +32,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.jttools.datacontrol.log.AppLog
-import com.jttools.datacontrol.service.FirewallVpnService
+import com.jttools.datacontrol.vpn.TunnelManager
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.jttools.datacontrol.ui.components.PasswordPromptDialog
@@ -42,17 +42,17 @@ import kotlinx.coroutines.launch
 @Composable
 fun JournalScreen() {
     val context = LocalContext.current
-    val entries by AppLog.entries.collectAsStateWithLifecycle(initialValue = emptyList())
     val viewModel: JournalViewModel = hiltViewModel()
+    val entries by AppLog.entries.collectAsStateWithLifecycle(initialValue = emptyList())
     val passwordSet by viewModel.passwordSet.collectAsStateWithLifecycle()
     var askPassword by remember { mutableStateOf(false) }
     var passwordError by remember { mutableStateOf<String?>(null) }
     val scope = rememberCoroutineScope()
 
     // État en direct du pare-feu, rafraîchi chaque seconde : première chose à regarder si le VPN n'apparaît pas.
-    var live by remember { mutableStateOf(liveStatus(context)) }
+    var live by remember { mutableStateOf(liveStatus(context, viewModel.tunnelUp())) }
     LaunchedEffect(Unit) {
-        while (true) { live = liveStatus(context); delay(1000) }
+        while (true) { live = liveStatus(context, viewModel.tunnelUp()); delay(1000) }
     }
 
     Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) {
@@ -110,10 +110,10 @@ private fun ClearPasswordDialog(
     onConfirm: (String) -> Unit
 ) = PasswordPromptDialog(title = "Effacer le journal", error = error, onDismiss = onDismiss, onConfirm = onConfirm)
 
-private fun liveStatus(context: Context): String = buildString {
+private fun liveStatus(context: Context, tunnelUp: Boolean): String = buildString {
-    appendLine("VPN autorisé (prepare) : ${FirewallVpnService.isPrepared(context)}")
+    appendLine("VPN autorisé (prepare) : ${TunnelManager.isPrepared(context)}")
-    appendLine("Tunnel VPN monté       : ${FirewallVpnService.tunnelActive}")
+    appendLine("Tunnel WireGuard       : ${if (tunnelUp) "monté" else "non monté"}")
     appendLine("Suivi des applis (accessibilité) : ${com.jttools.datacontrol.guard.AppGuardService.isEnabled(context)}")
     appendLine("Conservation du journal : ${AppLog.RETENTION_DAYS} jours")
-    append("Attendu : le tunnel n'est monté QUE sur données mobiles, contrôle activé.")
+    append("Attendu : tunnel monté en permanence (Wi-Fi et données mobiles) dès que le contrôle est activé.")
 }

app/src/main/java/com/jttools/datacontrol/ui/journal/JournalViewModel.kt

@@ -14,9 +14,12 @@ import javax.inject.Inject
 /** Effacer le journal fait disparaître la trace des usages : protégé par le mot de passe. */
 @HiltViewModel
 class JournalViewModel @Inject constructor(
-    private val settingsRepository: SettingsRepository
+    private val settingsRepository: SettingsRepository,
+    private val tunnel: com.jttools.datacontrol.vpn.TunnelManager
 ) : ViewModel() {
 
+    fun tunnelUp(): Boolean = tunnel.up.value
+
     val passwordSet: StateFlow<Boolean?> = settingsRepository.settingsFlow.map<AppSettings, Boolean?> { it.hasPassword }
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
 

app/src/main/java/com/jttools/datacontrol/ui/navigation/DataControlNavHost.kt

@@ -1,7 +1,6 @@
 package com.jttools.datacontrol.ui.navigation
 
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.List
 import androidx.compose.material.icons.filled.BugReport
 import androidx.compose.material.icons.filled.Dashboard
 import androidx.compose.material.icons.filled.Info
@@ -28,17 +27,15 @@ import com.jttools.datacontrol.ui.about.AboutScreen
 import com.jttools.datacontrol.ui.dashboard.DashboardScreen
 import com.jttools.datacontrol.ui.journal.JournalScreen
 import com.jttools.datacontrol.ui.settings.SettingsScreen
-import com.jttools.datacontrol.ui.whitelist.WhitelistScreen
 
 private sealed class Destination(val route: String, val labelRes: Int, val icon: androidx.compose.ui.graphics.vector.ImageVector) {
     data object Dashboard : Destination("dashboard", R.string.nav_dashboard, Icons.Filled.Dashboard)
     data object Settings : Destination("settings", R.string.nav_settings, Icons.Filled.Settings)
-    data object Whitelist : Destination("whitelist", R.string.nav_whitelist, Icons.AutoMirrored.Filled.List)
     data object Journal : Destination("journal", R.string.nav_journal, Icons.Filled.BugReport)
     data object About : Destination("about", R.string.nav_about, Icons.Filled.Info)
 }
 
-private val destinations = listOf(Destination.Dashboard, Destination.Settings, Destination.Whitelist, Destination.Journal, Destination.About)
+private val destinations = listOf(Destination.Dashboard, Destination.Settings, Destination.Journal, Destination.About)
 
 @Composable
 fun DataControlNavHost(systemActions: SystemActions) {
@@ -74,7 +71,6 @@ fun DataControlNavHost(systemActions: SystemActions) {
         ) {
             composable(Destination.Dashboard.route) { DashboardScreen(systemActions) }
             composable(Destination.Settings.route) { SettingsScreen(systemActions) }
-            composable(Destination.Whitelist.route) { WhitelistScreen() }
             composable(Destination.Journal.route) { JournalScreen() }
             composable(Destination.About.route) { AboutScreen() }
         }

app/src/main/java/com/jttools/datacontrol/ui/settings/SettingsScreen.kt

@@ -70,7 +70,6 @@ private fun SettingsContent(
     var planLimitText by remember(settings.planLimitMo) { mutableStateOf(settings.planLimitMo.toString()) }
     var planPriceText by remember(settings.planPriceEuro) { mutableStateOf(settings.planPriceEuro.toString()) }
     var overagePriceText by remember(settings.overagePricePerMoEuro) { mutableStateOf(settings.overagePricePerMoEuro.toString()) }
-    var cutoffText by remember(settings.cutoffIntervalMinutes) { mutableStateOf(settings.cutoffIntervalMinutes.toString()) }
     var autoReset by remember(settings.autoResetEnabled) { mutableStateOf(settings.autoResetEnabled) }
     var showDatePicker by remember { mutableStateOf(false) }
 
@@ -178,24 +177,6 @@ private fun SettingsContent(
             }
         }
 
-        Card(shape = RoundedCornerShape(20.dp), elevation = CardDefaults.cardElevation(2.dp)) {
-            Column(Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) {
-                Text(stringResource(R.string.settings_section_cutoff), style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)
-                OutlinedTextField(
-                    value = cutoffText,
-                    onValueChange = { cutoffText = it.filter(Char::isDigit) },
-                    label = { Text(stringResource(R.string.settings_cutoff_interval)) },
-                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                    modifier = Modifier.fillMaxWidth()
-                )
-                Text(
-                    stringResource(R.string.settings_cutoff_help),
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-        }
-
         Card(shape = RoundedCornerShape(20.dp), elevation = CardDefaults.cardElevation(2.dp)) {
             Column(Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
                 Text(stringResource(R.string.settings_section_permissions), style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)
@@ -293,7 +274,6 @@ private fun SettingsContent(
                     planLimitMo = planLimitText.toLongOrNull() ?: settings.planLimitMo,
                     planPriceEuro = planPriceText.toDoubleOrNull() ?: settings.planPriceEuro,
                     overagePricePerMoEuro = overagePriceText.toDoubleOrNull() ?: settings.overagePricePerMoEuro,
-                    cutoffIntervalMinutes = cutoffText.toIntOrNull()?.coerceAtLeast(1) ?: settings.cutoffIntervalMinutes,
                     autoResetEnabled = autoReset
                 )
             },

app/src/main/java/com/jttools/datacontrol/ui/settings/SettingsViewModel.kt

@@ -34,12 +34,11 @@ class SettingsViewModel @Inject constructor(
         planLimitMo: Long,
         planPriceEuro: Double,
         overagePricePerMoEuro: Double,
-        cutoffIntervalMinutes: Int,
         autoResetEnabled: Boolean
     ) {
         viewModelScope.launch {
             settingsRepository.updatePlan(
-                planLimitMo, planPriceEuro, overagePricePerMoEuro, cutoffIntervalMinutes, autoResetEnabled
+                planLimitMo, planPriceEuro, overagePricePerMoEuro, autoResetEnabled
             )
         }
     }

app/src/main/java/com/jttools/datacontrol/ui/whitelist/WhitelistScreen.kt

@@ -1,192 +0,0 @@
-package com.jttools.datacontrol.ui.whitelist
-
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Search
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedButton
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Tab
-import androidx.compose.material3.TabRow
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.asImageBitmap
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.core.graphics.drawable.toBitmap
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.jttools.datacontrol.R
-import com.jttools.datacontrol.data.AppInfo
-import com.jttools.datacontrol.ui.components.PasswordGate
-
-@Composable
-fun WhitelistScreen() {
-    val viewModel: WhitelistViewModel = hiltViewModel()
-    val settings by viewModel.settings.collectAsStateWithLifecycle()
-    val passwordSet by viewModel.passwordSet.collectAsStateWithLifecycle()
-
-    PasswordGate(passwordSet = passwordSet, verify = { viewModel.checkPassword(it) }) {
-        WhitelistContent(viewModel, settings)
-    }
-}
-
-@Composable
-private fun WhitelistContent(viewModel: WhitelistViewModel, settings: com.jttools.datacontrol.data.AppSettings) {
-    val apps by viewModel.apps.collectAsStateWithLifecycle()
-    val loading by viewModel.loading.collectAsStateWithLifecycle()
-    var query by remember { mutableStateOf("") }
-    var tabIndex by remember { mutableIntStateOf(0) }
-    val forWifi = tabIndex == 1
-
-    val filtered = apps
-        .filter { settings.showSystemApps || !it.isSystemApp }
-        .filter { it.label.contains(query, ignoreCase = true) || it.packageName.contains(query, ignoreCase = true) }
-
-    val activeSet = if (forWifi) settings.whitelistedPackagesWifi else settings.whitelistedPackages
-
-    Column(Modifier.fillMaxSize().padding(20.dp)) {
-        Text(stringResource(R.string.whitelist_title), style = MaterialTheme.typography.headlineMedium)
-        Text(
-            stringResource(R.string.whitelist_description),
-            style = MaterialTheme.typography.bodyMedium,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            modifier = Modifier.padding(top = 6.dp, bottom = 14.dp)
-        )
-
-        TabRow(selectedTabIndex = tabIndex) {
-            Tab(
-                selected = tabIndex == 0,
-                onClick = { tabIndex = 0 },
-                text = { Text(stringResource(R.string.whitelist_tab_mobile)) }
-            )
-            Tab(
-                selected = tabIndex == 1,
-                onClick = { tabIndex = 1 },
-                text = { Text(stringResource(R.string.whitelist_tab_wifi)) }
-            )
-        }
-
-        if (forWifi) {
-            Row(
-                Modifier.fillMaxWidth().padding(top = 10.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Column(Modifier.weight(1f)) {
-                    Text(stringResource(R.string.whitelist_wifi_filter_toggle), style = MaterialTheme.typography.bodyMedium)
-                    Text(
-                        stringResource(R.string.whitelist_wifi_filter_help),
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-                Switch(checked = settings.wifiFilterEnabled, onCheckedChange = { viewModel.setWifiFilterEnabled(it) })
-            }
-        }
-
-        OutlinedTextField(
-            value = query,
-            onValueChange = { query = it },
-            leadingIcon = { Icon(Icons.Filled.Search, contentDescription = null) },
-            label = { Text(stringResource(R.string.whitelist_search_hint)) },
-            singleLine = true,
-            modifier = Modifier.fillMaxWidth().padding(top = 10.dp)
-        )
-
-        Row(
-            Modifier.fillMaxWidth().padding(vertical = 10.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Text(stringResource(R.string.whitelist_system_apps_toggle), style = MaterialTheme.typography.bodyMedium)
-            Switch(checked = settings.showSystemApps, onCheckedChange = { viewModel.setShowSystemApps(it) })
-        }
-
-        Row(
-            Modifier.fillMaxWidth().padding(bottom = 10.dp),
-            horizontalArrangement = Arrangement.spacedBy(10.dp)
-        ) {
-            OutlinedButton(
-                onClick = { viewModel.setWhitelistedBulk(filtered.map { it.packageName }, whitelisted = true, forWifi = forWifi) },
-                modifier = Modifier.weight(1f)
-            ) { Text(stringResource(R.string.whitelist_select_all)) }
-            OutlinedButton(
-                onClick = { viewModel.setWhitelistedBulk(filtered.map { it.packageName }, whitelisted = false, forWifi = forWifi) },
-                modifier = Modifier.weight(1f)
-            ) { Text(stringResource(R.string.whitelist_select_none)) }
-        }
-        HorizontalDivider()
-
-        if (loading) {
-            Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
-        } else {
-            LazyColumn {
-                items(filtered, key = { it.packageName }) { app ->
-                    AppRow(
-                        app = app,
-                        checked = activeSet.contains(app.packageName),
-                        onCheckedChange = { viewModel.setWhitelisted(app.packageName, it, forWifi) }
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun AppRow(app: AppInfo, checked: Boolean, onCheckedChange: (Boolean) -> Unit) {
-    Row(
-        Modifier.fillMaxWidth().padding(vertical = 6.dp),
-        verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.spacedBy(14.dp)
-    ) {
-        AppIcon(app)
-        Column(Modifier.weight(1f)) {
-            Text(app.label, style = MaterialTheme.typography.bodyLarge, fontWeight = FontWeight.Medium)
-            Text(app.packageName, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
-        }
-        Checkbox(checked = checked, onCheckedChange = onCheckedChange)
-    }
-}
-
-@Composable
-private fun AppIcon(app: AppInfo) {
-    val bitmap = remember(app.packageName) {
-        app.icon?.let { runCatching { it.toBitmap(width = 96, height = 96).asImageBitmap() }.getOrNull() }
-    }
-    if (bitmap != null) {
-        Image(bitmap = bitmap, contentDescription = null, modifier = Modifier.size(40.dp))
-    } else {
-        Box(
-            modifier = Modifier
-                .size(40.dp)
-                .background(MaterialTheme.colorScheme.surfaceVariant, CircleShape)
-        )
-    }
-}

app/src/main/java/com/jttools/datacontrol/ui/whitelist/WhitelistViewModel.kt

@@ -1,73 +0,0 @@
-package com.jttools.datacontrol.ui.whitelist
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.jttools.datacontrol.data.AppInfo
-import com.jttools.datacontrol.data.AppSettings
-import com.jttools.datacontrol.data.InstalledAppsRepository
-import com.jttools.datacontrol.data.SettingsRepository
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import javax.inject.Inject
-
-@HiltViewModel
-class WhitelistViewModel @Inject constructor(
-    private val settingsRepository: SettingsRepository,
-    private val installedAppsRepository: InstalledAppsRepository
-) : ViewModel() {
-
-    val settings = settingsRepository.settingsFlow.stateIn(
-        viewModelScope, SharingStarted.WhileSubscribed(5_000), AppSettings()
-    )
-
-    private val _apps = MutableStateFlow<List<AppInfo>>(emptyList())
-    val apps = _apps.asStateFlow()
-
-    private val _loading = MutableStateFlow(true)
-    val loading = _loading.asStateFlow()
-
-    init {
-        viewModelScope.launch {
-            _apps.value = installedAppsRepository.listInstalledApps()
-            _loading.value = false
-        }
-    }
-
-    fun setWhitelisted(packageName: String, whitelisted: Boolean, forWifi: Boolean) {
-        viewModelScope.launch {
-            val current = if (forWifi) settings.value.whitelistedPackagesWifi else settings.value.whitelistedPackages
-            val updated = if (whitelisted) current + packageName else current - packageName
-            if (forWifi) settingsRepository.setWhitelistedPackagesWifi(updated) else settingsRepository.setWhitelistedPackages(updated)
-        }
-    }
-
-    /** Sélectionne ou désélectionne en bloc les paquets [packageNames] (ex : la liste actuellement filtrée à l'écran). */
-    fun setWhitelistedBulk(packageNames: List<String>, whitelisted: Boolean, forWifi: Boolean) {
-        viewModelScope.launch {
-            val current = if (forWifi) settings.value.whitelistedPackagesWifi else settings.value.whitelistedPackages
-            val updated = if (whitelisted) current + packageNames else current - packageNames.toSet()
-            if (forWifi) settingsRepository.setWhitelistedPackagesWifi(updated) else settingsRepository.setWhitelistedPackages(updated)
-        }
-    }
-
-    fun setWifiFilterEnabled(enabled: Boolean) {
-        viewModelScope.launch { settingsRepository.setWifiFilterEnabled(enabled) }
-    }
-
-    fun setShowSystemApps(show: Boolean) {
-        viewModelScope.launch { settingsRepository.setShowSystemApps(show) }
-    }
-
-    /** null tant que les réglages ne sont pas chargés, sinon vrai si un mot de passe est défini. */
-    val passwordSet: StateFlow<Boolean?> = settingsRepository.settingsFlow.map<AppSettings, Boolean?> { it.hasPassword }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
-
-    /** null si le mot de passe est bon, sinon le message d'erreur. */
-    suspend fun checkPassword(password: String): String? = settingsRepository.checkPassword(password)
-}

app/src/main/java/com/jttools/datacontrol/vpn/TunnelManager.kt

@@ -0,0 +1,106 @@
+package com.jttools.datacontrol.vpn
+
+import android.content.Context
+import android.net.VpnService
+import com.jttools.datacontrol.log.AppLog
+import com.jttools.datacontrol.remote.FamilyLink
+import com.wireguard.android.backend.BackendException
+import com.wireguard.android.backend.GoBackend
+import com.wireguard.android.backend.Tunnel
+import com.wireguard.config.Config
+import com.wireguard.crypto.KeyPair
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Tunnel WireGuard vers le serveur familyd, par la bibliothèque officielle (wireguard-go embarqué).
+ * Un seul VPN sur l'appareil : tout le trafic du téléphone passe par le serveur, qui le filtre.
+ */
+@Singleton
+class TunnelManager @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    private val backend by lazy { GoBackend(context) }
+    private val mutex = Mutex()
+    private var appliedConfig: String? = null
+
+    private val _up = MutableStateFlow(false)
+    /** Vrai tant que le tunnel est monté (faux après un retrait du VPN par l'utilisateur ou un autre VPN). */
+    val up: StateFlow<Boolean> = _up.asStateFlow()
+
+    @Volatile var lastError: String? = null
+        private set
+
+    private val tunnel = object : Tunnel {
+        override fun getName() = "familyd"
+        override fun onStateChange(newState: Tunnel.State) {
+            val isUp = newState == Tunnel.State.UP
+            if (!isUp && _up.value) AppLog.w("Tunnel", "Tunnel arrêté (VPN retiré ou autre VPN prioritaire)")
+            _up.value = isUp
+            if (!isUp) appliedConfig = null
+        }
+    }
+
+    /** Monte (ou reconfigure) le tunnel. Sans effet si la configuration n'a pas changé et que le tunnel tourne. */
+    suspend fun ensureUp(link: FamilyLink, privateKey: String): Boolean = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            val text = link.wgQuickConfig(privateKey)
+            if (text == appliedConfig && backend.getState(tunnel) == Tunnel.State.UP) return@withLock true
+            try {
+                val config = Config.parse(text.byteInputStream())
+                backend.setState(tunnel, Tunnel.State.UP, config)
+                appliedConfig = text
+                lastError = null
+                _up.value = true
+                AppLog.i("Tunnel", "Tunnel monté vers ${link.endpoint} (adresse ${link.tunnelIp})")
+                true
+            } catch (e: BackendException) {
+                lastError = describe(e.reason)
+                AppLog.e("Tunnel", "Tunnel non monté : $lastError")
+                false
+            } catch (e: Exception) {
+                lastError = e.message ?: e.javaClass.simpleName
+                AppLog.e("Tunnel", "Tunnel non monté", e)
+                false
+            }
+        }
+    }
+
+    suspend fun down() = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            runCatching { backend.setState(tunnel, Tunnel.State.DOWN, null) }
+                .onFailure { AppLog.w("Tunnel", "Arrêt du tunnel : ${it.message}") }
+            appliedConfig = null
+            _up.value = false
+        }
+    }
+
+    /** Dernière poignée de main avec le serveur (ms), ou null si aucune. */
+    fun lastHandshakeMillis(): Long? = runCatching {
+        val stats = backend.getStatistics(tunnel)
+        stats.peers().firstOrNull()?.let { stats.peer(it)?.latestHandshakeEpochMillis() }?.takeIf { it > 0 }
+    }.getOrNull()
+
+    private fun describe(reason: BackendException.Reason): String = when (reason) {
+        BackendException.Reason.VPN_NOT_AUTHORIZED -> "autorisation VPN absente (à redonner dans DataControl)"
+        BackendException.Reason.DNS_RESOLUTION_FAILURE -> "adresse du serveur introuvable (DNS)"
+        BackendException.Reason.UNABLE_TO_START_VPN -> "Android refuse de démarrer le VPN"
+        BackendException.Reason.TUN_CREATION_ERROR -> "création de l'interface VPN impossible"
+        else -> reason.name
+    }
+
+    companion object {
+        fun isPrepared(context: Context): Boolean = VpnService.prepare(context) == null
+
+        /** Nouvelle paire de clés WireGuard : (clé privée, clé publique) en base64. */
+        fun newKeyPair(): Pair<String, String> = KeyPair().let { it.privateKey.toBase64() to it.publicKey.toBase64() }
+    }
+}

app/src/main/res/values/strings.xml

@@ -5,7 +5,6 @@
     <!-- Navigation -->
     <string name="nav_dashboard">Tableau de bord</string>
     <string name="nav_settings">Réglages</string>
-    <string name="nav_whitelist">Liste blanche</string>
     <string name="nav_journal">Journal</string>
     <string name="nav_about">À propos</string>
 
@@ -16,8 +15,7 @@
     <string name="dashboard_overage">Dépassement</string>
     <string name="dashboard_state_ok">Sous le forfait</string>
     <string name="dashboard_state_warning">Proche du forfait</string>
-    <string name="dashboard_state_cut">Coupure totale en cours</string>
+    <string name="dashboard_state_wifi">Wi-Fi actif</string>
-    <string name="dashboard_state_wifi">Wi-Fi actif — aucun filtrage</string>
     <string name="dashboard_cost_title">Estimation du coût</string>
     <string name="dashboard_cost_plan">Prix du forfait</string>
     <string name="dashboard_cost_overage">Coût hors-forfait</string>
@@ -29,11 +27,6 @@
     <string name="dashboard_reset_confirm_title">Réinitialiser le forfait ?</string>
     <string name="dashboard_reset_confirm_message">Le compteur de données consommées sera remis à zéro immédiatement.</string>
     <string name="dashboard_control_disabled">Contrôle désactivé</string>
-    <string name="dashboard_next_cutoff">Prochaine coupure</string>
-    <string name="dashboard_cutoff_wifi">Wi-Fi actif (pas de coupure)</string>
-    <string name="dashboard_cutoff_in_progress">En cours…</string>
-    <string name="dashboard_cutoff_countdown">dans %1$d min %2$d s</string>
-    <string name="dashboard_cutoff_unavailable">indisponible (pare-feu inactif)</string>
 
     <!-- Settings -->
     <string name="settings_title">Réglages</string>
@@ -45,9 +38,6 @@
     <string name="settings_overage_price">Prix par Mo hors-forfait (€)</string>
     <string name="settings_start_date">Date de début du forfait</string>
     <string name="settings_auto_reset">Réinitialisation automatique mensuelle</string>
-    <string name="settings_section_cutoff">Coupure automatique</string>
-    <string name="settings_cutoff_interval">Intervalle de coupure (minutes)</string>
-    <string name="settings_cutoff_help">Une coupure totale (même pour la liste blanche) se déclenche cycliquement à cet intervalle, que le forfait soit dépassé ou non.</string>
     <string name="settings_section_permissions">Autorisations</string>
     <string name="settings_perm_vpn">Pare-feu local (VPN)</string>
     <string name="settings_perm_vpn_desc">Nécessaire pour filtrer les applications sur les données mobiles</string>
@@ -76,6 +66,17 @@
     <string name="password_field_label">Mot de passe</string>
     <string name="password_unlock">Déverrouiller</string>
 
+    <!-- Verrouillage parental (écran plein écran levé par un code du serveur) -->
+    <string name="parental_lock_title">Téléphone verrouillé</string>
+    <string name="parental_lock_message">Ce téléphone a été verrouillé à distance par le parent. Demandez-lui le code de déverrouillage.</string>
+    <string name="parental_lock_code_label">Code de déverrouillage</string>
+    <string name="parental_lock_unlock">Déverrouiller</string>
+
+    <!-- Code du serveur exigé pour désactiver le contrôle (remplace le mot de passe local) -->
+    <string name="unlock_code_title">Code de désactivation</string>
+    <string name="unlock_code_message">Pour désactiver le contrôle, demandez au parent de générer un code de désactivation depuis l\'espace parents, puis saisissez-le ici.</string>
+    <string name="unlock_code_field">Code du parent</string>
+
     <!-- About -->
     <string name="about_version">Version %1$s</string>
     <string name="update_section">Mise à jour</string>
@@ -91,31 +92,20 @@
     <string name="about_author_value">JT-Tools — Johnny</string>
 
     <!-- Whitelist -->
-    <string name="whitelist_title">Liste blanche</string>
-    <string name="whitelist_description">Ces applications gardent toujours accès aux données mobiles, y compris en dépassement de forfait (sauf pendant les coupures cycliques totales).</string>
-    <string name="whitelist_search_hint">Rechercher une application</string>
-    <string name="whitelist_system_apps_toggle">Afficher les applications système</string>
-    <string name="whitelist_tab_mobile">Données mobiles</string>
-    <string name="whitelist_tab_wifi">Wi-Fi</string>
-    <string name="whitelist_wifi_filter_toggle">Filtrer aussi le Wi-Fi</string>
-    <string name="whitelist_wifi_filter_help">Par défaut, le Wi-Fi n\'est jamais filtré. Activez pour restreindre l\'accès Wi-Fi aux applications cochées ci-dessous.</string>
-    <string name="whitelist_select_all">Tout sélectionner</string>
-    <string name="whitelist_select_none">Tout désélectionner</string>
 
     <!-- Notification -->
     <string name="notification_channel_name">Surveillance des données</string>
-    <string name="notification_channel_description">Affiche la consommation de données et l\'état de la coupure</string>
+    <string name="notification_channel_description">Affiche la consommation de données et l\'état de la protection</string>
     <string name="notification_title">DataControl</string>
 
     <!-- Common -->
     <string name="common_cancel">Annuler</string>
     <string name="common_confirm">Confirmer</string>
 
-    <string name="family_title">Contrôle parental (FamilyControl)</string>
+    <string name="family_title">Contrôle parental</string>
-    <string name="family_unavailable">Renseignez d\'abord la configuration Firebase ci-dessus pour pouvoir associer l\'appareil.</string>
+    <string name="family_paired">Téléphone associé au serveur %1$s (adresse %2$s dans le tunnel). Le parent gère l\'accès à Internet et voit la batterie, la position et le temps d\'écran.</string>
-    <string name="family_paired">Appareil associé à FamilyControl : le parent peut gérer les accès réseau, voir la batterie, la position et l\'historique de trafic.</string>
+    <string name="family_unpair">Oublier cette liaison</string>
-    <string name="family_unpair">Dissocier cet appareil</string>
+    <string name="family_pair_help">Dans l\'espace parents (family.tuxtech.fr), touchez « Associer un téléphone », puis saisissez ici le code affiché (ou collez le lien familyd://…).</string>
-    <string name="family_pair_help">Saisissez le code d\'appairage affiché dans FamilyControl pour associer cet appareil.</string>
     <string name="family_code">Code d\'appairage</string>
     <string name="family_device_name">Nom de l\'appareil</string>
     <string name="family_pair">Associer</string>
@@ -126,7 +116,7 @@
     <string name="family_admin_disable">Désactiver la protection</string>
     <string name="family_admin_needs_password">Définissez un mot de passe (section Sécurité) : sans lui, la protection peut être retirée librement.</string>
     <string name="family_location_title">Position de l\'appareil</string>
-    <string name="family_location_desc">Partagée avec le parent via FamilyControl, y compris en arrière-plan (choisir « Toujours autoriser »).</string>
+    <string name="family_location_desc">Partagée avec le parent, y compris en arrière-plan (choisir « Toujours autoriser »).</string>
     <string name="family_location_grant">Autoriser la position</string>
     <string name="family_location_background">Autoriser en arrière-plan</string>
     <string name="guard_service_label">DataControl — limitation des applications</string>
@@ -135,10 +125,27 @@
     <string name="family_guard_desc">Plages horaires, temps d\'écran et blocage d\'applications décidés par le parent. Nécessite le service d\'accessibilité « DataControl ».</string>
     <string name="family_guard_hint">Android 13+ : si l\'activation est grisée, ouvrez Infos sur l\'application → ⋮ → « Autoriser les paramètres restreints », puis réessayez.</string>
     <string name="family_guard_enable">Activer le service</string>
-    <string name="family_firebase_title">Configuration Firebase</string>
+    <!-- v0.2 : tunnel WireGuard et serveur familyd -->
-    <string name="family_firebase_ok">Configurée — projet %1$s</string>
+    <string name="mode_open">Accès libre</string>
-    <string name="family_firebase_edit">Modifier la configuration</string>
+    <string name="mode_blocklist">Liste noire (certains services bloqués)</string>
-    <string name="family_firebase_help">Collez ici la chaîne « fc1:… » partagée par FamilyControl (bouton « Partager pour DataControl »), ou le bloc « firebaseConfig » de la console Firebase.</string>
+    <string name="mode_allowlist">Liste blanche seulement</string>
-    <string name="family_firebase_field">Configuration Firebase</string>
+    <string name="mode_cut">Internet coupé</string>
-    <string name="family_firebase_save">Enregistrer</string>
+    <string name="dashboard_tunnel">Tunnel</string>
+    <string name="dashboard_tunnel_up">connecté au serveur</string>
+    <string name="dashboard_tunnel_down">PROTECTION INACTIVE — tunnel coupé</string>
+    <string name="dashboard_server_mode">Accès décidé par le parent</string>
+    <string name="dashboard_not_paired">téléphone non associé (Réglages → Contrôle parental)</string>
+    <string name="dashboard_pair_first">Associez d\'abord le téléphone (Réglages → Contrôle parental).</string>
+    <string name="family_code_or_link">Code d\'appairage ou lien familyd://</string>
+    <string name="family_code_invalid">Code non reconnu : 8 caractères (lettres et chiffres), ou un lien familyd://…</string>
+    <string name="family_pairing">Association en cours…</string>
+    <string name="family_paired_now">Téléphone associé. Activez la protection sur le tableau de bord.</string>
+    <string name="family_owner_title">Mode propriétaire de l\'appareil</string>
+    <string name="family_owner_on">Actif : DataControl verrouille le VPN, la date et l\'heure, la réinitialisation et sa propre désinstallation.</string>
+    <string name="family_owner_rules_active">Protection en cours : VPN toujours actif, connexions bloquées hors VPN (levées automatiquement si le serveur ne répond plus pendant 15 min).</string>
+    <string name="family_owner_rules_idle">En attente : les verrous s\'appliquent dès que le téléphone est associé et la protection activée.</string>
+    <string name="family_owner_release">Retirer le mode propriétaire</string>
+    <string name="family_owner_release_error">Retrait impossible : voir le journal.</string>
+    <string name="family_owner_off">Inactif. Pour l\'activer (une seule fois, téléphone branché au PC, tous les comptes retirés le temps de la commande) :</string>
+    <string name="screen_shared_banner">🔴 Écran partagé avec le parent</string>
 </resources>

app/src/main/res/xml/accessibility_guard.xml

@@ -4,4 +4,5 @@
     android:accessibilityFeedbackType="feedbackGeneric"
     android:canRetrieveWindowContent="false"
     android:description="@string/guard_service_description"
-    android:notificationTimeout="100" />
+    android:notificationTimeout="100"
+    android:canTakeScreenshot="true" />

app/src/main/res/xml/device_admin.xml

@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <device-admin>
-    <uses-policies />
+    <uses-policies>
+        <force-lock />
+    </uses-policies>
 </device-admin>

app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- HTTPS partout. Seule exception : l'API familyd dans le tunnel WireGuard (déjà chiffré de bout en bout). -->
+<network-security-config>
+    <base-config cleartextTrafficPermitted="false" />
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="false">10.78.0.1</domain>
+    </domain-config>
+</network-security-config>

app/src/test/java/com/jttools/datacontrol/remote/FamilyLinkTest.kt

@@ -0,0 +1,56 @@
+package com.jttools.datacontrol.remote
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class FamilyLinkTest {
+
+    private val pairResponse = """
+        {"device_id":"5b1f","token":"fd_secret","name":"Tél. Lilou","ready":true,
+         "wireguard":{"address":"10.78.0.11/32","dns":"10.78.0.1","mtu":1280,
+                      "server_public_key":"JavjzwIltCzZB49zUDJCVrbUu9SGbxHH6gcfPB3Y81k=",
+                      "endpoint":"fam-vpn.tuxtech.fr:51721","allowed_ips":["0.0.0.0/0","::/0"],
+                      "persistent_keepalive":25},
+         "api":"http://10.78.0.1:8100/"}
+    """.trimIndent()
+
+    @Test fun `code seul, avec espaces ou tirets`() {
+        assertEquals(PairingInput("https://family.tuxtech.fr", "ABCD2345"), PairingInput.parse("abcd 2345"))
+        assertEquals("ABCD2345", PairingInput.parse("ABCD-2345")?.code)
+        assertNull(PairingInput.parse("ABC"))
+        assertNull(PairingInput.parse("ABCD234O"))          // O et 0 exclus de l'alphabet
+    }
+
+    @Test fun `lien familyd`() {
+        val p = PairingInput.parse("familyd://pair?url=https%3A%2F%2Fautre.exemple.fr%2F&code=WXYZ2345")
+        assertEquals(PairingInput("https://autre.exemple.fr", "WXYZ2345"), p)
+        assertEquals("https://family.tuxtech.fr", PairingInput.parse("familyd://pair?url=https://family.tuxtech.fr&code=WXYZ2345")?.serverUrl)
+        assertNull(PairingInput.parse("familyd://pair?url=http://non.chiffre.fr&code=WXYZ2345"))   // HTTPS obligatoire
+        assertNull(PairingInput.parse("familyd://pair?code=WXYZ2345"))
+    }
+
+    @Test fun `reponse d appairage`() {
+        val (link, token) = FamilyLink.fromPairResponse("https://family.tuxtech.fr", pairResponse)
+        assertEquals("fd_secret", token)
+        assertEquals("10.78.0.11", link.tunnelIp)
+        assertEquals("http://10.78.0.1:8100", link.apiBase)
+        assertEquals(listOf("0.0.0.0/0", "::/0"), link.allowedIps)
+    }
+
+    @Test fun `configuration wg-quick`() {
+        val (link, _) = FamilyLink.fromPairResponse("https://family.tuxtech.fr", pairResponse)
+        val conf = link.wgQuickConfig("PRIVEE=")
+        assertTrue(conf.startsWith("[Interface]\nPrivateKey = PRIVEE=\nAddress = 10.78.0.11/32\nDNS = 10.78.0.1\nMTU = 1280"))
+        assertTrue("AllowedIPs = 0.0.0.0/0, ::/0" in conf && "Endpoint = fam-vpn.tuxtech.fr:51721" in conf)
+        assertTrue("PersistentKeepalive = 25" in conf)
+    }
+
+    @Test fun `sauvegarde et relecture`() {
+        val (link, _) = FamilyLink.fromPairResponse("https://family.tuxtech.fr", pairResponse)
+        assertEquals(link, FamilyLink.fromJson(link.toJson()))
+        assertNull(FamilyLink.fromJson("{pas du json"))
+        assertNull(FamilyLink.fromJson(null))
+    }
+}

app/src/test/java/com/jttools/datacontrol/remote/FirebaseConfigTest.kt

@@ -1,43 +0,0 @@
-package com.jttools.datacontrol.remote
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-import java.util.Base64
-
-class FirebaseConfigTest {
-    private val expected = FirebaseConfig("AIzaTest", "1:123:android:abc", "mon-projet")
-
-    @Test fun `bloc firebaseConfig de la console`() {
-        val js = """
-            const firebaseConfig = {
-              apiKey: "AIzaTest",
-              authDomain: "mon-projet.firebaseapp.com",
-              projectId: "mon-projet",
-              appId: "1:123:android:abc"
-            };
-        """.trimIndent()
-        assertEquals(expected, FirebaseConfig.parse(js))
-    }
-
-    @Test fun `json`() {
-        assertEquals(
-            expected,
-            FirebaseConfig.parse("""{"apiKey":"AIzaTest","appId":"1:123:android:abc","projectId":"mon-projet"}""")
-        )
-    }
-
-    @Test fun `chaine fc1 de FamilyControl`() {
-        val b64 = Base64.getEncoder().encodeToString(
-            """{"apiKey":"AIzaTest","appId":"1:123:android:abc","projectId":"mon-projet"}""".toByteArray()
-        )
-        assertEquals(expected, FirebaseConfig.parse("fc1:$b64"))
-        assertEquals(expected, FirebaseConfig.parse("  fc1:${b64.chunked(20).joinToString("\n")}  "))
-    }
-
-    @Test fun `champ manquant ou illisible`() {
-        assertNull(FirebaseConfig.parse("""{"apiKey":"AIzaTest","projectId":"mon-projet"}"""))
-        assertNull(FirebaseConfig.parse("fc1:!!!"))
-        assertNull(FirebaseConfig.parse(""))
-    }
-}

docs/PLAN-wireguard.md

@@ -0,0 +1,425 @@
+# Plan : contrôle parental par WireGuard et serveur auto-hébergé
+
+> Statut : **proposition**, rien n'est réalisé. Rédigé le 2026-10-25.
+> Concerne DataControl (téléphone de l'enfant), FamilyControl (téléphone du parent) et un nouveau
+> service serveur, `familyd`, hébergé sur le CT 233 de pve-home (192.168.77.233).
+
+## 1. Objectif
+
+Remplacer le fonctionnement actuel (pare-feu VPN local « trou noir » + Firebase) par :
+
+- **un tunnel WireGuard permanent** entre le téléphone de l'enfant et le serveur : tout le trafic
+  du téléphone (Wi-Fi comme 4G/5G) passe par le serveur ;
+- **un filtrage côté serveur** : coupures, plages horaires, quota, sites et services interdits ;
+- **un canal de contrôle** par ce même tunnel : consignes du parent, état de l'appareil, alertes ;
+- **plus aucune dépendance à Firebase / Google**.
+
+Ce qui reste sur le téléphone : ce que seul le téléphone peut savoir (application au premier plan,
+temps d'écran, batterie, position, type de réseau) et le blocage du lancement des applications.
+
+## 2. Principe et contrainte fondatrice
+
+WireGuard transporte des **paquets IP** : le serveur voit des adresses, des ports et (via le DNS)
+des noms de domaine, **jamais l'application qui a émis le paquet**. D'où la répartition :
+
+| Besoin | Où | Comment |
+|---|---|---|
+| Couper Internet (horaire, punition, coupure cyclique) | Serveur | Règle nftables de l'appareil → « coupé » |
+| Bloquer un service (TikTok, YouTube…) ou une catégorie | Serveur | DNS filtrant par appareil |
+| « Seul Pronote passe » (liste blanche) | Serveur | DNS limité aux domaines autorisés + jeu d'IP rempli par les réponses DNS |
+| Quota de données | Serveur | Compteur d'octets du pair WireGuard (fiable, non falsifiable) |
+| Interdire / limiter le temps d'une application | Téléphone | Service d'accessibilité existant (blocage au lancement) |
+| Temps d'écran, batterie, position, type de réseau | Téléphone | Remontés à l'API par le tunnel |
+| Empêcher de couper le VPN, de changer l'heure, de désinstaller | Téléphone | Mode Device Owner (§8) |
+
+Le filtrage réseau **par application** n'est pas repris en phase 1 : une application interdite est
+bloquée à son lancement, ce qui couvre l'usage réel. Il reste possible en phase 5 (§11).
+
+## 3. Architecture
+
+```
+Téléphone enfant (DataControl)                    CT 233 srv-home-zoompilot (192.168.77.233)
+┌──────────────────────────────┐                 ┌──────────────────────────────────────────────┐
+│ VPN = client WireGuard       │  UDP 51721      │ wg1 10.78.0.1/24   (wg0 ZoomPilot inchangé)  │
+│  AllowedIPs 0.0.0.0/0, ::/0  ├────────────────►│  ├ nftables table inet familyd               │
+│  DNS 10.78.0.1, MTU 1280     │  Freebox        │  │   modes par appareil, NAT sortant,        │
+│ Service d'accessibilité      │  82.67.111.224  │  │   DNS forcé, DoT/DoH bloqués               │
+│ Client API (+ WebSocket)     │                 │  ├ DNS filtrant (AdGuard Home) 10.78.0.1:53  │
+└──────────────────────────────┘                 │  ├ familyd (FastAPI + SQLite)                │
+                                                 │  │   10.78.0.1:8100 (appareils, via wg1)     │
+FamilyControl (parent)                           │  │   192.168.77.233:8100 (Traefik, parents)  │
+┌──────────────────────────────┐   HTTPS         │  ├ compteurs `wg show wg1 transfer`          │
+│ API REST + WebSocket         ├──► Traefik CT 201 ─►└ ntfy :8090 (existant) pour les alertes     │
+│ Alertes : appli ntfy         │  family.tuxtech.fr                                              │
+└──────────────────────────────┘                 └──────────────────────────────────────────────┘
+```
+
+### Cohabitation avec ZoomPilot sur le CT 233
+
+Tout est séparé pour qu'un changement d'un côté ne touche pas l'autre :
+
+| | ZoomPilot (existant) | Contrôle parental (nouveau) |
+|---|---|---|
+| Interface WireGuard | `wg0` 10.77.0.1/24, UDP 51720 | `wg1` 10.78.0.1/24, UDP **51721** |
+| Pare-feu | `table inet filter`, `table ip zp_nat` | `table inet familyd` (dédiée) |
+| Service | `zoompilot` :8000 | `familyd` :8100, `adguardhome` :53 + :3000 (admin, local) |
+| Utilisateur système | `zoompilot` | `familyd` |
+| Données | /var/lib/zoompilot | /var/lib/familyd |
+
+Plages et ports vérifiés libres le 2026-10-25 : 10.6.0.0/24, 10.8.0.0/23 et 10.77.0.0/24 sont pris ;
+UDP 51720, 51820, 51900 pris.
+
+**Risque assumé** : le CT devient critique pour l'accès Internet de l'enfant (voir §9). Un CT dédié
+(ex. 234) isolerait mieux ; le plan reste valable tel quel en changeant l'IP.
+
+## 4. Serveur
+
+### 4.1 Ressources du CT 233
+
+Actuel : 1 cœur, 512 Mo, disque 3,9 Go (2,4 Go libres). À porter à **2 cœurs, 1,5 Go de RAM,
+disque +8 Go** (journaux DNS, historique SQLite). Sur pve-home, lire `/etc/pve` plutôt que
+`pct list` (stockage lent) ; le CT est sur `local-lvm`.
+
+```bash
+# sur pve-home
+pct set 233 --cores 2 --memory 1536
+pct resize 233 rootfs +8G
+```
+
+### 4.2 Réseau
+
+- **Freebox** : rediriger **UDP 51721** → 192.168.77.233.
+- **Nom** : `fam-vpn.tuxtech.fr` → 82.67.111.224 (point de terminaison WireGuard ; un nom plutôt
+  qu'une IP, pour survivre à un changement d'adresse).
+- **Traefik (CT 201)** : `family.tuxtech.fr` → 192.168.77.233:8100, certificat Let's Encrypt,
+  **uniquement** les routes parent et appairage (`/api/parent/*`, `/api/pair`). Les routes
+  appareil ne sont servies que sur 10.78.0.1.
+- **Retour en boucle (hairpin)** : quand le téléphone est sur le Wi-Fi de la maison, il joint
+  82.67.111.224 depuis le réseau local. À vérifier sur la Freebox en phase 0 ; sinon, résolution
+  DNS locale de `fam-vpn.tuxtech.fr` vers 192.168.77.233.
+- **IPv6** : le tunnel annonce `::/0` pour qu'aucun trafic IPv6 ne contourne le serveur ; le
+  serveur ne route pas l'IPv6 (les applications retombent sur IPv4). NAT66 éventuel plus tard.
+
+### 4.3 WireGuard `wg1`
+
+```ini
+# /etc/wireguard/wg1.conf
+[Interface]
+Address = 10.78.0.1/24
+ListenPort = 51721
+PrivateKey = <clé serveur, chmod 600>
+# Les pairs sont ajoutés par familyd (wg set + wg-quick save) — pas d'édition à la main.
+```
+
+Pair type (écrit par familyd à l'appairage) :
+
+```ini
+[Peer]
+# device=<uuid> family=<id>
+PublicKey = <clé publique générée sur le téléphone>
+AllowedIPs = 10.78.0.10/32
+```
+
+Côté téléphone : `PersistentKeepalive = 25` (indispensable derrière le NAT des opérateurs), MTU 1280.
+
+### 4.4 Pare-feu nftables (`table inet familyd`)
+
+Chaque appareil a un **mode** appliqué par familyd, via une map plutôt qu'une réécriture des
+règles :
+
+| Mode | Effet |
+|---|---|
+| `open` | Tout passe (filtrage DNS seul) |
+| `allowlist` | Seules les IP du jeu `allow4` (remplies par les réponses DNS des domaines autorisés) passent |
+| `cut` | Rien ne sort, sauf le serveur lui-même (API + DNS sur 10.78.0.1) |
+
+```nft
+table inet familyd {
+  map mode4 { type ipv4_addr : verdict; }            # 10.78.0.10 : jump m_open …
+  set allow4 { type ipv4_addr; flags timeout; timeout 1h; }   # rempli par dnsmasq (nftset)
+  set doh4   { type ipv4_addr; flags interval; }     # résolveurs DoH connus
+
+  chain prerouting {
+    type nat hook prerouting priority dstnat;
+    iifname "wg1" udp dport 53 dnat ip to 10.78.0.1   # DNS forcé
+    iifname "wg1" tcp dport 53 dnat ip to 10.78.0.1
+  }
+  chain postrouting {
+    type nat hook postrouting priority srcnat;
+    iifname "wg1" oifname "eth0" masquerade
+  }
+  chain forward {
+    type filter hook forward priority 0; policy accept;
+    iifname != "wg1" return
+    tcp dport 853 drop                                 # DNS sur TLS
+    udp dport 853 drop
+    ip daddr @doh4 tcp dport 443 drop                  # DNS sur HTTPS vers IP connues
+    ip saddr vmap @mode4
+    drop                                               # appareil inconnu
+  }
+  chain m_open      { accept }
+  chain m_allowlist { ip daddr @allow4 accept; drop; }
+  chain m_cut       { drop }
+  chain input {
+    type filter hook input priority 0; policy accept;
+    iifname "wg1" ip daddr 10.78.0.1 tcp dport { 53, 8100 } accept
+    iifname "wg1" ip daddr 10.78.0.1 udp dport 53 accept
+    iifname "wg1" drop                                 # rien d'autre du CT (ZoomPilot, SSH…)
+  }
+}
+```
+
+Points à respecter :
+- règles **idempotentes**, rechargées au démarrage de familyd depuis la base (source de vérité :
+  SQLite, pas nftables) ;
+- **isolation entre pairs** : un appareil ne joint ni les autres pairs de `wg1`, ni `wg0`, ni le
+  réseau 192.168.77.0/24 (règles `ip daddr { 10.77.0.0/24, 10.78.0.0/24, 192.168.77.0/24 } drop`
+  dans `forward`, sauf 10.78.0.1) ;
+- après un changement de mode, purger les connexions en cours de l'appareil
+  (`conntrack -D -s 10.78.0.x`), sinon une connexion ouverte survit à la coupure.
+
+### 4.5 DNS filtrant
+
+**Choix : AdGuard Home** (binaire unique, API REST, réglages par client) :
+- un **client par appareil** (identifié par son IP 10.78.0.x) avec ses **services bloqués**
+  (liste intégrée : TikTok, YouTube, Snapchat…), contrôle parental, recherche sécurisée ;
+- règles par appareil avec le modificateur `$client` (mode liste blanche :
+  `/.*/$client='10.78.0.10'` + `@@||index-education.net^$client='10.78.0.10'`) ;
+- blocage des domaines DoH connus (`dns.google`, `cloudflare-dns.com`…) et du domaine canari
+  `use-application-dns.net` (désactive le DoH de Firefox) ;
+- journal des requêtes conservé **7 jours** (consultable par le parent, à mentionner à l'enfant) ;
+- interface d'administration sur 127.0.0.1:3003 uniquement, pilotée par familyd ; les règles de
+  blocage DoH portent `$important` (sinon les exceptions du filtre AdGuard par défaut l'emportent).
+
+**Liste blanche (validé en phase 0)** : la fonction `ipset` d'AdGuard Home ne remplit que les
+anciens jeux « ipset », illisibles par nftables. On utilise donc une petite instance **dnsmasq**
+(`familyd-dnsmasq`, 127.0.0.1:5353, option `nftset=`) à laquelle AdGuard Home transmet les seuls
+domaines de la liste blanche ; chaque adresse obtenue entre dans le jeu `allow4` (expiration 1 h,
+renouvelée à chaque requête ; AdGuard Home plafonne son cache à 300 s pour que le renouvellement
+ait lieu). Conséquence : `allow4` est **commun à tous les appareils** (union des listes blanches) ;
+la liste propre à chaque appareil s'applique au niveau DNS (règles `$client`).
+
+### 4.6 Service `familyd` (FastAPI + SQLite)
+
+Même pile que ZoomPilot (déjà maîtrisée et déployée sur ce CT) : `/opt/familyd`, venv,
+`/etc/familyd/familyd.env` (600), données `/var/lib/familyd`, unité systemd, utilisateur
+`familyd`. Les opérations privilégiées (`wg set`, `nft`, `conntrack`) passent par un petit
+assistant root appelé via `sudo` avec une liste de commandes fermée (pas de shell libre).
+
+**Tâches de fond**
+- toutes les 60 s : relevé `wg show wg1 transfer` + `latest-handshakes` → octets par appareil
+  (deltas stockés), « appareil en ligne » (dernière poignée de main < 3 min) ;
+- moteur de règles : à chaque minute et à chaque changement, calcule le mode de chaque appareil
+  (consigne du parent, plage horaire, coupure cyclique sur données mobiles, quota) et l'applique
+  (nft + AdGuard) ;
+- alertes vers **ntfy** (déjà sur le CT) : appareil hors ligne > 15 min, VPN coupé, protection
+  retirée, heure modifiée, quota atteint.
+
+**Schéma SQLite (esquisse)**
+
+| Table | Contenu |
+|---|---|
+| `parents` | id, e-mail, hachage argon2, créé le |
+| `families` / `family_parents` | famille, parents associés |
+| `devices` | id (uuid), famille, nom, IP tunnel, clé publique WG, hachage du jeton, créé le, dissocié le |
+| `pairing_codes` | code (8 car.), famille, appareil prévu, expire le, utilisé le |
+| `policies` | appareil, mode manuel, plages horaires, quota, coupure cyclique, services bloqués, liste blanche, règles d'applications (JSON), version |
+| `device_state` | appareil, batterie, position, réseau (mobile/Wi-Fi), version de l'appli, Device Owner actif, vu le |
+| `traffic` | appareil, jour, octets mobile, octets Wi-Fi (attribués selon le réseau déclaré) |
+| `usage` | appareil, jour, temps d'écran total et par application |
+| `events` | appareil, type, détail, horodatage |
+
+**API (esquisse)**
+
+| Route | Qui | Rôle |
+|---|---|---|
+| `POST /api/parent/login` | parent | jeton de session |
+| `GET/PUT /api/parent/devices/{id}/policy` | parent | lire / modifier les consignes (versionnées) |
+| `POST /api/parent/devices/{id}/pairing-code` | parent | créer un code d'appairage (10 min, usage unique) |
+| `POST /api/parent/devices/{id}/bonus` | parent | temps supplémentaire du jour |
+| `GET /api/parent/devices/{id}/{state,traffic,usage,events,dns-log}` | parent | suivi |
+| `WS /api/parent/ws` | parent | changements en direct |
+| `POST /api/pair` | appareil (public, limité en débit) | code + clé publique → IP tunnel, clé serveur, point de terminaison, jeton |
+| `GET /api/device/policy` | appareil (tunnel) | consignes en vigueur |
+| `POST /api/device/{state,usage,events}` | appareil (tunnel) | remontées |
+| `WS /api/device/ws` | appareil (tunnel) | consignes poussées en direct |
+| `GET /api/device/time` | appareil (tunnel) | heure de référence (horloge de confiance) |
+
+**Authentification**
+- parent : mot de passe (argon2) + jeton de session ;
+- appareil : jeton remis à l'appairage (stocké haché) **et** adresse source 10.78.0.x qui doit
+  correspondre à l'appareil du jeton. Un jeton volé est inutilisable hors du tunnel de cet appareil ;
+- `/api/pair` : 5 essais par minute et par IP, code invalidé après usage.
+
+## 5. Appairage
+
+```
+Parent (FamilyControl)        familyd                         Enfant (DataControl)
+  │ créer l'appareil ───────────►│ réserve 10.78.0.x
+  │◄── code ABCD2345 (10 min) ───│
+  │ affiche code + QR ··································►│ saisit le code (ou scanne)
+  │                              │                        │ génère sa paire de clés WG
+  │                              │◄── POST /api/pair ─────│  (clé privée jamais transmise)
+  │                              │   {code, clé publique}  │
+  │                              │ wg set wg1 peer …       │
+  │                              │ code consommé           │
+  │                              │──► {IP, clé serveur, fam-vpn.tuxtech.fr:51721, DNS, jeton}
+  │                              │                        │ monte le tunnel
+  │◄── WS : « appareil en ligne » │◄── 1re poignée de main ─│
+```
+
+- Le QR code contient l'URL `https://family.tuxtech.fr` et le code : rien à taper sur le téléphone
+  de l'enfant.
+- La clé privée WireGuard est générée et stockée sur le téléphone (chiffrée par l'Android
+  Keystore) ; perdue = ré-appairage.
+- Dissociation (par le parent) : pair retiré de `wg1`, jeton révoqué, mode `cut` jusqu'au retrait.
+
+## 6. DataControl (téléphone de l'enfant) — v0.2
+
+**Retiré**
+- `FirewallVpnService` (trou noir) et la logique de liste blanche locale par application ;
+- Firebase (`FirebaseGateway`, `RemoteSync`, dépendances `firebase-*`, écran de configuration
+  Firebase) — l'APK s'allège d'autant ;
+- la coupure cyclique locale (devient une règle serveur).
+
+**Ajouté**
+- client WireGuard : bibliothèque officielle `com.wireguard.android:tunnel` (`GoBackend`, qui
+  fournit son propre `VpnService`) ; un seul VPN sur l'appareil, donc aucun conflit. Compter
+  quelques Mo par architecture pour la bibliothèque native ; ne livrer que `arm64-v8a` (et
+  `armeabi-v7a` si un vieil appareil l'exige) ;
+- écran d'appairage (code ou QR) ;
+- client API (HTTP + WebSocket sur 10.78.0.1:8100) avec file d'attente hors ligne pour les
+  remontées ;
+- surveillance du tunnel : poignée de main trop ancienne → nouvelle tentative, alerte locale,
+  événement envoyé dès le retour.
+
+**Conservé**
+- service d'accessibilité et `GuardEngine` (blocage au lancement, temps d'écran) ; les règles
+  arrivent par l'API au lieu de Firestore ; l'horloge de confiance se recale sur
+  `/api/device/time` ;
+- mot de passe local (verrouillage des réglages), journal, mises à jour Gitea ;
+- suivi de consommation local (`TrafficStats`) à titre de contrôle croisé du compteur serveur.
+
+**Type de réseau** : le téléphone déclare à chaque changement s'il est en données mobiles ou en
+Wi-Fi ; le serveur s'en sert pour attribuer les octets (forfait) et pour les règles propres aux
+données mobiles (coupure cyclique).
+
+## 7. FamilyControl (parent) — v0.2
+
+- `src/firebase/*` remplacé par un client de l'API familyd (`src/api/`) : même découpage
+  fonctionnel, pour garder les écrans ;
+- écran de configuration : URL du serveur + compte parent au lieu de la configuration Firebase ;
+- nouveaux écrans : mode en cours (libre / liste blanche / coupé) avec bascule immédiate, services
+  bloqués, journal DNS, consommation réelle mesurée par le serveur ;
+- alertes : appli **ntfy** abonnée au sujet de la famille (ntfy exposé par Traefik en HTTPS, accès
+  refusé par défaut, un jeton par parent). Intégration directe dans FamilyControl plus tard ;
+- **clé de signature** : FamilyControl est signé aujourd'hui avec la clé de débogage publique du
+  modèle React Native. La v0.2 est l'occasion de passer à une clé privée (une réinstallation
+  unique du téléphone parent).
+
+## 8. Verrouillage du téléphone : mode Device Owner
+
+Sans ce mode, l'enfant peut toujours couper le VPN dans les réglages Android (le serveur le voit
+hors ligne et alerte le parent, sans pouvoir l'empêcher). Avec ce mode, DataControl impose :
+
+| Politique | API Android |
+|---|---|
+| VPN toujours actif + blocage des connexions hors VPN | `setAlwaysOnVpnPackage(admin, pkg, lockdown = true, exemptions)` (API 29+ pour les exemptions) |
+| Impossible de modifier les VPN | `addUserRestriction(DISALLOW_CONFIG_VPN)` |
+| Impossible de changer date et heure | `DISALLOW_CONFIG_DATE_TIME` |
+| Pas de réinitialisation ni de mode sans échec | `DISALLOW_FACTORY_RESET`, `DISALLOW_SAFE_BOOT` |
+| DataControl indésinstallable | `setUninstallBlocked(admin, pkg, true)` |
+| Pas d'autre utilisateur | `DISALLOW_ADD_USER` |
+| Mises à jour silencieuses de DataControl | `PackageInstaller` (autorisé au Device Owner) |
+
+**Mise en place** (une fois, câble USB) :
+1. retirer temporairement le compte Google du téléphone (Android refuse sinon) ;
+2. `adb shell dpm set-device-owner com.jttools.datacontrol/.admin.AppDeviceAdminReceiver` ;
+3. remettre le compte Google.
+
+**Précautions**
+- **essayer d'abord sur un téléphone de test** ;
+- prévoir dans DataControl « Retirer le mode propriétaire » (mot de passe + confirmation du
+  parent) : sans lui, seule une réinitialisation complète l'enlève ;
+- `DISALLOW_DEBUGGING_FEATURES` n'est **pas** activé par défaut (garder adb pour la maintenance) ;
+  activable à distance par le parent ;
+- **politique en cas de serveur injoignable** (choix du parent) :
+  - *fermé* : plus d'Internet tant que le serveur ne répond pas (sûr, mais une panne du CT prive
+    l'enfant d'Internet) ;
+  - *ouvert après délai* (recommandé) : au bout de 15 min sans poignée de main, DataControl lève
+    le blocage hors VPN (`lockdown = false`), garde le blocage des applications au lancement, et
+    signale l'incident dès le retour du serveur.
+- applications exemptées du VPN (liste du parent) : téléphone et messagerie de l'opérateur,
+  appels d'urgence.
+
+## 9. Exploitation
+
+- **Disponibilité** : redémarrage automatique du CT (`onboot`), `Restart=on-failure` pour familyd
+  et AdGuard Home, sonde de santé (`/api/health`) surveillée, alerte ntfy si familyd ou `wg1`
+  tombe.
+- **Sauvegarde** : `sqlite3 familyd.db ".backup …"` quotidien (jamais `cp`), clé privée du
+  serveur et `wg1.conf`, configuration AdGuard Home ; intégration aux sauvegardes existantes de
+  pve-home.
+- **Débit** : tout le trafic du téléphone (vidéos comprises) passe par la Freebox deux fois
+  (entrée + sortie). Mesurer en phase 0 ; la fibre Free est en général largement suffisante.
+- **Batterie** : WireGuard est le VPN le plus sobre ; `PersistentKeepalive = 25` coûte un peu,
+  à mesurer sur une journée en phase 0.
+- **Vie privée** : le journal DNS et la position sont des données sur un mineur ; durée de
+  conservation courte (7 jours DNS, 30 jours position), accès réservé aux parents de la famille.
+
+## 10. Migration depuis Firebase
+
+Une seule famille et un ou deux appareils : **bascule franche** plutôt que fonctionnement mixte.
+
+1. Serveur en place et testé (phases 0–1).
+2. Publier FamilyControl v0.2 et DataControl v0.2 (sans Firebase).
+3. Mettre à jour les deux téléphones, ré-appairer l'enfant (QR code).
+4. Vérifier une journée complète (coupures, horaires, quota, alertes).
+5. Supprimer le projet Firebase. L'historique Firestore n'est pas repris (option : script d'export
+   ponctuel si tu veux garder l'historique de trafic).
+
+Tant que la v0.2 n'est pas installée, la v0.1.x continue de fonctionner avec Firebase.
+
+## 11. Phases
+
+| Phase | Contenu | Critère de fin |
+|---|---|---|
+| **0. Essai** (≈ 1 j) | `wg1` à la main + appli WireGuard officielle sur un téléphone de test ; AdGuard Home ; essais nft `open` / `cut` / `allowlist` | Débit et batterie mesurés ; hairpin Freebox vérifié ; mode liste blanche validé (AdGuard `ipset` ou repli dnsmasq) |
+| **1. Serveur** | familyd (API, moteur de règles, compteurs, alertes), assistant root, déploiement documenté, tests pytest | Appairage, changement de mode et quota testés de bout en bout avec un pair manuel |
+| **2. DataControl v0.2** | Client WireGuard, appairage, client API, suppression trou noir + Firebase | Téléphone de test piloté uniquement par familyd pendant 48 h |
+| **3. FamilyControl v0.2** | Client API, nouveaux écrans, clé de signature privée | Toutes les fonctions actuelles disponibles sans Firebase |
+| **4. Device Owner** | Politiques §8, provisionnement, sortie du mode | VPN impossible à couper sur le téléphone de test ; reprise après panne serveur conforme à la politique choisie |
+| **5. Option** | Filtrage réseau par application sur le téléphone : couche Go entre l'interface du VPN et wireguard-go, identification de l'application par `getConnectionOwnerUid` (API 29+) | Une application précise coupée sans couper le reste |
+
+## 12. Phase 0 — état au 2026-10-25
+
+**Réalisé sur le CT 233** (sauvegarde des règles et configurations d'origine :
+`/root/backup-familyd-phase0/`) :
+- CT agrandi : 2 cœurs, 1,5 Go, disque 20 Go ;
+- `wg1` 10.78.0.1/24, UDP 51721 (`wg-quick@wg1`), pair de test 10.78.0.10 ;
+- `/etc/nftables.conf` : ouvertures minimales pour `wg1` dans `table inet filter` + `include
+  "/etc/nftables.d/*.nft"` ; `table inet familyd` dans `/etc/nftables.d/familyd.nft` ;
+- AdGuard Home v0.107.79 (`/opt/AdGuardHome`, DNS 10.78.0.1:53, admin 127.0.0.1:3003, mot de
+  passe `/root/adguard-admin.password`), client « test-phase0 » avec TikTok bloqué ;
+- `familyd-dnsmasq` (liste blanche → `allow4`) ;
+- `fam-mode IP open|allowlist|cut` et `fam-mode list` en attendant familyd ;
+- fichiers de travail : `/root/familyd-phase0/` (config et QR du téléphone de test,
+  `famsim-test.sh` : faux téléphone en espace réseau isolé pour rejouer les tests).
+
+**Tests passés avec le faux téléphone** : les trois modes se comportent comme prévu ; DNS forcé
+(une requête « vers 8.8.8.8 » est servie par le DNS filtrant) ; DoH par IP et DoT bloqués ; LAN,
+ZoomPilot et ntfy injoignables depuis le tunnel ; ZoomPilot, ntfy et `wg0` inchangés.
+
+**Reste à mesurer avec un vrai téléphone** : redirection Freebox UDP 51721 (en 4G), retour en
+boucle sur le Wi-Fi de la maison, débit, batterie sur une journée, blocage TikTok, applications
+qui contournent le DNS.
+
+## 13. Questions ouvertes
+
+1. **Politique en cas de serveur injoignable** : *fermé* ou *ouvert après 15 min* (recommandé) ?
+2. **Device Owner** : d'accord pour retirer temporairement le compte Google du téléphone de
+   l'enfant (ou le réinitialiser) ? Existe-t-il un téléphone de test ?
+3. **CT dédié** plutôt que le CT 233 partagé avec ZoomPilot ?
+4. **Coupure cyclique** (toutes les X minutes sur données mobiles) : la garder dans le nouveau
+   modèle, ou la remplacer par le quota et les plages horaires ?
+5. **Exemptions** du VPN : quelles applications doivent toujours passer (opérateur, banque…) ?

firebase.properties.example

@@ -1,5 +0,0 @@
-# Copier vers firebase.properties (ignoré par git) et renseigner les valeurs de l'app Android
-# déclarée dans la console Firebase (Paramètres du projet > Vos applications).
-apiKey=
-appId=
-projectId=

gradle/libs.versions.toml

@@ -17,8 +17,7 @@ hiltNavigationCompose = "1.2.0"
 datastore = "1.1.1"
 coroutines = "1.8.1"
 workManager = "2.9.1"
-firebaseBom = "33.1.2"
+wireguardTunnel = "1.0.20230706"
-coroutinesPlayServices = "1.8.1"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -46,10 +45,7 @@ androidx-hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navig
 androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }
 kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutines" }
 androidx-work-runtime-ktx = { group = "androidx.work", name = "work-runtime-ktx", version.ref = "workManager" }
-firebase-bom = { group = "com.google.firebase", name = "firebase-bom", version.ref = "firebaseBom" }
+wireguard-tunnel = { group = "com.wireguard.android", name = "tunnel", version.ref = "wireguardTunnel" }
-firebase-auth = { group = "com.google.firebase", name = "firebase-auth" }
-firebase-firestore = { group = "com.google.firebase", name = "firebase-firestore" }
-kotlinx-coroutines-play-services = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-play-services", version.ref = "coroutinesPlayServices" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }

version.properties

@@ -1,2 +1,2 @@
-versionName=0.1.9
+versionName=0.10.0
-versionCode=10
+versionCode=20