Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
  tuxgyverandClaude Opus 5.5
|
1b5558ff8b | ||
|
tuxgyverandClaude Opus 5.5
|
c9547016eb | ||
|
tuxgyverandClaude Opus 5.5
|
33ea4ff947 | ||
|
tuxgyverandClaude Opus 5.5
|
f382eeb4fe | ||
|
tuxgyverandClaude Opus 5.5
|
11d7ed1fa6 | ||
|
tuxgyverandClaude Opus 5.5
|
1d707f8785 | ||
|
tuxgyverandClaude Opus 5.5
|
e269e9932a | ||
|
tuxgyverandClaude Sonnet 5
|
f33776bbb5 | ||
|
tuxgyverandClaude Sonnet 5
|
eecad06eea |
No files matched your search
@@ -19,3 +19,8 @@ gitea-token.properties
|
||||
|
||||
# Configuration Firebase locale (clés du projet).
|
||||
firebase.properties
|
||||
|
||||
# Clé de signature des releases (chemin + mots de passe) : local, jamais versionné.
|
||||
keystore.properties
|
||||
*.keystore
|
||||
*.jks
|
||||
@@ -1,5 +1,44 @@
|
||||
# Changelog
|
||||
|
||||
## 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.
|
||||
- 🔒 **Sécurité** — Changer à la main la date, l'heure ou le fuseau du téléphone ne contourne plus les plages horaires ni le temps d'écran : le changement est ignoré et signalé au parent.
|
||||
- 🔒 **Sécurité** — Mot de passe haché avec PBKDF2 ; après 3 essais ratés, attente croissante (30 s à 15 min). Les mots de passe existants restent valides.
|
||||
- 🔒 **Sécurité** — Effacer le journal demande le mot de passe ; les écrans protégés ne s'affichent plus un instant avant le verrou.
|
||||
- 🔒 **Sécurité** — Le code d'appairage ne sert qu'une fois ; réglages, appairage et journal ne sont plus inclus dans la sauvegarde Google.
|
||||
- 🐛 **Corrigé** — L'alerte « protection anti-désinstallation retirée » ne peut plus se perdre ; si le système refuse de relancer la surveillance, une notification invite à rouvrir l'application et le parent est prévenu.
|
||||
- 🐛 **Corrigé** — La liste des applications est renvoyée au parent à chaque installation ou désinstallation ; le bouton Retour de l'écran de blocage renvoie toujours à l'accueil.
|
||||
- 🛠️ **Modifié** — Journal plus léger (la liste n'est reconstruite que lorsque l'onglet est ouvert) et horodatage fiable.
|
||||
- ⚙️ **Technique** — Signature des releases via `keystore.properties` (même clé qu'avant) ; premiers tests unitaires ; README et page « À propos » alignés sur le comportement réel (la coupure cyclique tourne en permanence sur données mobiles).
|
||||
|
||||
## v0.1.8 – 2026-09-21
|
||||
|
||||
- Contrôle parental : la configuration Firebase se **saisit dans l'application** (Réglages → Contrôle parental → Configuration Firebase), en collant la chaîne « fc1:… » partagée par FamilyControl ou le bloc « firebaseConfig » de la console. Plus besoin de recompiler ni de fichier firebase.properties (qui reste possible comme valeur par défaut).
|
||||
- La liaison Firebase se relance automatiquement quand la configuration change.
|
||||
|
||||
## v0.1.7 – 2026-09-20
|
||||
|
||||
- Contrôle parental : si le parent supprime l'appareil depuis FamilyControl, DataControl se dissocie automatiquement (règles et envois arrêtés) et le note dans le journal.
|
||||
|
||||
## v0.1.6 – 2026-09-20
|
||||
|
||||
- Onglet Journal : le bouton « Tester le VPN » est retiré (le VPN se monte correctement).
|
||||
|
||||
@@ -15,7 +15,7 @@ GITEA_REPO_NAME := DataControl
|
||||
GITEA_TOKEN ?= $(shell sed -n 's/^giteaToken=//p' gitea-token.properties 2>/dev/null | tr -d '[:space:]')
|
||||
|
||||
.DEFAULT_GOAL := help
|
||||
.PHONY: help build release install push version-bump changelog clean tag _check-token _check-apk publish deploy
|
||||
.PHONY: help build release install push version version-bump changelog clean tag _check-token _check-apk publish deploy
|
||||
|
||||
BOLD := \033[1m
|
||||
DIM := \033[2m
|
||||
@@ -34,6 +34,7 @@ help:
|
||||
@printf " $(GREEN)make install$(RESET) 📲 Installer l'APK debug sur l'appareil connecté\n"
|
||||
@printf "\n"
|
||||
@printf " $(BOLD)🚀 Versions & publication$(RESET)\n"
|
||||
@printf " $(GREEN)make version$(RESET) 🏷️ Afficher la version courante\n"
|
||||
@printf " $(GREEN)make version-bump$(RESET) 🔖 Incrémenter versionCode et le patch de versionName\n"
|
||||
@printf " $(GREEN)make changelog$(RESET) 📝 Ajouter au CHANGELOG les commits depuis le dernier tag\n"
|
||||
@printf " $(GREEN)make push$(RESET) 📤 Commit, tag et push de la version courante\n"
|
||||
@@ -131,6 +132,10 @@ publish: _check-apk _check-token tag
|
||||
deploy: release publish
|
||||
@printf "$(GREEN)🚢 Déploiement terminé.$(RESET)\n"
|
||||
|
||||
version:
|
||||
@printf "$(YELLOW)🏷️ Version courante...$(RESET)\n"
|
||||
@echo "v$(VERSION_NAME) (build $(VERSION_CODE))"
|
||||
|
||||
version-bump:
|
||||
@printf "$(YELLOW)🔖 Incrémentation de la version...$(RESET)\n"
|
||||
@NEW_CODE=$$(( $(VERSION_CODE) + 1 )); \
|
||||
|
||||
@@ -1,53 +1,44 @@
|
||||
# DataControl
|
||||
|
||||
**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.
|
||||
🚀 v0.3.0 · 🤖 Android · 🟣 Kotlin · 🎨 Jetpack Compose · 🔒 WireGuard · 🛡️ mode propriétaire · 👨👩👧 contrôle parental · 🧪 tests · 📄 licence non déclarée
|
||||
|
||||
> JT-Tools by Johnny — version courante et historique : voir [CHANGELOG.md](CHANGELOG.md) (aussi lisible dans l'onglet *À propos* de l'application).
|
||||
**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). 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).
|
||||
- **Forfait configurable** — Volume du forfait (Mo), prix du forfait (€), prix par Mo hors-forfait (€), date de début du cycle.
|
||||
- **Estimation du coût** — Calcul automatique : prix du forfait + (Mo hors-forfait × prix/Mo), affiché en temps réel sur le tableau de bord.
|
||||
- **Réinitialisation** — Automatique chaque mois à la date anniversaire du début de forfait, ou manuelle à tout moment depuis le tableau de bord.
|
||||
- **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é.
|
||||
- **Coupure cyclique en cas de dépassement** — Une fois le forfait dépassé, une coupure totale (même pour la liste blanche) se déclenche automatiquement toutes les X minutes (paramétrable), pendant une courte pulsation, avant de revenir en mode "liste blanche seule".
|
||||
- **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.
|
||||
- **Démarrage au boot** — Le service redémarre automatiquement après un redémarrage de l'appareil si le contrôle était actif.
|
||||
- **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.
|
||||
- **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.
|
||||
- **Mise à jour intégrée** — Recherche et installation de la dernière Release Gitea depuis l'onglet *À propos*.
|
||||
- **Mot de passe de verrouillage** — Protège les Réglages et la désactivation du contrôle.
|
||||
- **Interface Material 3** — Thème clair/sombre avec couleurs dynamiques (Android 12+), 5 onglets : Tableau de bord, Réglages, Liste blanche, Journal, À propos.
|
||||
- **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é).
|
||||
- **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.
|
||||
- **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è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).
|
||||
- **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.
|
||||
- **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.
|
||||
- **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.
|
||||
- **Suivi de la consommation** — Données mobiles depuis le début du cycle (`TrafficStats`), forfait, coût estimé, réinitialisation mensuelle automatique ou manuelle.
|
||||
- **Mot de passe de verrouillage** — Protège les Réglages, l'effacement du journal, la désactivation de la protection et la sortie du mode propriétaire. Haché avec PBKDF2 ; après 3 essais ratés, attente croissante (30 s à 15 min).
|
||||
- **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** — 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`.
|
||||
|
||||
---
|
||||
|
||||
## 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). Sans fichier `firebase.properties` à la compilation (voir `firebase.properties.example`), ces fonctions sont simplement désactivées.
|
||||
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*.
|
||||
- **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.
|
||||
- **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).
|
||||
**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.
|
||||
|
||||
---
|
||||
**Ou par adb** :
|
||||
|
||||
## Comportement du pare-feu (important)
|
||||
|
||||
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.
|
||||
|
||||
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 : seules les apps cochées ont accès | Liste blanche active **+** coupure totale cyclique toutes les X minutes (pulsation de 30 s, même les apps de la liste blanche sont coupées pendant la pulsation) |
|
||||
|
||||
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é.
|
||||
```bash
|
||||
# téléphone branché en USB, débogage USB actif, tous les comptes retirés le temps de la commande
|
||||
adb shell dpm set-device-owner com.jttools.datacontrol/.admin.AppDeviceAdminReceiver
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
@@ -55,34 +46,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` |
|
||||
| Notifications (Android 13+) | Afficher la notification permanente d'état |
|
||||
| Ignorer l'optimisation de la batterie | Éviter que le système ne tue le service de surveillance |
|
||||
| `QUERY_ALL_PACKAGES` | Lister toutes les applications installées dans l'écran Liste blanche |
|
||||
| `RECEIVE_BOOT_COMPLETED` | Relancer la surveillance après redémarrage si le contrôle était actif |
|
||||
| Position (dont arrière-plan) | Facultatif — transmise au parent si l'appareil est associé |
|
||||
| Administrateur d'appareil | Facultatif — anti-désinstallation |
|
||||
| Service d'accessibilité | Facultatif — détecte l'application au premier plan (sans lire les écrans) pour les règles d'usage et le journal |
|
||||
| VPN (consentement système) | Tunnel WireGuard — demandé à l'activation de la protection (accordé automatiquement en mode propriétaire) |
|
||||
| Notifications (Android 13+) | Notification permanente d'état |
|
||||
| Ignorer l'optimisation de la batterie | Éviter que le système n'arrête la surveillance |
|
||||
| `QUERY_ALL_PACKAGES` | Liste des applications installées, pour que le parent choisisse lesquelles limiter |
|
||||
| `RECEIVE_BOOT_COMPLETED` | Relancer la surveillance et le tunnel après redémarrage |
|
||||
| Position (dont arrière-plan) | Facultatif — transmise au parent |
|
||||
| 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 |
|
||||
|
||||
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.
|
||||
- `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 pare-feu VPN local est incompatible avec l'usage simultané d'un autre VPN (limitation système Android : un seul VPN actif à la fois).
|
||||
- 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.
|
||||
- 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.
|
||||
- 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.
|
||||
- `data/` — `SettingsRepository` (DataStore Preferences), `UsageRepository` (TrafficStats), `InstalledAppsRepository` (PackageManager).
|
||||
- `service/` — `FirewallVpnService` (VpnService), `ConnectivityObserver` (détection Wi-Fi/cellulaire), `DataMonitorService` (orchestration + notification), `MonitorStateHolder` (pont service ↔ UI), `BootReceiver`.
|
||||
- `remote/` — `FirebaseGateway`, `RemoteSync` (appairage, consignes, remontées), `DeviceReporter` (batterie, position, trafic, état).
|
||||
- `guard/` — `GuardEngine` (règles d'usage, temps d'écran), `AppGuardService` (accessibilité), `BlockedActivity`.
|
||||
- `admin/` — administrateur d'appareil (anti-désinstallation). `log/` — journal de diagnostic.
|
||||
- `ui/` — écrans Compose (`dashboard`, `settings`, `whitelist`, `journal`, `about`, `family`), navigation par `NavigationBar`, thème dynamique.
|
||||
- **Kotlin + Jetpack Compose (Material 3)**, Hilt, DataStore Preferences.
|
||||
- `vpn/` — `TunnelManager` (bibliothèque WireGuard officielle, `GoBackend`).
|
||||
- `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).
|
||||
- `service/` — `DataMonitorService` (tunnel, consommation, notification, mode propriétaire), `ConnectivityObserver`, `MonitorStateHolder`, `BootReceiver`, `DataMonitorRestartWorker`.
|
||||
- `guard/` — `GuardEngine` (règles d'usage, temps d'écran, horloge de confiance), `AppGuardService` (accessibilité), `BlockedActivity`.
|
||||
- `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`, `family`, `journal`, `about`).
|
||||
|
||||
Le serveur **familyd** (FastAPI, WireGuard, nftables, AdGuard Home) est dans un dépôt séparé (`~/scripts/familyd`).
|
||||
|
||||
---
|
||||
|
||||
@@ -97,6 +94,8 @@ make deploy # APK release + publication en Release Gitea (voir `make help`)
|
||||
|
||||
Prérequis : Android SDK (API 34), JDK 17. Le wrapper Gradle télécharge Gradle 8.13 au premier lancement.
|
||||
|
||||
Signature : la release est signée avec la clé décrite dans `keystore.properties` (non versionné, modèle dans `keystore.properties.example`). Cette clé doit rester celle des versions déjà publiées, sinon les téléphones refusent la mise à jour : sauvegarder le keystore et ce fichier. Sans `keystore.properties`, la compilation retombe sur la clé de débogage, avec un avertissement.
|
||||
|
||||
---
|
||||
|
||||
## Licence
|
||||
|
||||
+25
-12
@@ -9,10 +9,10 @@ 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")
|
||||
// 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 {
|
||||
val f = rootProject.file("keystore.properties")
|
||||
if (f.exists()) f.inputStream().use { load(it) }
|
||||
}
|
||||
|
||||
@@ -35,13 +35,23 @@ 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())}\"")
|
||||
}
|
||||
|
||||
signingConfigs {
|
||||
if (keystoreProps.getProperty("storeFile") != null) {
|
||||
create("release") {
|
||||
storeFile = file(keystoreProps.getProperty("storeFile"))
|
||||
storePassword = keystoreProps.getProperty("storePassword")
|
||||
keyAlias = keystoreProps.getProperty("keyAlias")
|
||||
keyPassword = keystoreProps.getProperty("keyPassword")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
buildTypes {
|
||||
release {
|
||||
isMinifyEnabled = true
|
||||
@@ -49,7 +59,10 @@ android {
|
||||
getDefaultProguardFile("proguard-android-optimize.txt"),
|
||||
"proguard-rules.pro"
|
||||
)
|
||||
signingConfig = signingConfigs.getByName("debug")
|
||||
signingConfig = signingConfigs.findByName("release") ?: run {
|
||||
logger.warn("⚠️ keystore.properties absent : release signée avec la clé de débogage")
|
||||
signingConfigs.getByName("debug")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -109,12 +122,12 @@ dependencies {
|
||||
implementation(libs.androidx.datastore.preferences)
|
||||
implementation(libs.kotlinx.coroutines.android)
|
||||
implementation(libs.androidx.work.runtime.ktx)
|
||||
implementation(platform(libs.firebase.bom))
|
||||
implementation(libs.firebase.auth)
|
||||
implementation(libs.firebase.firestore)
|
||||
implementation(libs.kotlinx.coroutines.play.services)
|
||||
// Client WireGuard officiel (GoBackend : wireguard-go embarqué, VpnService fourni par la bibliothèque).
|
||||
implementation(libs.wireguard.tunnel)
|
||||
|
||||
testImplementation(libs.junit)
|
||||
// org.json est fourni par Android à l'exécution, mais absent (bouchonné) des tests JVM.
|
||||
testImplementation(libs.org.json)
|
||||
androidTestImplementation(libs.androidx.junit)
|
||||
androidTestImplementation(libs.androidx.espresso.core)
|
||||
androidTestImplementation(platform(libs.androidx.compose.bom))
|
||||
|
||||
Vendored
+5
@@ -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.** { *; }
|
||||
@@ -23,6 +23,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,16 +40,6 @@
|
||||
</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"
|
||||
@@ -96,9 +87,32 @@
|
||||
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>
|
||||
|
||||
<receiver
|
||||
android:name=".service.BootReceiver"
|
||||
android:exported="true"
|
||||
|
||||
@@ -21,7 +21,15 @@ class DataControlApp : Application() {
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
com.jttools.datacontrol.log.AppLog.init(this)
|
||||
CoroutineScope(Dispatchers.IO).launch { settingsRepository.resetPasswordOnce() }
|
||||
CoroutineScope(Dispatchers.IO).launch {
|
||||
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.
|
||||
val request = PeriodicWorkRequestBuilder<DataMonitorRestartWorker>(15, TimeUnit.MINUTES).build()
|
||||
|
||||
@@ -4,16 +4,25 @@ import android.os.Bundle
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.activity.enableEdgeToEdge
|
||||
import androidx.lifecycle.lifecycleScope
|
||||
import com.jttools.datacontrol.data.SettingsRepository
|
||||
import com.jttools.datacontrol.log.AppLog
|
||||
import com.jttools.datacontrol.service.DataMonitorService
|
||||
import com.jttools.datacontrol.ui.SystemActions
|
||||
import com.jttools.datacontrol.ui.navigation.DataControlNavHost
|
||||
import com.jttools.datacontrol.ui.theme.DataControlTheme
|
||||
import dagger.hilt.android.AndroidEntryPoint
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.launch
|
||||
import javax.inject.Inject
|
||||
|
||||
@AndroidEntryPoint
|
||||
class MainActivity : ComponentActivity() {
|
||||
|
||||
@Inject lateinit var settingsRepository: SettingsRepository
|
||||
|
||||
private lateinit var systemActions: SystemActions
|
||||
private var vpnAskedThisSession = false
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
@@ -29,4 +38,21 @@ class MainActivity : ComponentActivity() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun onResume() {
|
||||
super.onResume()
|
||||
// Contrôle actif mais autorisation VPN perdue (retirée, ou prise par un autre VPN) :
|
||||
// on la redemande à l'ouverture, une seule fois par session pour ne pas boucler.
|
||||
if (vpnAskedThisSession) return
|
||||
lifecycleScope.launch {
|
||||
if (settingsRepository.settingsFlow.first().controlEnabled && !systemActions.isVpnPrepared()) {
|
||||
vpnAskedThisSession = true
|
||||
AppLog.w("Pare-feu", "Contrôle actif sans autorisation VPN : nouvelle demande")
|
||||
systemActions.requestVpnPermission { granted ->
|
||||
AppLog.i("Pare-feu", "Autorisation VPN ${if (granted) "rétablie" else "REFUSÉE"}")
|
||||
if (granted) DataMonitorService.start(this@MainActivity)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
|
||||
@@ -15,13 +15,24 @@ 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."
|
||||
|
||||
override fun onDisabled(context: Context, intent: Intent) {
|
||||
// Prévient le parent : la protection anti-désinstallation vient d'être retirée.
|
||||
// goAsync : sans lui, le processus peut être arrêté avant que l'alerte soit partie.
|
||||
val pending = goAsync()
|
||||
CoroutineScope(Dispatchers.IO).launch {
|
||||
try {
|
||||
remoteSync.pushEvent("admin_disabled", "Protection anti-désinstallation désactivée")
|
||||
} finally {
|
||||
pending.finish()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
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. */
|
||||
data class Target(val protect: Boolean, val lockdown: Boolean)
|
||||
|
||||
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) }
|
||||
dpm.setUninstallBlocked(admin, context.packageName, true)
|
||||
requireAutoTime(context)
|
||||
} else {
|
||||
dpm.setAlwaysOnVpnPackage(admin, null, false)
|
||||
RESTRICTIONS.forEach { dpm.clearUserRestriction(admin, it) }
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
@@ -1,37 +1,32 @@
|
||||
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,
|
||||
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
|
||||
/** Règles d'usage des applications (plages horaires, limites, interdites), envoyées par le serveur. */
|
||||
val rulesJson: String? = null,
|
||||
/** Liaison avec le serveur familyd (null tant que l'appareil n'est pas associé). */
|
||||
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
|
||||
) {
|
||||
val isPaired: Boolean get() = !familyId.isNullOrEmpty() && !deviceId.isNullOrEmpty()
|
||||
val isPaired: Boolean get() = link != null
|
||||
|
||||
val planStartDate: LocalDate get() = LocalDate.ofEpochDay(planStartDateEpochDay)
|
||||
|
||||
@@ -47,13 +42,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. */
|
||||
@@ -68,12 +56,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
|
||||
WARNING, // proche ou au-delà du forfait (>= 80%), liste blanche active, pas de coupure en cours
|
||||
CUT, // coupure totale cyclique en cours (indépendant du dépassement de forfait)
|
||||
WIFI // Wi-Fi actif, aucun filtrage (sauf si filtrage Wi-Fi activé séparément)
|
||||
OK, // sous le seuil d'alerte
|
||||
WARNING, // proche ou au-delà du forfait (>= 80 %)
|
||||
CUT, // le serveur coupe l'accès (mode « coupé » ou « liste blanche »)
|
||||
WIFI // Wi-Fi actif
|
||||
}
|
||||
@@ -2,10 +2,20 @@ package com.jttools.datacontrol.data
|
||||
|
||||
import java.security.MessageDigest
|
||||
import java.security.SecureRandom
|
||||
import javax.crypto.SecretKeyFactory
|
||||
import javax.crypto.spec.PBEKeySpec
|
||||
|
||||
/** Hachage salé (SHA-256) du mot de passe de verrouillage — jamais stocké en clair. */
|
||||
/**
|
||||
* Hachage du mot de passe de verrouillage (PBKDF2-HMAC-SHA256, salé) — jamais stocké en clair.
|
||||
*
|
||||
* Format stocké : `pbkdf2:<itérations>:<hex>`. Les anciens hachages (SHA-256 simple, v0.1.8 et avant)
|
||||
* restent vérifiables et sont convertis au prochain déverrouillage réussi.
|
||||
*/
|
||||
object PasswordHasher {
|
||||
private const val SALT_BYTES = 16
|
||||
private const val ITERATIONS = 100_000
|
||||
private const val KEY_BITS = 256
|
||||
private const val PREFIX = "pbkdf2:"
|
||||
|
||||
fun newSalt(): String {
|
||||
val bytes = ByteArray(SALT_BYTES)
|
||||
@@ -13,11 +23,40 @@ object PasswordHasher {
|
||||
return bytes.toHex()
|
||||
}
|
||||
|
||||
fun hash(password: String, saltHex: String): String {
|
||||
fun hash(password: String, saltHex: String): String =
|
||||
"$PREFIX$ITERATIONS:${pbkdf2(password, saltHex, ITERATIONS)}"
|
||||
|
||||
fun verify(password: String, saltHex: String, stored: String): Boolean {
|
||||
val computed = if (stored.startsWith(PREFIX)) {
|
||||
val iterations = stored.removePrefix(PREFIX).substringBefore(':').toIntOrNull() ?: return false
|
||||
"$PREFIX$iterations:${pbkdf2(password, saltHex, iterations)}"
|
||||
} else {
|
||||
legacySha256(password, saltHex)
|
||||
}
|
||||
// Comparaison à temps constant.
|
||||
return MessageDigest.isEqual(computed.toByteArray(Charsets.UTF_8), stored.toByteArray(Charsets.UTF_8))
|
||||
}
|
||||
|
||||
/** Vrai pour un hachage ancien format, à recalculer avec [hash]. */
|
||||
fun needsUpgrade(stored: String): Boolean = !stored.startsWith("$PREFIX$ITERATIONS:")
|
||||
|
||||
private fun pbkdf2(password: String, saltHex: String, iterations: Int): String {
|
||||
val spec = PBEKeySpec(password.toCharArray(), saltHex.hexToBytes(), iterations, KEY_BITS)
|
||||
try {
|
||||
return SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256").generateSecret(spec).encoded.toHex()
|
||||
} finally {
|
||||
spec.clearPassword()
|
||||
}
|
||||
}
|
||||
|
||||
private fun legacySha256(password: String, saltHex: String): String {
|
||||
val digest = MessageDigest.getInstance("SHA-256")
|
||||
digest.update(saltHex.toByteArray(Charsets.UTF_8))
|
||||
return digest.digest(password.toByteArray(Charsets.UTF_8)).toHex()
|
||||
}
|
||||
|
||||
private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
|
||||
|
||||
private fun String.hexToBytes(): ByteArray =
|
||||
ByteArray(length / 2) { i -> substring(2 * i, 2 * i + 2).toInt(16).toByte() }
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
@@ -1,24 +1,35 @@
|
||||
package com.jttools.datacontrol.data
|
||||
|
||||
import android.content.Context
|
||||
import android.os.SystemClock
|
||||
import androidx.datastore.preferences.core.Preferences
|
||||
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
|
||||
@@ -30,29 +41,48 @@ 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 PASSWORD_FAILS = intPreferencesKey("password_fails")
|
||||
val PASSWORD_LOCK_UNTIL = longPreferencesKey("password_lock_until")
|
||||
val RULES_JSON = stringPreferencesKey("rules_json")
|
||||
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 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 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 ->
|
||||
@@ -64,24 +94,29 @@ 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]
|
||||
rulesJson = prefs[Keys.RULES_JSON],
|
||||
link = FamilyLink.fromJson(prefs[Keys.LINK_JSON]),
|
||||
serverMode = prefs[Keys.SERVER_MODE] ?: defaults.serverMode,
|
||||
serverModeReason = prefs[Keys.SERVER_MODE_REASON] ?: defaults.serverModeReason,
|
||||
policyVersion = prefs[Keys.POLICY_VERSION] ?: defaults.policyVersion
|
||||
)
|
||||
}
|
||||
|
||||
/** 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 }
|
||||
}
|
||||
@@ -90,14 +125,12 @@ class SettingsRepository @Inject constructor(
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -107,22 +140,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 ->
|
||||
@@ -139,18 +156,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 (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.
|
||||
* La base peut devenir négative : c'est volontaire (voir [UsageRepository.consumedBytesSince]).
|
||||
*/
|
||||
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()) {
|
||||
@@ -160,10 +174,12 @@ class SettingsRepository @Inject constructor(
|
||||
}
|
||||
} else {
|
||||
val salt = PasswordHasher.newSalt()
|
||||
val hash = PasswordHasher.hash(password, salt)
|
||||
val hash = withContext(Dispatchers.Default) { PasswordHasher.hash(password, salt) }
|
||||
context.dataStore.edit { prefs ->
|
||||
prefs[Keys.PASSWORD_HASH] = hash
|
||||
prefs[Keys.PASSWORD_SALT] = salt
|
||||
prefs.remove(Keys.PASSWORD_FAILS)
|
||||
prefs.remove(Keys.PASSWORD_LOCK_UNTIL)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -182,95 +198,78 @@ class SettingsRepository @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
/** Vrai si aucun mot de passe n'est défini, ou si [password] correspond au mot de passe stocké. */
|
||||
suspend fun verifyPassword(password: String): Boolean {
|
||||
/** Fin du blocage en temps monotone : avancer l'horloge du téléphone ne raccourcit pas l'attente. */
|
||||
@Volatile private var lockUntilElapsed = 0L
|
||||
|
||||
/**
|
||||
* Vérifie [password]. Renvoie null s'il est correct (ou si aucun mot de passe n'est défini),
|
||||
* sinon le message d'erreur à afficher. Après [FREE_ATTEMPTS] échecs, chaque nouvel essai
|
||||
* impose une attente qui double (30 s, 1 min, 2 min… jusqu'à 15 min).
|
||||
*/
|
||||
suspend fun checkPassword(password: String): String? {
|
||||
val prefs = context.dataStore.data.first()
|
||||
val hash = prefs[Keys.PASSWORD_HASH] ?: return true
|
||||
val salt = prefs[Keys.PASSWORD_SALT] ?: return true
|
||||
return PasswordHasher.hash(password, salt) == hash
|
||||
}
|
||||
val hash = prefs[Keys.PASSWORD_HASH] ?: return null
|
||||
val salt = prefs[Keys.PASSWORD_SALT] ?: return null
|
||||
|
||||
/**
|
||||
* 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
|
||||
* (fréquent sur les ROM qui tuent agressivement les apps en arrière-plan sans exemption batterie).
|
||||
*/
|
||||
suspend fun setCutoffCycleState(anchorMillis: Long?, inPulse: Boolean, pulseStartMillis: Long) {
|
||||
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
|
||||
}
|
||||
}
|
||||
val remaining = maxOf(
|
||||
(prefs[Keys.PASSWORD_LOCK_UNTIL] ?: 0L) - System.currentTimeMillis(),
|
||||
lockUntilElapsed - SystemClock.elapsedRealtime()
|
||||
)
|
||||
if (remaining > 0) return lockMessage(remaining)
|
||||
|
||||
suspend fun setPairing(familyId: String?, deviceId: String?) {
|
||||
val ok = withContext(Dispatchers.Default) { PasswordHasher.verify(password, salt, hash) }
|
||||
if (ok) {
|
||||
val upgraded = if (PasswordHasher.needsUpgrade(hash)) {
|
||||
withContext(Dispatchers.Default) { PasswordHasher.newSalt().let { it to PasswordHasher.hash(password, it) } }
|
||||
} else null
|
||||
lockUntilElapsed = 0L
|
||||
context.dataStore.edit {
|
||||
if (familyId == null || deviceId == null) {
|
||||
it.remove(Keys.FAMILY_ID)
|
||||
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
|
||||
it.remove(Keys.PASSWORD_FAILS)
|
||||
it.remove(Keys.PASSWORD_LOCK_UNTIL)
|
||||
upgraded?.let { (newSalt, newHash) ->
|
||||
it[Keys.PASSWORD_SALT] = newSalt
|
||||
it[Keys.PASSWORD_HASH] = newHash
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 }
|
||||
var lockMs = 0L
|
||||
context.dataStore.edit {
|
||||
val fails = (it[Keys.PASSWORD_FAILS] ?: 0) + 1
|
||||
it[Keys.PASSWORD_FAILS] = fails
|
||||
if (fails >= FREE_ATTEMPTS) {
|
||||
lockMs = (LOCK_BASE_MS shl (fails - FREE_ATTEMPTS).coerceAtMost(10)).coerceAtMost(LOCK_MAX_MS)
|
||||
it[Keys.PASSWORD_LOCK_UNTIL] = System.currentTimeMillis() + lockMs
|
||||
}
|
||||
}
|
||||
if (lockMs > 0) {
|
||||
lockUntilElapsed = SystemClock.elapsedRealtime() + lockMs
|
||||
AppLog.w("Mot de passe", "Mot de passe erroné, saisie bloquée ${lockMs / 1000} s")
|
||||
return "Mot de passe incorrect. " + lockMessage(lockMs)
|
||||
}
|
||||
AppLog.w("Mot de passe", "Mot de passe erroné")
|
||||
return "Mot de passe incorrect."
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
private fun lockMessage(ms: Long): String {
|
||||
val s = (ms + 999) / 1000
|
||||
return if (s < 60) "Trop d'essais : réessayez dans $s s." else "Trop d'essais : réessayez dans ${(s + 59) / 60} min."
|
||||
}
|
||||
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)
|
||||
|
||||
// --- Horloge de référence et temps d'écran --------------------------------------------------
|
||||
|
||||
/** 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
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
suspend fun loadUsage(): Pair<String, String>? {
|
||||
@@ -286,4 +285,90 @@ class SettingsRepository @Inject constructor(
|
||||
it[Keys.USAGE_JSON] = json
|
||||
}
|
||||
}
|
||||
|
||||
// --- Liaison familyd --------------------------------------------------------------------
|
||||
|
||||
/** 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 {
|
||||
it[Keys.LINK_JSON] = link.toJson()
|
||||
it[Keys.LINK_TOKEN_ENC] = token
|
||||
it[Keys.WG_PRIVATE_ENC] = key
|
||||
it[Keys.SERVER_MODE] = "open"
|
||||
it[Keys.SERVER_MODE_REASON] = ""
|
||||
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?) {
|
||||
context.dataStore.edit {
|
||||
it[Keys.POLICY_VERSION] = version
|
||||
it[Keys.SERVER_MODE] = mode
|
||||
it[Keys.SERVER_MODE_REASON] = reason
|
||||
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()
|
||||
}
|
||||
@@ -118,12 +118,11 @@ 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) {
|
||||
"BLOCK_ALL" -> "BLOQUÉ (coupure totale en cours) [$net]" to true
|
||||
"FILTER" ->
|
||||
if (pkg in snap.effectiveWhitelist) "AUTORISÉ (liste blanche) [$net]" to false
|
||||
else "BLOQUÉ (hors liste blanche) [$net]" to true
|
||||
else -> "libre (aucun filtrage sur ce réseau) [$net]" to false
|
||||
if (!snap.tunnelUp) return "NON FILTRÉ (tunnel coupé) [$net]" to false
|
||||
return when (snap.serverMode) {
|
||||
"cut" -> "BLOQUÉ (Internet coupé par le serveur) [$net]" to true
|
||||
"allowlist" -> "LIMITÉ (liste blanche du serveur) [$net]" to true
|
||||
else -> "filtré par le serveur (accès libre) [$net]" to false
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -4,6 +4,7 @@ import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.os.Bundle
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.OnBackPressedCallback
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.activity.enableEdgeToEdge
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
@@ -32,6 +33,10 @@ class BlockedActivity : ComponentActivity() {
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
enableEdgeToEdge()
|
||||
// Retour : renvoie à l'accueil, jamais vers l'application bloquée.
|
||||
onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
|
||||
override fun handleOnBackPressed() = goHome()
|
||||
})
|
||||
val label = intent.getStringExtra(EXTRA_LABEL).orEmpty()
|
||||
val message = intent.getStringExtra(EXTRA_MESSAGE).orEmpty()
|
||||
setContent {
|
||||
@@ -55,8 +60,6 @@ class BlockedActivity : ComponentActivity() {
|
||||
}
|
||||
}
|
||||
|
||||
@Deprecated("Deprecated in Java")
|
||||
override fun onBackPressed() = goHome()
|
||||
|
||||
private fun goHome() {
|
||||
startActivity(Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_HOME).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
|
||||
|
||||
@@ -1,7 +1,16 @@
|
||||
package com.jttools.datacontrol.guard
|
||||
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.IntentFilter
|
||||
import android.os.SystemClock
|
||||
import android.provider.Settings
|
||||
import androidx.core.content.ContextCompat
|
||||
import com.jttools.datacontrol.data.SettingsRepository
|
||||
import com.jttools.datacontrol.log.AppLog
|
||||
import com.jttools.datacontrol.remote.RemoteSync
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
@@ -11,10 +20,12 @@ import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlinx.coroutines.launch
|
||||
import org.json.JSONObject
|
||||
import java.time.LocalDate
|
||||
import java.time.Instant
|
||||
import java.time.LocalDateTime
|
||||
import java.time.ZoneId
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
import kotlin.math.abs
|
||||
|
||||
data class Block(val message: String)
|
||||
|
||||
@@ -27,9 +38,19 @@ data class UsageSnapshot(val date: String, val totalMs: Long, val appMs: Map<Str
|
||||
*
|
||||
* L'appelant ([AppGuardService]) ne signale JAMAIS les applications exemptées (lanceur, téléphone,
|
||||
* clavier, DataControl) : elles ne comptent pas et ne sont jamais bloquées.
|
||||
*
|
||||
* Horloge de référence : changer la date ou l'heure du téléphone ne doit ni ouvrir une plage horaire
|
||||
* ni remettre à zéro le temps d'écran. Les sauts d'horloge sont repérés en comparant l'heure système
|
||||
* au temps monotone ([SystemClock.elapsedRealtime], non modifiable). Si l'heure automatique (réseau)
|
||||
* est désactivée, le saut est neutralisé (décalage mémorisé) et signalé au parent ; si elle est
|
||||
* activée, l'heure système fait foi. Même principe pour le fuseau horaire.
|
||||
*/
|
||||
@Singleton
|
||||
class GuardEngine @Inject constructor(private val settings: SettingsRepository) {
|
||||
class GuardEngine @Inject constructor(
|
||||
@ApplicationContext private val context: Context,
|
||||
private val settings: SettingsRepository,
|
||||
private val remoteSync: RemoteSync
|
||||
) {
|
||||
|
||||
private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
|
||||
private val lock = Any()
|
||||
@@ -38,18 +59,51 @@ class GuardEngine @Inject constructor(private val settings: SettingsRepository)
|
||||
private set
|
||||
|
||||
private var started = false
|
||||
private var day = LocalDate.now().toString()
|
||||
private var totalMs = 0L
|
||||
private val appMs = HashMap<String, Long>()
|
||||
private var currentPkg: String? = null
|
||||
private var lastMark = SystemClock.elapsedRealtime()
|
||||
private var screenOn = true
|
||||
private var dirty = false
|
||||
|
||||
// Horloge de référence.
|
||||
private var skewMs = 0L
|
||||
private var zone: ZoneId = ZoneId.systemDefault()
|
||||
private var refSysMs = System.currentTimeMillis()
|
||||
private var refElapsedMs = SystemClock.elapsedRealtime()
|
||||
|
||||
private var day = today()
|
||||
private var totalMs = 0L
|
||||
private val appMs = HashMap<String, Long>()
|
||||
|
||||
private val clockReceiver = object : BroadcastReceiver() {
|
||||
override fun onReceive(c: Context?, intent: Intent?) {
|
||||
synchronized(lock) {
|
||||
if (intent?.action == Intent.ACTION_TIMEZONE_CHANGED) onZoneChanged()
|
||||
flush()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun start() {
|
||||
synchronized(lock) { if (started) return; started = true }
|
||||
scope.launch {
|
||||
val (savedSkew, savedZone) = settings.trustedClock()
|
||||
synchronized(lock) {
|
||||
skewMs = if (autoTime()) 0L else savedSkew
|
||||
zone = savedZone?.takeIf { !autoZone() }?.let { runCatching { ZoneId.of(it) }.getOrNull() }
|
||||
?: ZoneId.systemDefault()
|
||||
refSysMs = System.currentTimeMillis()
|
||||
refElapsedMs = SystemClock.elapsedRealtime()
|
||||
day = today()
|
||||
}
|
||||
settings.loadUsage()?.let { (savedDay, json) -> restore(savedDay, json) }
|
||||
ContextCompat.registerReceiver(
|
||||
context, clockReceiver,
|
||||
IntentFilter().apply {
|
||||
addAction(Intent.ACTION_TIME_CHANGED)
|
||||
addAction(Intent.ACTION_TIMEZONE_CHANGED)
|
||||
},
|
||||
ContextCompat.RECEIVER_NOT_EXPORTED
|
||||
)
|
||||
settings.settingsFlow.map { it.rulesJson }.distinctUntilChanged().collect { rules = Rules.parse(it) }
|
||||
}
|
||||
scope.launch {
|
||||
@@ -62,7 +116,7 @@ class GuardEngine @Inject constructor(private val settings: SettingsRepository)
|
||||
}
|
||||
|
||||
private fun restore(savedDay: String, json: String) = synchronized(lock) {
|
||||
if (savedDay != LocalDate.now().toString()) return@synchronized
|
||||
if (savedDay != today()) return@synchronized
|
||||
runCatching {
|
||||
val o = JSONObject(json)
|
||||
day = savedDay
|
||||
@@ -89,9 +143,71 @@ class GuardEngine @Inject constructor(private val settings: SettingsRepository)
|
||||
|
||||
fun tick() = synchronized(lock) { flush() }
|
||||
|
||||
/** Heure de référence (heure système corrigée des réglages manuels repérés). À appeler sous verrou. */
|
||||
private fun nowLocal(): LocalDateTime {
|
||||
checkClockJump()
|
||||
return LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis() + skewMs), zone)
|
||||
}
|
||||
|
||||
private fun today(): String = nowLocal().toLocalDate().toString()
|
||||
|
||||
/** Repère un saut de l'heure système par rapport au temps monotone. À appeler sous verrou. */
|
||||
private fun checkClockJump() {
|
||||
val sys = System.currentTimeMillis()
|
||||
val elapsed = SystemClock.elapsedRealtime()
|
||||
val jump = sys - (refSysMs + (elapsed - refElapsedMs))
|
||||
// La référence ne bouge qu'après un saut : des petits réglages successifs s'additionnent
|
||||
// et finissent par être repérés.
|
||||
if (abs(jump) < CLOCK_JUMP_TOLERANCE_MS) return
|
||||
refSysMs = sys
|
||||
refElapsedMs = elapsed
|
||||
val auto = autoTime()
|
||||
val newSkew = if (auto) 0L else skewMs - jump
|
||||
if (newSkew == skewMs) return
|
||||
skewMs = newSkew
|
||||
saveClock()
|
||||
val minutes = jump / 60_000
|
||||
if (auto) {
|
||||
AppLog.i("Horloge", "Heure corrigée par le réseau (${signed(minutes)} min)")
|
||||
} else {
|
||||
val detail = "Heure du téléphone modifiée à la main (${signed(minutes)} min) : ignorée pour les plages horaires et le temps d'écran"
|
||||
AppLog.w("Horloge", detail)
|
||||
scope.launch { remoteSync.pushEvent("clock_changed", detail) }
|
||||
}
|
||||
}
|
||||
|
||||
/** À appeler sous verrou. */
|
||||
private fun onZoneChanged() {
|
||||
val system = ZoneId.systemDefault()
|
||||
if (system == zone) return
|
||||
if (autoZone()) {
|
||||
AppLog.i("Horloge", "Fuseau horaire : $zone → $system (automatique)")
|
||||
zone = system
|
||||
saveClock()
|
||||
} else {
|
||||
val detail = "Fuseau horaire changé à la main ($zone → $system) : ignoré pour les plages horaires et le temps d'écran"
|
||||
AppLog.w("Horloge", detail)
|
||||
scope.launch { remoteSync.pushEvent("clock_changed", detail) }
|
||||
}
|
||||
}
|
||||
|
||||
private fun saveClock() {
|
||||
val s = skewMs
|
||||
val z = zone.id
|
||||
scope.launch { settings.setTrustedClock(s, z) }
|
||||
}
|
||||
|
||||
private fun signed(v: Long) = if (v >= 0) "+$v" else "$v"
|
||||
|
||||
private fun autoTime(): Boolean =
|
||||
Settings.Global.getInt(context.contentResolver, Settings.Global.AUTO_TIME, 1) == 1
|
||||
|
||||
private fun autoZone(): Boolean =
|
||||
Settings.Global.getInt(context.contentResolver, Settings.Global.AUTO_TIME_ZONE, 1) == 1
|
||||
|
||||
private fun flush() {
|
||||
val now = SystemClock.elapsedRealtime()
|
||||
val today = LocalDate.now().toString()
|
||||
val today = today()
|
||||
if (today != day) {
|
||||
day = today; totalMs = 0; appMs.clear(); dirty = true
|
||||
}
|
||||
@@ -111,22 +227,22 @@ class GuardEngine @Inject constructor(private val settings: SettingsRepository)
|
||||
/** Vrai si l'appareil est hors de toutes les plages horaires autorisées. */
|
||||
fun scheduleLocked(): Boolean = synchronized(lock) {
|
||||
val r = rules
|
||||
r.scheduleEnabled && !inWindow(r, LocalDateTime.now())
|
||||
r.scheduleEnabled && !r.isOpenAt(nowLocal())
|
||||
}
|
||||
|
||||
fun cutsMobileNow(): Boolean = synchronized(lock) {
|
||||
val r = rules
|
||||
r.scheduleEnabled && r.scheduleCutsMobile && !inWindow(r, LocalDateTime.now())
|
||||
r.scheduleEnabled && r.scheduleCutsMobile && !r.isOpenAt(nowLocal())
|
||||
}
|
||||
|
||||
fun check(pkg: String): Block? = synchronized(lock) {
|
||||
flush()
|
||||
val r = rules
|
||||
if (r.isEmpty) return null
|
||||
val now = LocalDateTime.now()
|
||||
val now = nowLocal()
|
||||
if (pkg in r.blocked) return Block("Cette application est bloquée par vos parents.")
|
||||
if (r.scheduleEnabled && !inWindow(r, now)) {
|
||||
return Block("L'appareil est verrouillé en dehors des plages horaires. ${nextOpening(r, now)}")
|
||||
if (r.scheduleEnabled && !r.isOpenAt(now)) {
|
||||
return Block("L'appareil est verrouillé en dehors des plages horaires. ${r.nextOpeningText(now)}")
|
||||
}
|
||||
val bonusToday = r.bonusDate == day
|
||||
if (r.dailyLimitMin > 0) {
|
||||
@@ -142,31 +258,11 @@ class GuardEngine @Inject constructor(private val settings: SettingsRepository)
|
||||
null
|
||||
}
|
||||
|
||||
private fun inWindow(r: Rules, now: LocalDateTime): Boolean {
|
||||
val dow = now.dayOfWeek.value
|
||||
val prev = if (dow == 1) 7 else dow - 1
|
||||
val minute = now.hour * 60 + now.minute
|
||||
return r.windows.any { w ->
|
||||
if (w.startMin <= w.endMin) dow in w.days && minute >= w.startMin && minute < w.endMin
|
||||
else (dow in w.days && minute >= w.startMin) || (prev in w.days && minute < w.endMin)
|
||||
}
|
||||
}
|
||||
|
||||
private fun nextOpening(r: Rules, now: LocalDateTime): String {
|
||||
val minute = now.hour * 60 + now.minute
|
||||
for (offset in 0..7) {
|
||||
val dow = ((now.dayOfWeek.value - 1 + offset) % 7) + 1
|
||||
val start = r.windows.filter { dow in it.days && (offset > 0 || it.startMin > minute) }
|
||||
.minOfOrNull { it.startMin } ?: continue
|
||||
val label = "%02d:%02d".format(start / 60, start % 60)
|
||||
return if (offset == 0) "Reprise à $label." else "Reprise à $label (dans $offset j)."
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val MIN_MS = 60_000L
|
||||
const val MAX_DELTA_MS = 120_000L
|
||||
const val PERSIST_INTERVAL_MS = 30_000L
|
||||
/** Écart cumulé toléré entre heure système et temps monotone (resynchronisations NTP ordinaires). */
|
||||
const val CLOCK_JUMP_TOLERANCE_MS = 60_000L
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,7 @@ package com.jttools.datacontrol.guard
|
||||
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.time.LocalDateTime
|
||||
|
||||
/** Plage pendant laquelle l'appareil est utilisable. Minutes depuis minuit ; jours ISO (1 = lundi … 7 = dimanche). */
|
||||
data class TimeWindow(val days: Set<Int>, val startMin: Int, val endMin: Int)
|
||||
@@ -26,6 +27,30 @@ data class Rules(
|
||||
val isEmpty: Boolean
|
||||
get() = !scheduleEnabled && dailyLimitMin <= 0 && appLimits.isEmpty() && blocked.isEmpty()
|
||||
|
||||
/** Vrai si [now] tombe dans une plage autorisée (une plage qui passe minuit déborde sur le lendemain). */
|
||||
fun isOpenAt(now: LocalDateTime): Boolean {
|
||||
val dow = now.dayOfWeek.value
|
||||
val prev = if (dow == 1) 7 else dow - 1
|
||||
val minute = now.hour * 60 + now.minute
|
||||
return windows.any { w ->
|
||||
if (w.startMin <= w.endMin) dow in w.days && minute >= w.startMin && minute < w.endMin
|
||||
else (dow in w.days && minute >= w.startMin) || (prev in w.days && minute < w.endMin)
|
||||
}
|
||||
}
|
||||
|
||||
/** Heure de la prochaine ouverture, en texte (« Reprise à 08:00. »), ou "" s'il n'y en a pas. */
|
||||
fun nextOpeningText(now: LocalDateTime): String {
|
||||
val minute = now.hour * 60 + now.minute
|
||||
for (offset in 0..7) {
|
||||
val dow = ((now.dayOfWeek.value - 1 + offset) % 7) + 1
|
||||
val start = windows.filter { dow in it.days && (offset > 0 || it.startMin > minute) }
|
||||
.minOfOrNull { it.startMin } ?: continue
|
||||
val label = "%02d:%02d".format(start / 60, start % 60)
|
||||
return if (offset == 0) "Reprise à $label." else "Reprise à $label (dans $offset j)."
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
companion object {
|
||||
val NONE = Rules()
|
||||
|
||||
|
||||
@@ -2,9 +2,9 @@ package com.jttools.datacontrol.log
|
||||
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
import kotlinx.coroutines.flow.map
|
||||
import java.io.File
|
||||
import java.text.SimpleDateFormat
|
||||
import java.util.Date
|
||||
@@ -31,8 +31,9 @@ object AppLog {
|
||||
private val io = Executors.newSingleThreadExecutor()
|
||||
private val fmt = SimpleDateFormat("MM-dd HH:mm:ss", Locale.FRANCE)
|
||||
private val lines = ArrayDeque<Entry>()
|
||||
private val _entries = MutableStateFlow<List<String>>(emptyList())
|
||||
val entries: StateFlow<List<String>> = _entries.asStateFlow()
|
||||
/** Incrémenté à chaque changement : la liste n'est reconstruite que si l'onglet Journal l'observe. */
|
||||
private val version = MutableStateFlow(0L)
|
||||
val entries: Flow<List<String>> = version.map { synchronized(lines) { lines.map { it.text } } }
|
||||
|
||||
@Volatile private var file: File? = null
|
||||
private var prunedSinceCompact = 0
|
||||
@@ -65,8 +66,9 @@ object AppLog {
|
||||
private fun add(level: String, tag: String, message: String) {
|
||||
Log.println(when (level) { "E" -> Log.ERROR; "W" -> Log.WARN; else -> Log.INFO }, "DataControl/$tag", message)
|
||||
val now = System.currentTimeMillis()
|
||||
val entry = Entry(now, "${fmt.format(Date(now))} $level $tag: $message")
|
||||
synchronized(lines) {
|
||||
// SimpleDateFormat n'est pas sûr entre threads : formaté sous le verrou.
|
||||
val entry = Entry(now, "${fmt.format(Date(now))} $level $tag: $message")
|
||||
lines.addLast(entry)
|
||||
prune(now)
|
||||
publish()
|
||||
@@ -87,7 +89,7 @@ object AppLog {
|
||||
}
|
||||
|
||||
private fun publish() {
|
||||
_entries.value = lines.map { it.text }
|
||||
version.value++
|
||||
}
|
||||
|
||||
/** Réécrit le fichier avec les seules entrées conservées. À appeler sous verrou. */
|
||||
|
||||
@@ -9,30 +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,
|
||||
* état du pare-feu, historique de trafic. Ne fait rien tant que l'appareil n'est pas associé.
|
||||
* Envoie au serveur familyd l'état du téléphone : batterie, position, réseau, protections actives,
|
||||
* 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(
|
||||
@@ -40,26 +46,35 @@ 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 lastBatterySentAt = 0L
|
||||
private var lastLocationSentAt = 0L
|
||||
private var lastStateSignature = ""
|
||||
private var lastStateSentAt = 0L
|
||||
private var battery: JSONObject? = null
|
||||
private var location: JSONObject? = null
|
||||
private var lastSignature = ""
|
||||
private var lastSentAt = 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 || !remote.available) return
|
||||
if (started) return
|
||||
started = true
|
||||
remote.start(scope)
|
||||
|
||||
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.
|
||||
@@ -67,89 +82,89 @@ class DeviceReporter @Inject constructor(
|
||||
context, batteryReceiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED), ContextCompat.RECEIVER_NOT_EXPORTED
|
||||
)
|
||||
|
||||
// Application installée ou désinstallée : le parent doit voir la liste à jour pour choisir.
|
||||
val packageReceiver = object : BroadcastReceiver() {
|
||||
override fun onReceive(c: Context?, intent: Intent?) {
|
||||
if (intent?.getBooleanExtra(Intent.EXTRA_REPLACING, false) == true) return // simple mise à jour
|
||||
appsPushJob?.cancel()
|
||||
appsPushJob = scope.launch {
|
||||
delay(APPS_PUSH_DEBOUNCE_MS) // regroupe les installations en rafale
|
||||
if (settingsRepository.settingsFlow.first().isPaired) remote.pushApps()
|
||||
}
|
||||
}
|
||||
}
|
||||
ContextCompat.registerReceiver(
|
||||
context, packageReceiver,
|
||||
IntentFilter().apply {
|
||||
addAction(Intent.ACTION_PACKAGE_ADDED)
|
||||
addAction(Intent.ACTION_PACKAGE_REMOVED)
|
||||
addDataScheme("package")
|
||||
},
|
||||
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) {
|
||||
registerLocationUpdates(scope)
|
||||
pushState()
|
||||
pushTraffic()
|
||||
if (s.isPaired && tunnel.up.value) {
|
||||
registerLocationUpdates()
|
||||
pushState(force = false)
|
||||
pushUsage()
|
||||
if (!appsSent) appsSent = remote.pushApps()
|
||||
}
|
||||
delay(REPORT_INTERVAL_MS)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun pushBattery(intent: Intent) {
|
||||
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
|
||||
private suspend fun pushState(force: Boolean) {
|
||||
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(
|
||||
"controlEnabled" to s.controlEnabled,
|
||||
"transport" to snap.transport.name,
|
||||
"firewallFault" to snap.firewallFault,
|
||||
"vpnPrepared" to FirewallVpnService.isPrepared(context),
|
||||
"tunnelActive" to FirewallVpnService.tunnelActive,
|
||||
"adminActive" to AdminController.isActive(context),
|
||||
"guardEnabled" to guardEnabled,
|
||||
"rulesActive" to !guardEngine.rules.isEmpty,
|
||||
"consumedMo" to snap.consumedMo,
|
||||
"planLimitMo" to s.planLimitMo,
|
||||
"cutoffIntervalMinutes" to s.cutoffIntervalMinutes,
|
||||
"wifiFilterEnabled" to s.wifiFilterEnabled,
|
||||
"whitelistedPackages" to s.whitelistedPackages.sorted(),
|
||||
"whitelistedPackagesWifi" to s.whitelistedPackagesWifi.sorted(),
|
||||
"appliedConfigAt" to s.remoteConfigVersion,
|
||||
"appVersion" to BuildConfig.VERSION_NAME
|
||||
)
|
||||
val state = JSONObject()
|
||||
.put("transport", when (stateHolder.snapshot.value.transport) {
|
||||
NetworkTransport.CELLULAR -> "mobile"
|
||||
NetworkTransport.WIFI -> "wifi"
|
||||
else -> "none"
|
||||
})
|
||||
.put("app_version", BuildConfig.VERSION_NAME)
|
||||
.put("android", Build.VERSION.RELEASE)
|
||||
.put("guard_enabled", guardEnabled)
|
||||
.put("admin_active", AdminController.isActive(context))
|
||||
.put("device_owner", AdminController.isDeviceOwner(context))
|
||||
.put("always_on_vpn", com.jttools.datacontrol.admin.OwnerPolicy.alwaysOnState(context).let { (on, lock) ->
|
||||
JSONObject().put("enabled", on).put("lockdown", lock)
|
||||
})
|
||||
.put("auto_time", Settings.Global.getInt(context.contentResolver, Settings.Global.AUTO_TIME, 1) == 1)
|
||||
battery?.let { state.put("battery", it) }
|
||||
location?.let { state.put("location", it) }
|
||||
val signature = state.toString()
|
||||
val now = System.currentTimeMillis()
|
||||
// Évite les écritures inutiles ; un battement toutes les 5 min indique que l'appareil est vivant.
|
||||
if (signature == lastStateSignature && now - lastStateSentAt < HEARTBEAT_MS) return
|
||||
lastStateSignature = signature
|
||||
lastStateSentAt = now
|
||||
remote.pushDevice(mapOf("state" to (state + ("at" to now))))
|
||||
// Évite les envois inutiles ; un battement toutes les 5 min suffit quand rien ne change.
|
||||
if (!force && signature == lastSignature && now - lastSentAt < HEARTBEAT_MS) return
|
||||
if (remote.pushState(state)) {
|
||||
lastSignature = signature
|
||||
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
|
||||
remote.pushUsage(u.date, u.totalMs, u.appMs)
|
||||
if (remote.pushUsage(u.date, u.totalMs, u.appMs)) lastUsageSentTotal = u.totalMs
|
||||
}
|
||||
|
||||
@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
|
||||
@@ -157,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
|
||||
@@ -170,27 +185,20 @@ 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
|
||||
lastLocationSentAt = now
|
||||
remote.pushDevice(
|
||||
mapOf(
|
||||
"location" to mapOf(
|
||||
"lat" to loc.latitude, "lng" to loc.longitude,
|
||||
"accuracy" to loc.accuracy.toDouble(), "at" to now
|
||||
)
|
||||
)
|
||||
)
|
||||
if (now - lastLocationAt < LOCATION_MIN_SEND_MS) return
|
||||
lastLocationAt = now
|
||||
location = JSONObject().put("lat", loc.latitude).put("lng", loc.longitude)
|
||||
.put("accuracy", loc.accuracy.toDouble()).put("at", 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
|
||||
const val APPS_PUSH_DEBOUNCE_MS = 5_000L
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
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))
|
||||
}
|
||||
|
||||
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?): String {
|
||||
val conn = try {
|
||||
(URL(url).openConnection() as HttpURLConnection).apply {
|
||||
requestMethod = method
|
||||
connectTimeout = CONNECT_TIMEOUT_MS
|
||||
readTimeout = READ_TIMEOUT_MS
|
||||
setRequestProperty("Accept", "application/json")
|
||||
token?.let { setRequestProperty("Authorization", "Bearer $it") }
|
||||
if (body != null) {
|
||||
doOutput = true
|
||||
setRequestProperty("Content-Type", "application/json; charset=utf-8")
|
||||
}
|
||||
}
|
||||
} catch (e: IOException) {
|
||||
throw ApiException(0, "Serveur injoignable : ${e.message}")
|
||||
}
|
||||
try {
|
||||
if (body != null) conn.outputStream.use { it.write(body.toString().toByteArray(Charsets.UTF_8)) }
|
||||
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()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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) }
|
||||
}
|
||||
}
|
||||
@@ -1,51 +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 dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import kotlinx.coroutines.tasks.await
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
|
||||
/**
|
||||
* Accès à Firebase (Auth anonyme + Firestore) initialisé depuis `firebase.properties`
|
||||
* (voir build.gradle.kts), sans plugin google-services : si la config est absente,
|
||||
* [enabled] est faux et toutes les fonctions distantes restent inertes.
|
||||
*/
|
||||
@Singleton
|
||||
class FirebaseGateway @Inject constructor(
|
||||
@ApplicationContext private val context: Context
|
||||
) {
|
||||
val enabled: Boolean = BuildConfig.FIREBASE_API_KEY.isNotBlank() &&
|
||||
BuildConfig.FIREBASE_APP_ID.isNotBlank() &&
|
||||
BuildConfig.FIREBASE_PROJECT_ID.isNotBlank()
|
||||
|
||||
private val app: FirebaseApp? by lazy {
|
||||
if (!enabled) return@lazy null
|
||||
runCatching {
|
||||
FirebaseApp.getApps(context).firstOrNull()
|
||||
?: FirebaseApp.initializeApp(
|
||||
context,
|
||||
FirebaseOptions.Builder()
|
||||
.setApiKey(BuildConfig.FIREBASE_API_KEY)
|
||||
.setApplicationId(BuildConfig.FIREBASE_APP_ID)
|
||||
.setProjectId(BuildConfig.FIREBASE_PROJECT_ID)
|
||||
.build()
|
||||
)
|
||||
}.getOrNull()
|
||||
}
|
||||
|
||||
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 }.getOrNull()
|
||||
}
|
||||
}
|
||||
@@ -1,187 +1,157 @@
|
||||
package com.jttools.datacontrol.remote
|
||||
|
||||
import android.os.Build
|
||||
import android.util.Log
|
||||
import com.google.firebase.firestore.DocumentReference
|
||||
import com.google.firebase.firestore.SetOptions
|
||||
import com.jttools.datacontrol.data.AppSettings
|
||||
import com.jttools.datacontrol.BuildConfig
|
||||
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.ExperimentalCoroutinesApi
|
||||
import kotlinx.coroutines.flow.distinctUntilChanged
|
||||
import kotlinx.coroutines.flow.flatMapLatest
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.flow.flowOf
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.flow.callbackFlow
|
||||
import kotlinx.coroutines.channels.awaitClose
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.tasks.await
|
||||
import java.util.UUID
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import kotlinx.coroutines.withContext
|
||||
import kotlinx.coroutines.withTimeoutOrNull
|
||||
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) :
|
||||
* - pairings/{code} : créé par le parent, lu une fois par l'enfant
|
||||
* - families/{fid}/devices/{did} : état, batterie, position (écrit par l'appareil)
|
||||
* - 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é.
|
||||
* Tout passe par le tunnel WireGuard, sauf l'appairage (HTTPS public). Les évènements sont d'abord
|
||||
* enregistrés sur le téléphone, puis envoyés dès que le serveur répond : aucun ne se perd quand le
|
||||
* tunnel est coupé.
|
||||
*/
|
||||
@Singleton
|
||||
class RemoteSync @Inject constructor(
|
||||
private val gateway: FirebaseGateway,
|
||||
private val settingsRepository: SettingsRepository,
|
||||
private val installedApps: InstalledAppsRepository
|
||||
private val settings: SettingsRepository,
|
||||
private val installedApps: InstalledAppsRepository,
|
||||
private val tunnel: TunnelManager
|
||||
) {
|
||||
val available: Boolean get() = gateway.enabled
|
||||
private val flushLock = Mutex()
|
||||
private var started = false
|
||||
|
||||
private fun deviceDoc(s: AppSettings): DocumentReference? {
|
||||
val db = gateway.db ?: return null
|
||||
val fid = s.familyId ?: return null
|
||||
val did = s.deviceId ?: return null
|
||||
return db.collection("families").document(fid).collection("devices").document(did)
|
||||
private suspend fun api(): FamilyApi? {
|
||||
val link = settings.settingsFlow.first().link ?: return null
|
||||
val token = settings.deviceToken() ?: return null
|
||||
return FamilyApi(link.apiBase, token)
|
||||
}
|
||||
|
||||
/** Associe cet appareil à la famille correspondant au [code] affiché dans FamilyControl. */
|
||||
suspend fun pair(code: String, deviceName: String): Result<Unit> = runCatching {
|
||||
check(gateway.enabled) { "Firebase non configuré dans cette version" }
|
||||
val db = gateway.db!!
|
||||
val uid = gateway.ensureSignedIn() ?: error("Connexion Firebase impossible (réseau ?)")
|
||||
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()
|
||||
settingsRepository.setPairing(familyId, deviceId)
|
||||
}
|
||||
|
||||
suspend fun unpair() {
|
||||
val s = settingsRepository.settingsFlow.first()
|
||||
pushEvent("unpaired", "Appareil dissocié depuis DataControl")
|
||||
deviceDoc(s)?.let { runCatching { it.update("unpairedAt", System.currentTimeMillis()) } }
|
||||
settingsRepository.setPairing(null, null)
|
||||
}
|
||||
|
||||
/** Écoute les consignes du parent et les applique aux réglages locaux. */
|
||||
@OptIn(ExperimentalCoroutinesApi::class)
|
||||
fun start(scope: CoroutineScope) {
|
||||
if (!gateway.enabled) return
|
||||
scope.launch {
|
||||
settingsRepository.settingsFlow
|
||||
.map { it.familyId to it.deviceId }
|
||||
.distinctUntilChanged()
|
||||
.flatMapLatest { (fid, did) ->
|
||||
if (fid == null || did == null) flowOf(null) else configFlow(fid, did)
|
||||
}
|
||||
.collect { cfg -> if (cfg != null) apply(cfg) }
|
||||
}
|
||||
scope.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()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class Config(val map: Map<String, Any?>)
|
||||
|
||||
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() }
|
||||
)
|
||||
}
|
||||
|
||||
private 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
|
||||
/** 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) {
|
||||
runCatching {
|
||||
ref.collection("events").add(
|
||||
mapOf("type" to type, "detail" to detail, "at" to System.currentTimeMillis())
|
||||
val (privateKey, publicKey) = TunnelManager.newKeyPair()
|
||||
val raw = FamilyApi.pair(
|
||||
input.serverUrl, input.code, publicKey, deviceName.trim().ifBlank { Build.MODEL },
|
||||
"${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?>) {
|
||||
if (gateway.ensureSignedIn() == null) return
|
||||
// Les écritures sont mises en file par le SDK hors-ligne : pas d'attente bloquante du réseau.
|
||||
ref.set(data, SetOptions.merge())
|
||||
/** Récupère la consigne en cours et vide la file des évènements. Faux si le serveur est injoignable. */
|
||||
suspend fun syncOnce(): Boolean = withContext(Dispatchers.IO) {
|
||||
if (!tunnel.up.value) return@withContext false
|
||||
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")
|
||||
if (version != current.policyVersion || mode != current.serverMode || reason != current.serverModeReason) {
|
||||
val rules = p.optJSONObject("app_rules")?.takeIf { it.length() > 0 }?.toString()
|
||||
settings.applyServerPolicy(version, mode, reason, rules)
|
||||
if (mode != current.serverMode) AppLog.i("Liaison", "Mode réseau : $mode${if (reason.isNotBlank()) " ($reason)" else ""}")
|
||||
}
|
||||
flushEvents()
|
||||
true
|
||||
}
|
||||
|
||||
companion object { private const val TAG = "RemoteSync" }
|
||||
/** Enregistre l'évènement puis tente de l'envoyer (8 s au plus : appelable depuis un récepteur goAsync). */
|
||||
suspend fun pushEvent(type: String, detail: String) {
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -1,9 +1,17 @@
|
||||
package com.jttools.datacontrol.service
|
||||
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import androidx.core.app.NotificationCompat
|
||||
import androidx.work.CoroutineWorker
|
||||
import androidx.work.WorkerParameters
|
||||
import com.jttools.datacontrol.MainActivity
|
||||
import com.jttools.datacontrol.R
|
||||
import com.jttools.datacontrol.data.SettingsRepository
|
||||
import com.jttools.datacontrol.remote.RemoteSync
|
||||
import dagger.hilt.EntryPoint
|
||||
import dagger.hilt.InstallIn
|
||||
import dagger.hilt.android.EntryPointAccessors
|
||||
@@ -16,6 +24,10 @@ import kotlinx.coroutines.flow.first
|
||||
* (voir [BootReceiver]) ne suffisent pas toujours sur les ROM qui tuent agressivement les apps en
|
||||
* arrière-plan (ex: ColorOS) sans exemption d'optimisation batterie. Démarrer un service déjà en
|
||||
* cours d'exécution est sans effet, cet appel est donc sûr à répéter à chaque déclenchement.
|
||||
*
|
||||
* Sur Android 12+, ce démarrage depuis l'arrière-plan est refusé si l'application n'est pas exemptée
|
||||
* d'optimisation de la batterie : on affiche alors une notification pour rouvrir l'application, et
|
||||
* le parent est prévenu.
|
||||
*/
|
||||
class DataMonitorRestartWorker(
|
||||
context: Context,
|
||||
@@ -26,17 +38,47 @@ class DataMonitorRestartWorker(
|
||||
@InstallIn(SingletonComponent::class)
|
||||
interface RestartWorkerEntryPoint {
|
||||
fun settingsRepository(): SettingsRepository
|
||||
fun remoteSync(): RemoteSync
|
||||
}
|
||||
|
||||
override suspend fun doWork(): Result {
|
||||
val appContext = applicationContext
|
||||
val entryPoint = EntryPointAccessors.fromApplication(appContext, RestartWorkerEntryPoint::class.java)
|
||||
val enabled = entryPoint.settingsRepository().settingsFlow.first().controlEnabled
|
||||
if (enabled) DataMonitorService.start(appContext)
|
||||
if (enabled && !DataMonitorService.start(appContext)) {
|
||||
notifyRestartNeeded(appContext)
|
||||
entryPoint.remoteSync().pushEvent(
|
||||
"service_stopped",
|
||||
"Surveillance arrêtée par le système et non relançable en arrière-plan (optimisation de la batterie active)"
|
||||
)
|
||||
}
|
||||
return Result.success()
|
||||
}
|
||||
|
||||
private fun notifyRestartNeeded(context: Context) {
|
||||
val nm = context.getSystemService(NotificationManager::class.java)
|
||||
nm.createNotificationChannel(
|
||||
NotificationChannel(ALERT_CHANNEL_ID, "Alertes DataControl", NotificationManager.IMPORTANCE_HIGH)
|
||||
)
|
||||
val open = PendingIntent.getActivity(
|
||||
context, 0, Intent(context, MainActivity::class.java), PendingIntent.FLAG_IMMUTABLE
|
||||
)
|
||||
nm.notify(
|
||||
ALERT_NOTIF_ID,
|
||||
NotificationCompat.Builder(context, ALERT_CHANNEL_ID)
|
||||
.setSmallIcon(R.drawable.ic_notification)
|
||||
.setContentTitle("DataControl est arrêté")
|
||||
.setContentText("Touchez pour relancer la surveillance.")
|
||||
.setContentIntent(open)
|
||||
.setAutoCancel(true)
|
||||
.setPriority(NotificationCompat.PRIORITY_HIGH)
|
||||
.build()
|
||||
)
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val WORK_NAME = "data_monitor_restart_watchdog"
|
||||
private const val ALERT_CHANNEL_ID = "datacontrol_alerts"
|
||||
private const val ALERT_NOTIF_ID = 3001
|
||||
}
|
||||
}
|
||||
@@ -4,18 +4,17 @@ 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.Build
|
||||
import android.os.SystemClock
|
||||
import androidx.core.app.NotificationCompat
|
||||
import androidx.core.content.ContextCompat
|
||||
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,10 @@ 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.isActive
|
||||
import kotlinx.coroutines.launch
|
||||
import java.time.LocalDate
|
||||
@@ -32,15 +34,12 @@ import javax.inject.Inject
|
||||
import kotlin.math.max
|
||||
|
||||
/**
|
||||
* Service de premier plan qui surveille en continu la consommation de données mobiles,
|
||||
* pilote le pare-feu [FirewallVpnService] et met à jour la notification permanente.
|
||||
* Service de premier plan : garde le tunnel WireGuard vers le serveur familyd monté tant que le
|
||||
* 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) :
|
||||
* - Sur Wi-Fi : aucun filtrage par défaut (le pare-feu est arrêté), sauf si le filtrage Wi-Fi
|
||||
* 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.
|
||||
* Si le tunnel tombe (VPN retiré, autre VPN, réseau), le contrôle reste ACTIVÉ : la notification
|
||||
* passe en rouge, le parent est prévenu, et le tunnel est remonté dès que possible.
|
||||
*/
|
||||
@AndroidEntryPoint
|
||||
class DataMonitorService : LifecycleService() {
|
||||
@@ -52,72 +51,56 @@ class DataMonitorService : LifecycleService() {
|
||||
@Inject lateinit var deviceReporter: DeviceReporter
|
||||
@Inject lateinit var remoteSync: RemoteSync
|
||||
@Inject lateinit var guardEngine: GuardEngine
|
||||
@Inject lateinit var tunnel: TunnelManager
|
||||
|
||||
private var latestSettings: AppSettings = AppSettings()
|
||||
private var latestTransport: NetworkTransport = NetworkTransport.NONE
|
||||
private var vpnRevoked = 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 = ""
|
||||
|
||||
private val vpnRevokedReceiver = object : BroadcastReceiver() {
|
||||
override fun onReceive(context: Context?, intent: Intent?) {
|
||||
vpnRevoked = true
|
||||
lifecycleScope.launch {
|
||||
settingsRepository.setControlEnabled(false)
|
||||
remoteSync.pushEvent("vpn_revoked", "Autorisation VPN retirée : le filtrage est désactivé")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private enum class VpnMode { FILTER, BLOCK_ALL, STOPPED }
|
||||
/** Dernière poignée de main récente avec le serveur (temps monotone), pour le garde-fou du mode propriétaire. */
|
||||
private var serverSeenAt = SystemClock.elapsedRealtime()
|
||||
private var lockdownRelaxed = false
|
||||
private var lastProvisionAttempt = 0L
|
||||
private var provisionJob: Job? = null
|
||||
|
||||
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
|
||||
// automatiquement (avec un Intent null) dès que les ressources redeviennent disponibles.
|
||||
// START_STICKY : si le système tue ce service, il le relance dès que possible (Intent null).
|
||||
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) vpnRevoked = false
|
||||
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()
|
||||
}
|
||||
}
|
||||
@@ -132,7 +115,7 @@ class DataMonitorService : LifecycleService() {
|
||||
lifecycleScope.launch {
|
||||
while (isActive) {
|
||||
tick()
|
||||
kotlinx.coroutines.delay(TICK_INTERVAL_MS)
|
||||
delay(TICK_INTERVAL_MS)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -140,9 +123,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é
|
||||
// (ex: pour refléter immédiatement une valeur définie manuellement dans Réglages), il ne
|
||||
// doit donc pas dépendre de settings.controlEnabled.
|
||||
// Consommation de données mobiles (compteur local, pour le tableau de bord et le forfait affiché).
|
||||
val consumedBytes = usageRepository.consumedBytesSince(settings.baselineMobileBytesAtReset)
|
||||
if (usageRepository.hasCounterReset(settings.baselineMobileBytesAtReset)) {
|
||||
lifecycleScope.launch { settingsRepository.rebaseline(usageRepository.totalMobileBytes()) }
|
||||
@@ -151,97 +132,36 @@ 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.controlEnabled) {
|
||||
applyVpnMode(VpnMode.STOPPED, emptySet())
|
||||
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
|
||||
)
|
||||
if (settings.autoResetEnabled && !LocalDate.now().isBefore(settings.nextAutoResetDate())) {
|
||||
lifecycleScope.launch {
|
||||
settingsRepository.resetPlan(usageRepository.totalMobileBytes(), settings.nextAutoResetDate())
|
||||
}
|
||||
updateNotification(stateHolder.snapshot.value)
|
||||
return
|
||||
}
|
||||
|
||||
maybeAutoReset(settings)
|
||||
|
||||
val dataState: DataState
|
||||
var nextCutoffAt: Long? = null
|
||||
var firewallFault = false
|
||||
if (!settings.isPaired) maybeProvisionPairing()
|
||||
|
||||
// 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 -> {
|
||||
if (settings.wifiFilterEnabled && FirewallVpnService.isPrepared(this)) {
|
||||
applyVpnMode(VpnMode.FILTER, settings.whitelistedPackagesWifi)
|
||||
} else {
|
||||
applyVpnMode(VpnMode.STOPPED, emptySet())
|
||||
wanted && !up -> maybeBringUp(settings)
|
||||
!wanted && up && tunnelJob?.isActive != true -> {
|
||||
tunnelJob = lifecycleScope.launch { tunnel.down() }
|
||||
}
|
||||
resetCutoffCycle()
|
||||
dataState = DataState.WIFI
|
||||
}
|
||||
latestTransport == NetworkTransport.CELLULAR && !vpnRevoked && FirewallVpnService.isPrepared(this) -> {
|
||||
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!!
|
||||
val fault = wanted && !up
|
||||
|
||||
if (inPulse) {
|
||||
if (now - pulseStartMillis >= PULSE_DURATION_MS) {
|
||||
inPulse = false
|
||||
cutoffCycleAnchorMillis = now
|
||||
persistCutoffState()
|
||||
applyVpnMode(VpnMode.FILTER, settings.whitelistedPackages)
|
||||
} else {
|
||||
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
|
||||
}
|
||||
val dataState = when {
|
||||
!settings.controlEnabled -> if (percent >= WARNING_THRESHOLD) DataState.WARNING else DataState.OK
|
||||
settings.serverMode != "open" -> DataState.CUT
|
||||
latestTransport == NetworkTransport.WIFI -> DataState.WIFI
|
||||
percent >= WARNING_THRESHOLD -> DataState.WARNING
|
||||
else -> DataState.OK
|
||||
}
|
||||
|
||||
logDiagnostic(settings)
|
||||
|
||||
logDiagnostic(settings, up)
|
||||
stateHolder.update {
|
||||
it.copy(
|
||||
consumedMo = consumedMo,
|
||||
@@ -250,117 +170,141 @@ class DataMonitorService : LifecycleService() {
|
||||
estimatedTotalPriceEuro = estimatedTotal,
|
||||
dataState = dataState,
|
||||
nextAutoResetDate = settings.nextAutoResetDate(),
|
||||
nextCutoffAtMillis = nextCutoffAt,
|
||||
serviceRunning = true,
|
||||
firewallFault = firewallFault,
|
||||
transport = latestTransport
|
||||
serviceRunning = settings.controlEnabled,
|
||||
firewallFault = fault,
|
||||
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) {
|
||||
val prepared = FirewallVpnService.isPrepared(this)
|
||||
/**
|
||||
* Appairage prévu par le QR de provisionnement : tenté toutes les minutes jusqu'à réussite ; la
|
||||
* 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))
|
||||
}
|
||||
|
||||
/** 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 ->
|
||||
if (settings.wifiFilterEnabled && prepared) "Wi-Fi filtré" else "Wi-Fi : pas de filtrage (normal, le VPN ne se monte que sur données mobiles)"
|
||||
latestTransport == NetworkTransport.CELLULAR ->
|
||||
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})"
|
||||
!prepared -> "autorisation VPN absente"
|
||||
up -> "tunnel monté, filtrage par le serveur (mode ${settings.serverMode})"
|
||||
else -> "tunnel attendu mais non monté${tunnel.lastError?.let { " : $it" } ?: ""}"
|
||||
}
|
||||
val guard = com.jttools.datacontrol.guard.AppGuardService.isEnabled(this)
|
||||
val diag = "réseau=$latestTransport contrôle=${settings.controlEnabled} vpnAutorisé=$prepared " +
|
||||
"tunnelMonté=${FirewallVpnService.tunnelActive} accessibilité=$guard révoqué=$vpnRevoked " +
|
||||
"mode=${lastAppliedMode ?: "—"} → $expected"
|
||||
val diag = "réseau=$latestTransport contrôle=${settings.controlEnabled} associé=${settings.isPaired} " +
|
||||
"vpnAutorisé=$prepared tunnel=$up accessibilité=$guard → $expected"
|
||||
if (diag != lastDiagnostic) {
|
||||
lastDiagnostic = diag
|
||||
AppLog.i("Pare-feu", 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)
|
||||
AppLog.i("Tunnel", diag)
|
||||
}
|
||||
}
|
||||
|
||||
private fun buildNotification(snapshot: MonitorSnapshot): Notification {
|
||||
val nm = getSystemService(NotificationManager::class.java)
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
||||
val channel = NotificationChannel(
|
||||
CHANNEL_ID,
|
||||
getString(R.string.notification_channel_name),
|
||||
NotificationManager.IMPORTANCE_LOW
|
||||
).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)
|
||||
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"))
|
||||
else -> Triple("🔵", getString(R.string.dashboard_state_wifi), Color.parseColor("#1565C0"))
|
||||
snapshot.dataState == DataState.WIFI -> 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) {
|
||||
"${(snapshot.consumedMo * 100 / snapshot.planLimitMo)}%"
|
||||
} else "—"
|
||||
val priceText = String.format("%.2f", snapshot.estimatedTotalPriceEuro)
|
||||
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 = "$warn$emoji $stateLabel · ${snapshot.consumedMo}/${snapshot.planLimitMo} Mo ($percentText)"
|
||||
val usageText = "$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
|
||||
@@ -385,21 +329,26 @@ 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_DELAY_MS = 5_000L
|
||||
private const val TUNNEL_RETRY_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
|
||||
|
||||
fun start(context: Context) {
|
||||
/**
|
||||
* Démarre le service. Renvoie faux si Android refuse (Android 12+ interdit de démarrer un service
|
||||
* de premier plan depuis l'arrière-plan sans exemption d'optimisation de la batterie).
|
||||
*/
|
||||
fun start(context: Context): Boolean = try {
|
||||
ContextCompat.startForegroundService(context, Intent(context, DataMonitorService::class.java))
|
||||
true
|
||||
} catch (e: Exception) {
|
||||
AppLog.e("Service", "Démarrage de DataMonitorService refusé par le système", e)
|
||||
false
|
||||
}
|
||||
|
||||
fun stop(context: Context) {
|
||||
|
||||
@@ -1,199 +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.Build
|
||||
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)
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -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 appliedMode: String = "STOPPED",
|
||||
val effectiveWhitelist: Set<String> = emptySet()
|
||||
val paired: Boolean = false,
|
||||
val tunnelUp: Boolean = false,
|
||||
/** 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
|
||||
)
|
||||
|
||||
/**
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
* 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.
|
||||
* Contenu des sous-onglets de « À propos ». Chaque affirmation doit se vérifier dans le code, le README
|
||||
* 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,104 +11,104 @@ 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("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("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é.")
|
||||
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.")
|
||||
)),
|
||||
AboutSection("Protection", listOf(
|
||||
AboutEntry("Mot de passe de verrouillage", "Protège l'accès aux Réglages et la désactivation du contrôle."),
|
||||
AboutSection("Sur le téléphone", listOf(
|
||||
AboutEntry("Mot de passe de verrouillage", "Protège les Réglages, l'effacement du journal et la désactivation de la protection."),
|
||||
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("Mise à jour intégrée", "Recherche et installation de la dernière version publiée, depuis l'onglet Journal de cette page.")
|
||||
)),
|
||||
AboutSection("Contrôle parental (avec FamilyControl)", listOf(
|
||||
AboutEntry("Appairage par code", "L'appareil s'associe à l'application parent FamilyControl avec un code d'appairage."),
|
||||
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("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 n'existent que si l'application a été compilée avec une configuration Firebase et associée à un compte parent.")
|
||||
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("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.")
|
||||
))
|
||||
)
|
||||
|
||||
val howTo = listOf(
|
||||
"Ouvrez « Réglages » et renseignez le forfait : volume (Mo), prix, prix par Mo hors-forfait, intervalle de coupure. Touchez « Enregistrer ».",
|
||||
"Ouvrez « Liste blanche » et cochez les applications qui doivent garder Internet en données mobiles.",
|
||||
"Dans « Réglages » → « Autorisations », accordez « Pare-feu local (VPN) », « Notifications » et « Optimisation de la batterie ».",
|
||||
"Sur le « Tableau de bord », activez « Activer le contrôle » et acceptez la demande VPN d'Android.",
|
||||
"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é »."
|
||||
"Sur l'espace parents (family.tuxtech.fr), touchez « Associer un téléphone » : un code de 8 caractères s'affiche pendant 10 minutes.",
|
||||
"Dans DataControl, ouvrez « Réglages » → « Contrôle parental », saisissez le code et touchez « Associer ».",
|
||||
"Sur le « Tableau de bord », activez la protection et acceptez la demande VPN d'Android : l'icône clé apparaît.",
|
||||
"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.",
|
||||
"Recommandé : définissez un mot de passe dans « Réglages » → « Sécurité », puis activez la protection anti-désinstallation."
|
||||
)
|
||||
|
||||
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("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("Changer une application autorisée", "Onglet « Liste blanche » : onglets « Données mobiles » et « Wi-Fi », recherche et sélection multiple.")
|
||||
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("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("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("« PARE-FEU INACTIF » dans la notification", "Les données mobiles ne sont pas filtrées : autorisation VPN retirée ou tunnel non monté. Réactivez le contrôle et lisez le Journal."),
|
||||
AboutEntry("Le contrôle s'est désactivé tout seul", "Un seul VPN peut être actif sous Android : si un autre VPN prend la main, DataControl est révoqué et se désactive."),
|
||||
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("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("« 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("Un seul VPN à la fois", "Le pare-feu est incompatible avec un autre VPN actif en même temps.")
|
||||
AboutEntry("Ni root, ni Shizuku", "Le tunnel repose sur le VPN standard d'Android."),
|
||||
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("Contrôle parental (facultatif)", "Position (avec « Toujours autoriser » pour l'arrière-plan), administrateur de l'appareil, service d'accessibilité.")
|
||||
AboutEntry("Liste des applications", "Permission QUERY_ALL_PACKAGES, pour que le parent choisisse les applications à limiter."),
|
||||
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(
|
||||
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("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("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("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.")
|
||||
AboutSection("Tunnel", listOf(
|
||||
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("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("Tout le trafic, IPv4 et IPv6", "Le tunnel couvre 0.0.0.0/0 et ::/0 : aucune application ne le contourne en IPv6."),
|
||||
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é en SHA-256 avec un sel aléatoire de 16 octets (SecureRandom), jamais stocké en clair. Limite : un hachage simple, sans étirement de type bcrypt ou Argon2."),
|
||||
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.")
|
||||
)),
|
||||
AboutSection("Liaison FamilyControl", listOf(
|
||||
AboutEntry("Appairage", "Code aléatoire à 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("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 ; le parent en est alerté."),
|
||||
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("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("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 ; 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(
|
||||
AboutEntry("Contenu des écrans et messages", "Le service d'accessibilité ne lit pas le contenu des fenêtres."),
|
||||
AboutEntry("Contenu du trafic", "Le VPN ne route rien et n'inspecte aucun paquet.")
|
||||
AboutSection("Ce que voit le serveur", listOf(
|
||||
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("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.")
|
||||
)),
|
||||
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."),
|
||||
@@ -117,15 +117,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("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("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("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("Firebase sans plugin google-services", "Firestore et l'authentification sont initialisés depuis un fichier local non versionné (firebase.properties). Sans lui, l'application se compile normalement et le contrôle à distance est simplement désactivé."),
|
||||
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("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.")
|
||||
)
|
||||
|
||||
|
||||
@@ -35,14 +35,18 @@ import kotlinx.coroutines.launch
|
||||
|
||||
/**
|
||||
* Verrouille [content] derrière une saisie de mot de passe tant que [passwordSet] est vrai.
|
||||
* [passwordSet] null = réglages pas encore chargés : rien n'est affiché (sinon l'écran protégé
|
||||
* apparaîtrait le temps d'une image avant le verrou).
|
||||
* [verify] renvoie null si le mot de passe est bon, sinon le message d'erreur.
|
||||
* Le déverrouillage n'est valable que pour la composition courante (redemandé à chaque visite de l'écran).
|
||||
*/
|
||||
@Composable
|
||||
fun PasswordGate(
|
||||
passwordSet: Boolean,
|
||||
verify: suspend (String) -> Boolean,
|
||||
passwordSet: Boolean?,
|
||||
verify: suspend (String) -> String?,
|
||||
content: @Composable () -> Unit
|
||||
) {
|
||||
if (passwordSet == null) return
|
||||
var unlocked by remember(passwordSet) { mutableStateOf(!passwordSet) }
|
||||
if (unlocked) {
|
||||
content()
|
||||
@@ -50,7 +54,8 @@ fun PasswordGate(
|
||||
}
|
||||
|
||||
var password by remember { mutableStateOf("") }
|
||||
var error by remember { mutableStateOf(false) }
|
||||
var error by remember { mutableStateOf<String?>(null) }
|
||||
var busy by remember { mutableStateOf(false) }
|
||||
val scope = rememberCoroutineScope()
|
||||
|
||||
Column(
|
||||
@@ -64,31 +69,27 @@ fun PasswordGate(
|
||||
Spacer(Modifier.height(16.dp))
|
||||
OutlinedTextField(
|
||||
value = password,
|
||||
onValueChange = { password = it; error = false },
|
||||
onValueChange = { password = it; error = null },
|
||||
label = { Text(stringResource(R.string.password_field_label)) },
|
||||
visualTransformation = PasswordVisualTransformation(),
|
||||
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password),
|
||||
isError = error,
|
||||
isError = error != null,
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth()
|
||||
)
|
||||
if (error) {
|
||||
error?.let {
|
||||
Spacer(Modifier.height(4.dp))
|
||||
Text(
|
||||
stringResource(R.string.password_incorrect),
|
||||
color = MaterialTheme.colorScheme.error,
|
||||
style = MaterialTheme.typography.bodySmall
|
||||
)
|
||||
Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
|
||||
}
|
||||
Spacer(Modifier.height(16.dp))
|
||||
Button(
|
||||
enabled = !busy,
|
||||
onClick = {
|
||||
busy = true
|
||||
scope.launch {
|
||||
if (verify(password)) {
|
||||
unlocked = true
|
||||
} else {
|
||||
error = true
|
||||
}
|
||||
val result = verify(password)
|
||||
busy = false
|
||||
if (result == null) unlocked = true else error = result
|
||||
}
|
||||
},
|
||||
modifier = Modifier.fillMaxWidth()
|
||||
@@ -100,7 +101,7 @@ fun PasswordGate(
|
||||
@Composable
|
||||
fun PasswordPromptDialog(
|
||||
title: String,
|
||||
error: Boolean,
|
||||
error: String?,
|
||||
onDismiss: () -> Unit,
|
||||
onConfirm: (String) -> Unit
|
||||
) {
|
||||
@@ -117,17 +118,13 @@ fun PasswordPromptDialog(
|
||||
label = { Text(stringResource(R.string.password_field_label)) },
|
||||
visualTransformation = PasswordVisualTransformation(),
|
||||
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password),
|
||||
isError = error,
|
||||
isError = error != null,
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth()
|
||||
)
|
||||
if (error) {
|
||||
error?.let {
|
||||
Spacer(Modifier.height(4.dp))
|
||||
Text(
|
||||
stringResource(R.string.password_incorrect),
|
||||
color = MaterialTheme.colorScheme.error,
|
||||
style = MaterialTheme.typography.bodySmall
|
||||
)
|
||||
Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
@@ -56,9 +56,10 @@ fun DashboardScreen(systemActions: SystemActions) {
|
||||
val viewModel: DashboardViewModel = hiltViewModel()
|
||||
val settings by viewModel.settings.collectAsStateWithLifecycle()
|
||||
val snapshot by viewModel.snapshot.collectAsStateWithLifecycle()
|
||||
val passwordSet by viewModel.passwordSet.collectAsStateWithLifecycle()
|
||||
var showResetDialog by remember { mutableStateOf(false) }
|
||||
var showDisablePasswordDialog by remember { mutableStateOf(false) }
|
||||
var disablePasswordError by remember { mutableStateOf(false) }
|
||||
var disablePasswordError by remember { mutableStateOf<String?>(null) }
|
||||
val scope = rememberCoroutineScope()
|
||||
|
||||
val stateColor = when {
|
||||
@@ -69,10 +70,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)
|
||||
}
|
||||
|
||||
@@ -160,7 +163,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"}")
|
||||
@@ -170,9 +175,9 @@ fun DashboardScreen(systemActions: SystemActions) {
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (settings.hasPassword) {
|
||||
disablePasswordError = false
|
||||
} else if (passwordSet != null) { // null : réglages pas encore chargés
|
||||
if (passwordSet == true) {
|
||||
disablePasswordError = null
|
||||
showDisablePasswordDialog = true
|
||||
} else {
|
||||
viewModel.setControlEnabled(false)
|
||||
@@ -191,24 +196,29 @@ 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)
|
||||
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.dataState == DataState.CUT -> stringResource(R.string.dashboard_cutoff_in_progress)
|
||||
snapshot.nextCutoffAtMillis != null -> {
|
||||
val remainingMs = (snapshot.nextCutoffAtMillis!! - System.currentTimeMillis()).coerceAtLeast(0L)
|
||||
stringResource(
|
||||
R.string.dashboard_cutoff_countdown,
|
||||
remainingMs / 60_000,
|
||||
(remainingMs / 1000) % 60
|
||||
)
|
||||
}
|
||||
else -> stringResource(R.string.dashboard_cutoff_unavailable)
|
||||
snapshot.tunnelUp -> stringResource(R.string.dashboard_tunnel_up) +
|
||||
(snapshot.lastHandshakeMs?.let { " · " + DateTimeFormatter.ofPattern("HH:mm:ss")
|
||||
.format(java.time.Instant.ofEpochMilli(it).atZone(java.time.ZoneId.systemDefault())) } ?: "")
|
||||
else -> stringResource(R.string.dashboard_tunnel_down) + (snapshot.tunnelError?.let { " ($it)" } ?: "")
|
||||
}
|
||||
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))
|
||||
@@ -243,11 +253,12 @@ fun DashboardScreen(systemActions: SystemActions) {
|
||||
onDismiss = { showDisablePasswordDialog = false },
|
||||
onConfirm = { password ->
|
||||
scope.launch {
|
||||
if (viewModel.verifyPassword(password)) {
|
||||
val error = viewModel.checkPassword(password)
|
||||
if (error == null) {
|
||||
viewModel.setControlEnabled(false)
|
||||
showDisablePasswordDialog = false
|
||||
} else {
|
||||
disablePasswordError = true
|
||||
disablePasswordError = error
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,6 +10,8 @@ import dagger.hilt.android.lifecycle.HiltViewModel
|
||||
import kotlinx.coroutines.flow.SharingStarted
|
||||
import kotlinx.coroutines.flow.stateIn
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.map
|
||||
import javax.inject.Inject
|
||||
|
||||
@HiltViewModel
|
||||
@@ -33,5 +35,10 @@ class DashboardViewModel @Inject constructor(
|
||||
viewModelScope.launch { settingsRepository.resetPlan(usageRepository.totalMobileBytes()) }
|
||||
}
|
||||
|
||||
suspend fun verifyPassword(password: String): Boolean = settingsRepository.verifyPassword(password)
|
||||
/** 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)
|
||||
}
|
||||
@@ -32,11 +32,12 @@ 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.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()
|
||||
@@ -54,10 +55,15 @@ fun FamilySection(systemActions: SystemActions) {
|
||||
// Action sensible en attente de confirmation par mot de passe : "admin" ou "unpair".
|
||||
var pendingAction by remember { mutableStateOf<String?>(null) }
|
||||
var pwd by remember { mutableStateOf("") }
|
||||
var pwdError by remember { mutableStateOf(false) }
|
||||
var pwdError by remember { mutableStateOf<String?>(null) }
|
||||
|
||||
// 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()
|
||||
@@ -65,13 +71,18 @@ fun FamilySection(systemActions: SystemActions) {
|
||||
}
|
||||
|
||||
fun runProtected(action: String, block: () -> Unit) {
|
||||
if (settings.hasPassword) { pendingAction = action; pwd = ""; pwdError = false } else block()
|
||||
if (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()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -83,38 +94,70 @@ fun FamilySection(systemActions: SystemActions) {
|
||||
)
|
||||
HorizontalDivider()
|
||||
|
||||
// --- Appairage ---
|
||||
when {
|
||||
!vm.remoteAvailable -> Text(
|
||||
stringResource(R.string.family_unavailable),
|
||||
style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant
|
||||
// --- Liaison avec le serveur familyd ---
|
||||
val link = settings.link
|
||||
if (link != null) {
|
||||
Text(
|
||||
stringResource(R.string.family_paired, link.serverUrl.removePrefix("https://"), link.tunnelIp),
|
||||
color = StateOk, style = MaterialTheme.typography.bodyMedium
|
||||
)
|
||||
Text(
|
||||
"${stringResource(R.string.family_device_name)} : ${link.name}",
|
||||
style = MaterialTheme.typography.bodySmall, 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) },
|
||||
label = { Text(stringResource(R.string.family_code)) },
|
||||
value = code, onValueChange = { code = it.take(300) },
|
||||
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()
|
||||
@@ -126,7 +169,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))
|
||||
}
|
||||
@@ -191,22 +236,23 @@ fun FamilySection(systemActions: SystemActions) {
|
||||
text = {
|
||||
Column {
|
||||
OutlinedTextField(
|
||||
value = pwd, onValueChange = { pwd = it; pwdError = false },
|
||||
value = pwd, onValueChange = { pwd = it; pwdError = null },
|
||||
label = { Text(stringResource(R.string.password_field_label)) },
|
||||
visualTransformation = PasswordVisualTransformation(),
|
||||
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password),
|
||||
isError = pwdError, singleLine = true, modifier = Modifier.fillMaxWidth()
|
||||
isError = pwdError != null, singleLine = true, modifier = Modifier.fillMaxWidth()
|
||||
)
|
||||
if (pwdError) Text(
|
||||
stringResource(R.string.password_incorrect),
|
||||
pwdError?.let { Text(
|
||||
it,
|
||||
color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall
|
||||
)
|
||||
) }
|
||||
}
|
||||
},
|
||||
confirmButton = {
|
||||
Button(onClick = {
|
||||
scope.launch {
|
||||
if (vm.verifyPassword(pwd)) { pendingAction = null; execute(action) } else pwdError = true
|
||||
val err = vm.checkPassword(pwd)
|
||||
if (err == null) { pendingAction = null; execute(action) } else pwdError = err
|
||||
}
|
||||
}) { Text(stringResource(R.string.common_confirm)) }
|
||||
},
|
||||
|
||||
@@ -4,17 +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.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 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(
|
||||
@@ -26,22 +28,39 @@ class FamilyViewModel @Inject constructor(
|
||||
viewModelScope, SharingStarted.WhileSubscribed(5_000), AppSettings()
|
||||
)
|
||||
|
||||
val remoteAvailable: Boolean get() = remoteSync.available
|
||||
/** 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(code: String, deviceName: String) {
|
||||
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(code, deviceName)
|
||||
_pairing.value = PairingUiState(error = result.exceptionOrNull()?.message)
|
||||
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.unpair() }
|
||||
viewModelScope.launch { remoteSync.forget() }
|
||||
}
|
||||
|
||||
suspend fun verifyPassword(password: String): Boolean = settingsRepository.verifyPassword(password)
|
||||
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)
|
||||
}
|
||||
@@ -32,18 +32,27 @@ 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
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.launch
|
||||
|
||||
@Composable
|
||||
fun JournalScreen() {
|
||||
val context = LocalContext.current
|
||||
val entries by AppLog.entries.collectAsStateWithLifecycle()
|
||||
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)) {
|
||||
@@ -61,7 +70,12 @@ fun JournalScreen() {
|
||||
.putExtra(Intent.EXTRA_TEXT, live + "\n\n" + AppLog.asText())
|
||||
context.startActivity(Intent.createChooser(send, "Partager le journal").addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
|
||||
}) { Text("Partager") }
|
||||
OutlinedButton(onClick = { AppLog.clear() }) { Text("Effacer") }
|
||||
OutlinedButton(
|
||||
enabled = passwordSet != null,
|
||||
onClick = {
|
||||
if (passwordSet == true) { passwordError = null; askPassword = true } else AppLog.clear()
|
||||
}
|
||||
) { Text("Effacer") }
|
||||
}
|
||||
LazyColumn(Modifier.fillMaxWidth().weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
|
||||
items(entries.asReversed()) { line ->
|
||||
@@ -74,12 +88,32 @@ fun JournalScreen() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (askPassword) {
|
||||
ClearPasswordDialog(
|
||||
error = passwordError,
|
||||
onDismiss = { askPassword = false },
|
||||
onConfirm = { password ->
|
||||
scope.launch {
|
||||
val error = viewModel.checkPassword(password)
|
||||
if (error == null) { AppLog.clear(); askPassword = false } else passwordError = error
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private fun liveStatus(context: Context): String = buildString {
|
||||
appendLine("VPN autorisé (prepare) : ${FirewallVpnService.isPrepared(context)}")
|
||||
appendLine("Tunnel VPN monté : ${FirewallVpnService.tunnelActive}")
|
||||
@Composable
|
||||
private fun ClearPasswordDialog(
|
||||
error: String?,
|
||||
onDismiss: () -> Unit,
|
||||
onConfirm: (String) -> Unit
|
||||
) = PasswordPromptDialog(title = "Effacer le journal", error = error, onDismiss = onDismiss, onConfirm = onConfirm)
|
||||
|
||||
private fun liveStatus(context: Context, tunnelUp: Boolean): String = buildString {
|
||||
appendLine("VPN autorisé (prepare) : ${TunnelManager.isPrepared(context)}")
|
||||
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é.")
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.jttools.datacontrol.ui.journal
|
||||
|
||||
import androidx.lifecycle.ViewModel
|
||||
import androidx.lifecycle.viewModelScope
|
||||
import com.jttools.datacontrol.data.AppSettings
|
||||
import com.jttools.datacontrol.data.SettingsRepository
|
||||
import dagger.hilt.android.lifecycle.HiltViewModel
|
||||
import kotlinx.coroutines.flow.SharingStarted
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.flow.stateIn
|
||||
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 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)
|
||||
|
||||
suspend fun checkPassword(password: String): String? = settingsRepository.checkPassword(password)
|
||||
}
|
||||
@@ -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() }
|
||||
}
|
||||
|
||||
@@ -53,8 +53,9 @@ import java.util.Locale
|
||||
fun SettingsScreen(systemActions: SystemActions) {
|
||||
val viewModel: SettingsViewModel = hiltViewModel()
|
||||
val settings by viewModel.settings.collectAsStateWithLifecycle()
|
||||
val passwordSet by viewModel.passwordSet.collectAsStateWithLifecycle()
|
||||
|
||||
PasswordGate(passwordSet = settings.hasPassword, verify = { viewModel.verifyPassword(it) }) {
|
||||
PasswordGate(passwordSet = passwordSet, verify = { viewModel.checkPassword(it) }) {
|
||||
SettingsContent(systemActions, viewModel, settings)
|
||||
}
|
||||
}
|
||||
@@ -69,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) }
|
||||
|
||||
@@ -177,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)
|
||||
@@ -292,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
|
||||
)
|
||||
},
|
||||
|
||||
@@ -12,6 +12,7 @@ import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.flow.stateIn
|
||||
import kotlinx.coroutines.launch
|
||||
import java.time.LocalDate
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import javax.inject.Inject
|
||||
|
||||
@HiltViewModel
|
||||
@@ -33,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
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -55,5 +55,10 @@ class SettingsViewModel @Inject constructor(
|
||||
viewModelScope.launch { settingsRepository.setPassword(password) }
|
||||
}
|
||||
|
||||
suspend fun verifyPassword(password: String): Boolean = settingsRepository.verifyPassword(password)
|
||||
/** 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)
|
||||
}
|
||||
@@ -1,191 +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()
|
||||
|
||||
PasswordGate(passwordSet = settings.hasPassword, verify = { viewModel.verifyPassword(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)
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -1,66 +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 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) }
|
||||
}
|
||||
|
||||
suspend fun verifyPassword(password: String): Boolean = settingsRepository.verifyPassword(password)
|
||||
}
|
||||
@@ -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() }
|
||||
}
|
||||
}
|
||||
@@ -5,21 +5,17 @@
|
||||
<!-- 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>
|
||||
|
||||
<!-- Dashboard -->
|
||||
<string name="dashboard_title">Tableau de bord</string>
|
||||
<string name="dashboard_consumed">Données consommées</string>
|
||||
<string name="dashboard_plan_label">Forfait</string>
|
||||
<string name="dashboard_remaining">Restant</string>
|
||||
<string name="dashboard_overage">Dépassement</string>
|
||||
<string name="dashboard_state_label">État des données</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 — aucun filtrage</string>
|
||||
<string name="dashboard_state_wifi">Wi-Fi actif</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>
|
||||
@@ -30,13 +26,7 @@
|
||||
<string name="dashboard_reset_now">Réinitialiser le forfait maintenant</string>
|
||||
<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_permissions_needed">Autorisations requises pour fonctionner correctement</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>
|
||||
@@ -48,12 +38,7 @@
|
||||
<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_usage_access">Accès aux statistiques d\'utilisation</string>
|
||||
<string name="settings_perm_usage_access_desc">Nécessaire pour mesurer la consommation de données mobiles</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>
|
||||
<string name="settings_perm_notifications">Notifications</string>
|
||||
@@ -64,7 +49,6 @@
|
||||
<string name="settings_perm_missing">Manquante</string>
|
||||
<string name="settings_save">Enregistrer</string>
|
||||
<string name="settings_edit_date">Modifier</string>
|
||||
<string name="settings_saved">Réglages enregistrés</string>
|
||||
<string name="settings_section_security">Sécurité</string>
|
||||
<string name="settings_password_active">Mot de passe actif — protège la désactivation et les réglages</string>
|
||||
<string name="settings_password_inactive">Aucun mot de passe défini</string>
|
||||
@@ -80,11 +64,9 @@
|
||||
<!-- Verrouillage par mot de passe -->
|
||||
<string name="password_gate_title">Zone protégée</string>
|
||||
<string name="password_field_label">Mot de passe</string>
|
||||
<string name="password_incorrect">Mot de passe incorrect</string>
|
||||
<string name="password_unlock">Déverrouiller</string>
|
||||
|
||||
<!-- About -->
|
||||
<string name="about_title">À propos</string>
|
||||
<string name="about_version">Version %1$s</string>
|
||||
<string name="update_section">Mise à jour</string>
|
||||
<string name="update_check">Rechercher une mise à jour</string>
|
||||
@@ -99,33 +81,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="unit_mo">Mo</string>
|
||||
<string name="unit_euro">€</string>
|
||||
<string name="common_cancel">Annuler</string>
|
||||
<string name="common_confirm">Confirmer</string>
|
||||
|
||||
<string name="family_title">Contrôle parental (FamilyControl)</string>
|
||||
<string name="family_unavailable">Liaison FamilyControl non configurée dans cette version (fichier firebase.properties absent à la compilation).</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">Dissocier cet appareil</string>
|
||||
<string name="family_pair_help">Saisissez le code d\'appairage affiché dans FamilyControl pour associer cet appareil.</string>
|
||||
<string name="family_title">Contrôle parental</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_unpair">Oublier cette liaison</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_code">Code d\'appairage</string>
|
||||
<string name="family_device_name">Nom de l\'appareil</string>
|
||||
<string name="family_pair">Associer</string>
|
||||
@@ -136,7 +105,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>
|
||||
@@ -145,4 +114,25 @@
|
||||
<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>
|
||||
<!-- v0.2 : tunnel WireGuard et serveur familyd -->
|
||||
<string name="mode_open">Accès libre</string>
|
||||
<string name="mode_allowlist">Liste blanche seulement</string>
|
||||
<string name="mode_cut">Internet coupé</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>
|
||||
</resources>
|
||||
@@ -1,4 +1,8 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Android 11 et avant. Réglages (DataStore), appairage, mot de passe et journal sont propres à cet
|
||||
appareil : restaurés ailleurs, l'appareil se croirait associé alors que Firestore refuse ses écritures. -->
|
||||
<full-backup-content>
|
||||
<exclude domain="sharedpref" path="." />
|
||||
<exclude domain="file" path="datastore/" />
|
||||
<exclude domain="file" path="journal.txt" />
|
||||
</full-backup-content>
|
||||
@@ -1,6 +1,14 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Android 12+. Voir backup_rules.xml : rien de propre à l'appareil ne doit être sauvegardé ni transféré. -->
|
||||
<data-extraction-rules>
|
||||
<cloud-backup>
|
||||
<exclude domain="sharedpref" path="." />
|
||||
<exclude domain="file" path="datastore/" />
|
||||
<exclude domain="file" path="journal.txt" />
|
||||
</cloud-backup>
|
||||
<device-transfer>
|
||||
<exclude domain="sharedpref" path="." />
|
||||
<exclude domain="file" path="datastore/" />
|
||||
<exclude domain="file" path="journal.txt" />
|
||||
</device-transfer>
|
||||
</data-extraction-rules>
|
||||
@@ -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>
|
||||
@@ -0,0 +1,38 @@
|
||||
package com.jttools.datacontrol.data
|
||||
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
import java.security.MessageDigest
|
||||
|
||||
class PasswordHasherTest {
|
||||
|
||||
@Test fun `bon et mauvais mot de passe`() {
|
||||
val salt = PasswordHasher.newSalt()
|
||||
val hash = PasswordHasher.hash("1234", salt)
|
||||
assertTrue(hash.startsWith("pbkdf2:"))
|
||||
assertTrue(PasswordHasher.verify("1234", salt, hash))
|
||||
assertFalse(PasswordHasher.verify("1235", salt, hash))
|
||||
assertFalse(PasswordHasher.needsUpgrade(hash))
|
||||
}
|
||||
|
||||
@Test fun `le sel change le hachage`() {
|
||||
val a = PasswordHasher.hash("1234", PasswordHasher.newSalt())
|
||||
val b = PasswordHasher.hash("1234", PasswordHasher.newSalt())
|
||||
assertTrue(a != b)
|
||||
}
|
||||
|
||||
@Test fun `ancien format SHA-256 toujours accepte et a convertir`() {
|
||||
val salt = "00112233445566778899aabbccddeeff"
|
||||
val md = MessageDigest.getInstance("SHA-256")
|
||||
md.update(salt.toByteArray())
|
||||
val legacy = md.digest("secret".toByteArray()).joinToString("") { "%02x".format(it) }
|
||||
assertTrue(PasswordHasher.verify("secret", salt, legacy))
|
||||
assertFalse(PasswordHasher.verify("autre", salt, legacy))
|
||||
assertTrue(PasswordHasher.needsUpgrade(legacy))
|
||||
}
|
||||
|
||||
@Test fun `hachage illisible refuse`() {
|
||||
assertFalse(PasswordHasher.verify("1234", PasswordHasher.newSalt(), "pbkdf2:abc:00"))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package com.jttools.datacontrol.data
|
||||
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class UpdateManagerTest {
|
||||
@Test fun `comparaison de versions`() {
|
||||
assertTrue(UpdateManager.isNewer("0.1.9", "0.1.8"))
|
||||
assertTrue(UpdateManager.isNewer("0.2.0", "0.1.10"))
|
||||
assertTrue(UpdateManager.isNewer("0.1.10", "0.1.9")) // numérique, pas alphabétique
|
||||
assertTrue(UpdateManager.isNewer("1.0", "0.9.9"))
|
||||
assertFalse(UpdateManager.isNewer("0.1.8", "0.1.8"))
|
||||
assertFalse(UpdateManager.isNewer("0.1.8", "0.1.8.0"))
|
||||
assertFalse(UpdateManager.isNewer("0.1.7", "0.1.8"))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
package com.jttools.datacontrol.guard
|
||||
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
import java.time.LocalDateTime
|
||||
|
||||
class RulesTest {
|
||||
|
||||
// 2026-10-26 est un lundi.
|
||||
private fun at(day: Int, h: Int, m: Int = 0) = LocalDateTime.of(2026, 10, 25, h, m).plusDays(day.toLong())
|
||||
|
||||
private val json = """
|
||||
{"schedule":{"enabled":true,"cutsMobile":false,
|
||||
"windows":[{"days":[1,2,3,4,5],"start":480,"end":1200},{"days":[5],"start":1320,"end":120}]},
|
||||
"dailyLimitMin":90,
|
||||
"appLimits":[{"pkg":"com.game","min":30}],
|
||||
"blocked":["com.bad"],
|
||||
"bonus":{"date":"2026-10-26","globalMin":15,"apps":[{"pkg":"com.game","min":10}]}}
|
||||
""".trimIndent()
|
||||
|
||||
@Test fun `lecture complete`() {
|
||||
val r = Rules.parse(json)
|
||||
assertTrue(r.scheduleEnabled)
|
||||
assertFalse(r.scheduleCutsMobile)
|
||||
assertEquals(2, r.windows.size)
|
||||
assertEquals(90, r.dailyLimitMin)
|
||||
assertEquals(listOf(AppLimit("com.game", 30)), r.appLimits)
|
||||
assertEquals(setOf("com.bad"), r.blocked)
|
||||
assertEquals("2026-10-26", r.bonusDate)
|
||||
assertEquals(15, r.bonusGlobalMin)
|
||||
assertFalse(r.isEmpty)
|
||||
}
|
||||
|
||||
@Test fun `json vide ou invalide donne aucune regle`() {
|
||||
assertTrue(Rules.parse(null).isEmpty)
|
||||
assertTrue(Rules.parse("").isEmpty)
|
||||
assertTrue(Rules.parse("{pas du json").isEmpty)
|
||||
}
|
||||
|
||||
@Test fun `plage de journee`() {
|
||||
val r = Rules.parse(json)
|
||||
assertTrue(r.isOpenAt(at(1, 8))) // lundi 08:00 : début inclus
|
||||
assertTrue(r.isOpenAt(at(1, 19, 59)))
|
||||
assertFalse(r.isOpenAt(at(1, 20))) // fin exclue
|
||||
assertFalse(r.isOpenAt(at(1, 7, 59)))
|
||||
assertFalse(r.isOpenAt(at(6, 12))) // samedi : pas de plage de journée
|
||||
}
|
||||
|
||||
@Test fun `plage qui passe minuit deborde sur le lendemain`() {
|
||||
val r = Rules.parse(json)
|
||||
assertTrue(r.isOpenAt(at(5, 23))) // vendredi 23:00
|
||||
assertTrue(r.isOpenAt(at(6, 1, 30))) // samedi 01:30, suite de la plage du vendredi
|
||||
assertFalse(r.isOpenAt(at(6, 2)))
|
||||
assertFalse(r.isOpenAt(at(7, 1))) // dimanche 01:00 : pas de plage samedi soir
|
||||
}
|
||||
|
||||
@Test fun `prochaine ouverture`() {
|
||||
val r = Rules.parse(json)
|
||||
assertEquals("Reprise à 08:00.", r.nextOpeningText(at(1, 6)))
|
||||
assertEquals("Reprise à 08:00 (dans 2 j).", r.nextOpeningText(at(6, 12)))
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
@@ -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…) ?
|
||||
@@ -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=
|
||||
@@ -3,6 +3,7 @@ agp = "8.5.0"
|
||||
kotlin = "1.9.24"
|
||||
coreKtx = "1.13.1"
|
||||
junit = "4.13.2"
|
||||
orgJson = "20240303"
|
||||
junitVersion = "1.2.1"
|
||||
espressoCore = "3.6.1"
|
||||
composeBom = "2024.09.00"
|
||||
@@ -16,12 +17,12 @@ hiltNavigationCompose = "1.2.0"
|
||||
datastore = "1.1.1"
|
||||
coroutines = "1.8.1"
|
||||
workManager = "2.9.1"
|
||||
firebaseBom = "33.1.2"
|
||||
coroutinesPlayServices = "1.8.1"
|
||||
wireguardTunnel = "1.0.20230706"
|
||||
|
||||
[libraries]
|
||||
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
|
||||
junit = { group = "junit", name = "junit", version.ref = "junit" }
|
||||
org-json = { group = "org.json", name = "json", version.ref = "orgJson" }
|
||||
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
|
||||
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
|
||||
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
|
||||
@@ -44,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" }
|
||||
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" }
|
||||
wireguard-tunnel = { group = "com.wireguard.android", name = "tunnel", version.ref = "wireguardTunnel" }
|
||||
|
||||
[plugins]
|
||||
android-application = { id = "com.android.application", version.ref = "agp" }
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
# Copier en keystore.properties (non versionné) et renseigner.
|
||||
# La clé doit rester celle des versions déjà publiées, sinon les mises à jour échouent
|
||||
# (empreinte SHA-256 : 79:88:7C:5D:8F:32:77:DA:66:99:B6:4A:68:D8:DF:C9:AC:65:02:8C:20:E9:1D:B1:FC:8C:09:AF:5C:E8:8B:42).
|
||||
storeFile=/home/<utilisateur>/.android/datacontrol-release.keystore
|
||||
storePassword=
|
||||
keyAlias=datacontrol
|
||||
keyPassword=
|
||||
+2
-2
@@ -1,2 +1,2 @@
|
||||
versionName=0.1.6
|
||||
versionCode=7
|
||||
versionName=0.3.0
|
||||
versionCode=13
|
||||
Reference in new issue
Block a user