release: v0.1.8 — configuration Firebase saisie dans l'application

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 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).
+- README mis à jour (journal, contrôle parental, permissions, architecture).
+
 ## v0.1.5 – 2026-09-20
 
 - Onglet Journal : bouton **Tester le VPN** (10 s) qui monte le tunnel quel que soit le réseau, pour savoir si le VPN peut se monter sur l'appareil ; les erreurs de démarrage du service VPN sont désormais tracées au lieu d'être silencieuses.

README.md

@@ -2,7 +2,7 @@
 
 **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.
 
-> JT-Tools by Johnny — v0.1.0
+> JT-Tools by Johnny — version courante et historique : voir [CHANGELOG.md](CHANGELOG.md) (aussi lisible dans l'onglet *À propos* de l'application).
 
 ---
 
@@ -16,7 +16,23 @@
 - **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.
-- **Interface Material 3** — Thème clair/sombre avec couleurs dynamiques (Android 12+), 3 écrans : Tableau de bord, Réglages, Liste blanche.
+- **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.
+
+---
+
+## Contrôle parental (avec FamilyControl)
+
+DataControl peut être associé à **FamilyControl** (application parent en TypeScript/Expo, dépôt séparé) via Firebase (Auth + Firestore). La configuration du projet Firebase se **colle dans l'application** (*Réglages → Contrôle parental → Configuration Firebase*), sans recompiler ; sans elle, ces fonctions sont simplement désactivées (un `firebase.properties` à la compilation reste possible comme valeur par défaut).
+
+- **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).
 
 ---
 
@@ -44,6 +60,9 @@ Le pare-feu est démarré/arrêté automatiquement selon le transport réseau ac
 | 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 |
 
 ---
 
@@ -60,7 +79,10 @@ Le pare-feu est démarré/arrêté automatiquement selon le transport réseau ac
 - **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`.
-- `ui/` — écrans Compose (`dashboard`, `settings`, `whitelist`), navigation par `NavigationBar`, thème dynamique.
+- `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.
 
 ---
 
@@ -70,6 +92,7 @@ Le pare-feu est démarré/arrêté automatiquement selon le transport réseau ac
 make build      # APK debug
 make release    # APK release signé, copié en DataControl-<version>.apk
 make install    # Installe le debug sur un appareil connecté (adb)
+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.

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

@@ -9,6 +9,8 @@ import com.jttools.datacontrol.service.DataMonitorRestartWorker
 import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
@@ -17,11 +19,16 @@ import javax.inject.Inject
 class DataControlApp : Application() {
 
     @Inject lateinit var settingsRepository: SettingsRepository
+    @Inject lateinit var firebaseGateway: com.jttools.datacontrol.remote.FirebaseGateway
 
     override fun onCreate() {
         super.onCreate()
         com.jttools.datacontrol.log.AppLog.init(this)
         CoroutineScope(Dispatchers.IO).launch { settingsRepository.resetPasswordOnce() }
+        // La config Firebase se saisit dans l'appli : on l'applique au démarrage et à chaque modification.
+        CoroutineScope(Dispatchers.IO).launch {
+            settingsRepository.settingsFlow.map { it.firebase }.distinctUntilChanged().collect { firebaseGateway.apply(it) }
+        }
         // 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()

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

@@ -29,7 +29,9 @@ data class AppSettings(
     /** 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
+    val rulesJson: String? = null,
+    /** Configuration Firebase saisie dans l'application (null : voir firebase.properties de compilation). */
+    val firebase: com.jttools.datacontrol.remote.FirebaseConfig? = null
 ) {
     val isPaired: Boolean get() = !familyId.isNullOrEmpty() && !deviceId.isNullOrEmpty()
 

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

@@ -46,6 +46,9 @@ class SettingsRepository @Inject constructor(
         val DEVICE_ID = stringPreferencesKey("device_id")
         val REMOTE_CONFIG_VERSION = longPreferencesKey("remote_config_version")
         val RULES_JSON = stringPreferencesKey("rules_json")
+        val FIREBASE_API_KEY = stringPreferencesKey("firebase_api_key")
+        val FIREBASE_APP_ID = stringPreferencesKey("firebase_app_id")
+        val FIREBASE_PROJECT_ID = stringPreferencesKey("firebase_project_id")
         val USAGE_DAY = stringPreferencesKey("usage_day")
         val USAGE_JSON = stringPreferencesKey("usage_json")
         val TRAFFIC_DAY = stringPreferencesKey("traffic_day")
@@ -78,7 +81,12 @@ class SettingsRepository @Inject constructor(
             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],
+            firebase = run {
+                val k = prefs[Keys.FIREBASE_API_KEY]; val a = prefs[Keys.FIREBASE_APP_ID]; val p = prefs[Keys.FIREBASE_PROJECT_ID]
+                if (k.isNullOrBlank() || a.isNullOrBlank() || p.isNullOrBlank()) null
+                else com.jttools.datacontrol.remote.FirebaseConfig(k, a, p)
+            }
         )
     }
 
@@ -286,4 +294,17 @@ class SettingsRepository @Inject constructor(
             it[Keys.USAGE_JSON] = json
         }
     }
+
+    /** Enregistre (ou efface, si null) la configuration Firebase saisie dans l'application. */
+    suspend fun setFirebaseConfig(config: com.jttools.datacontrol.remote.FirebaseConfig?) {
+        context.dataStore.edit {
+            if (config == null) {
+                it.remove(Keys.FIREBASE_API_KEY); it.remove(Keys.FIREBASE_APP_ID); it.remove(Keys.FIREBASE_PROJECT_ID)
+            } else {
+                it[Keys.FIREBASE_API_KEY] = config.apiKey
+                it[Keys.FIREBASE_APP_ID] = config.appId
+                it[Keys.FIREBASE_PROJECT_ID] = config.projectId
+            }
+        }
+    }
 }

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

@@ -53,7 +53,7 @@ class DeviceReporter @Inject constructor(
     private var lastUsageSentTotal = -1L
 
     fun start(scope: CoroutineScope) {
-        if (started || !remote.available) return
+        if (started) return
         started = true
         remote.start(scope)
 

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

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

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

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

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

@@ -8,7 +8,10 @@ import com.jttools.datacontrol.data.AppSettings
 import com.jttools.datacontrol.data.InstalledAppsRepository
 import com.jttools.datacontrol.data.SettingsRepository
 import com.jttools.datacontrol.data.TrafficDay
+import com.jttools.datacontrol.log.AppLog
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flatMapLatest
@@ -43,6 +46,7 @@ class RemoteSync @Inject constructor(
     private val installedApps: InstalledAppsRepository
 ) {
     val available: Boolean get() = gateway.enabled
+    val gatewayState = gateway.state
 
     private fun deviceDoc(s: AppSettings): DocumentReference? {
         val db = gateway.db ?: return null
@@ -81,27 +85,59 @@ class RemoteSync @Inject constructor(
         settingsRepository.setPairing(null, null)
     }
 
-    /** Écoute les consignes du parent et les applique aux réglages locaux. */
+    /** Écoute les consignes du parent et les applique ; relancé à chaque (ré)initialisation de Firebase. */
     @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)
+            gateway.state.collectLatest { st ->
+                if (!st.enabled) return@collectLatest
+                coroutineScope {
+                    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) }
+                    }
+                    launch {
+                        // Si le parent supprime l'appareil de la famille, on se dissocie localement (plus de règles,
+                        // plus d'envois qui échoueraient en silence).
+                        settingsRepository.settingsFlow
+                            .map { it.familyId to it.deviceId }
+                            .distinctUntilChanged()
+                            .flatMapLatest { (fid, did) -> if (fid == null || did == null) flowOf(null) else existenceFlow(fid, did) }
+                            .collect { exists ->
+                                if (exists == false) {
+                                    AppLog.w("FamilyControl", "Appareil supprimé par le parent : dissociation locale")
+                                    settingsRepository.setPairing(null, null)
+                                }
+                            }
+                    }
+                    launch {
+                        // Liste des applications installées, pour que le parent puisse choisir lesquelles autoriser.
+                        settingsRepository.settingsFlow.map { it.isPaired }.distinctUntilChanged().collect { paired ->
+                            if (paired) pushApps()
+                        }
+                    }
                 }
-                .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()
             }
         }
     }
 
+    /** Vrai/faux selon que le document de l'appareil existe côté serveur (ignore le cache local). */
+    private fun existenceFlow(fid: String, did: String) = callbackFlow<Boolean?> {
+        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)
+            .addSnapshotListener { snap, err ->
+                if (err != null || snap == null || snap.metadata.isFromCache) return@addSnapshotListener
+                trySend(snap.exists())
+            }
+        awaitClose { reg.remove() }
+    }
+
     private class Config(val map: Map<String, Any?>)
 
     private fun configFlow(fid: String, did: String) = callbackFlow<Config?> {

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

@@ -32,7 +32,7 @@ object AboutContent {
             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("Condition", "Ces fonctions demandent une configuration Firebase saisie dans Réglages → Contrôle parental, puis l'association à un compte parent.")
         ))
     )
 
@@ -123,7 +123,7 @@ object AboutContent {
         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("Firebase sans plugin google-services", "La configuration se saisit dans l'application (Réglages → Contrôle parental) et peut changer sans recompiler ; sans elle, le contrôle à distance est simplement désactivé. Un fichier firebase.properties à la compilation reste possible comme valeur par défaut."),
         AboutEntry("Service d'accessibilité plutôt que statistiques d'usage", "Permet de renvoyer à l'accueil et d'afficher un écran de blocage dès qu'une application interdite passe au premier plan."),
         AboutEntry("Administrateur d'appareil plutôt que Device Owner", "Pas de réinitialisation d'usine ni de branchement à un PC ; en contrepartie, la protection est moins robuste."),
         AboutEntry("Journal embarqué", "Le journal de diagnostic est conservé 15 jours (20 000 lignes au plus) dans un fichier local ; le changelog de cette page est le CHANGELOG.md du dépôt, embarqué dans l'APK.")

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

@@ -42,6 +42,10 @@ fun FamilySection(systemActions: SystemActions) {
     val vm: FamilyViewModel = hiltViewModel()
     val settings by vm.settings.collectAsStateWithLifecycle()
     val pairing by vm.pairing.collectAsStateWithLifecycle()
+    val gw by vm.gatewayState.collectAsStateWithLifecycle()
+    var firebaseText by remember { mutableStateOf("") }
+    var firebaseError by remember { mutableStateOf<String?>(null) }
+    var editFirebase by remember { mutableStateOf(false) }
     val scope = rememberCoroutineScope()
 
     var adminActive by remember { mutableStateOf(systemActions.isAdminActive()) }
@@ -83,9 +87,41 @@ fun FamilySection(systemActions: SystemActions) {
             )
             HorizontalDivider()
 
+            // --- Configuration Firebase (saisie ici, sans recompiler) ---
+            Text(stringResource(R.string.family_firebase_title), fontWeight = FontWeight.Medium)
+            if (gw.enabled && !editFirebase) {
+                Text(
+                    stringResource(R.string.family_firebase_ok, gw.projectId ?: ""),
+                    color = StateOk, style = MaterialTheme.typography.bodyMedium
+                )
+                OutlinedButton(onClick = { editFirebase = true }) { Text(stringResource(R.string.family_firebase_edit)) }
+            } else {
+                Text(
+                    stringResource(R.string.family_firebase_help),
+                    style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+                OutlinedTextField(
+                    value = firebaseText, onValueChange = { firebaseText = it; firebaseError = null },
+                    label = { Text(stringResource(R.string.family_firebase_field)) },
+                    minLines = 3, maxLines = 6, modifier = Modifier.fillMaxWidth()
+                )
+                firebaseError?.let {
+                    Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+                }
+                Button(
+                    enabled = firebaseText.isNotBlank(),
+                    onClick = {
+                        firebaseError = vm.saveFirebaseConfig(firebaseText)
+                        if (firebaseError == null) { firebaseText = ""; editFirebase = false }
+                    }
+                ) { Text(stringResource(R.string.family_firebase_save)) }
+            }
+
+            HorizontalDivider()
+
             // --- Appairage ---
             when {
-                !vm.remoteAvailable -> Text(
+                !gw.enabled -> Text(
                     stringResource(R.string.family_unavailable),
                     style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant
                 )

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

@@ -4,6 +4,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.jttools.datacontrol.data.AppSettings
 import com.jttools.datacontrol.data.SettingsRepository
+import com.jttools.datacontrol.remote.FirebaseConfig
 import com.jttools.datacontrol.remote.RemoteSync
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -26,7 +27,17 @@ class FamilyViewModel @Inject constructor(
         viewModelScope, SharingStarted.WhileSubscribed(5_000), AppSettings()
     )
 
-    val remoteAvailable: Boolean get() = remoteSync.available
+    val gatewayState = remoteSync.gatewayState.stateIn(
+        viewModelScope, SharingStarted.WhileSubscribed(5_000), remoteSync.gatewayState.value
+    )
+
+    /** Enregistre la configuration Firebase collée ; renvoie un message d'erreur, ou null si elle est acceptée. */
+    fun saveFirebaseConfig(text: String): String? {
+        val cfg = FirebaseConfig.parse(text)
+            ?: return "Configuration non reconnue : il faut au minimum apiKey, appId et projectId (collez le bloc « firebaseConfig » complet, ou la chaîne « fc1:… » de FamilyControl)."
+        viewModelScope.launch { settingsRepository.setFirebaseConfig(cfg) }
+        return null
+    }
 
     private val _pairing = MutableStateFlow(PairingUiState())
     val pairing: StateFlow<PairingUiState> = _pairing.asStateFlow()

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

@@ -23,7 +23,6 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -34,14 +33,11 @@ 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.ui.SystemActions
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 
 @Composable
-fun JournalScreen(systemActions: SystemActions) {
+fun JournalScreen() {
     val context = LocalContext.current
-    val scope = rememberCoroutineScope()
     val entries by AppLog.entries.collectAsStateWithLifecycle()
 
     // État en direct du pare-feu, rafraîchi chaque seconde : première chose à regarder si le VPN n'apparaît pas.
@@ -67,18 +63,6 @@ fun JournalScreen(systemActions: SystemActions) {
             }) { Text("Partager") }
             OutlinedButton(onClick = { AppLog.clear() }) { Text("Effacer") }
         }
-        Button(onClick = {
-            scope.launch {
-                if (!FirewallVpnService.isPrepared(context)) {
-                    AppLog.i("Test VPN", "autorisation VPN absente : demande à l'utilisateur")
-                    systemActions.requestVpnPermission { granted ->
-                        AppLog.i("Test VPN", "autorisation VPN ${if (granted) "accordée" else "REFUSÉE"} — relancez le test")
-                    }
-                    return@launch
-                }
-                runVpnTest(context)
-            }
-        }, modifier = Modifier.fillMaxWidth()) { Text("Tester le VPN (10 s, coupe les autres applications)") }
         LazyColumn(Modifier.fillMaxWidth().weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
             items(entries.asReversed()) { line ->
                 val color = when {
@@ -99,23 +83,3 @@ private fun liveStatus(context: Context): String = buildString {
     appendLine("Conservation du journal : ${AppLog.RETENTION_DAYS} jours")
     append("Attendu : le tunnel n'est monté QUE sur données mobiles, contrôle activé.")
 }
-
-/** Monte le tunnel 10 s quel que soit le réseau : prouve (ou infirme) que le VPN peut se monter sur cet appareil. */
-private suspend fun runVpnTest(context: Context) {
-    val app = context.applicationContext
-    AppLog.i("Test VPN", "démarrage : demande de montage du tunnel (mode blocage total)")
-    try {
-        androidx.core.content.ContextCompat.startForegroundService(app, FirewallVpnService.startBlockAllIntent(app))
-    } catch (e: Exception) {
-        AppLog.e("Test VPN", "le service VPN n'a pas pu démarrer", e)
-        return
-    }
-    delay(3_000)
-    if (FirewallVpnService.tunnelActive) AppLog.i("Test VPN", "SUCCÈS : tunnel monté — l'icône clé doit être visible")
-    else AppLog.e("Test VPN", "ÉCHEC : tunnel non monté après 3 s (voir les lignes FirewallVpnService ci-dessus)")
-    delay(7_000)
-    runCatching {
-        androidx.core.content.ContextCompat.startForegroundService(app, FirewallVpnService.stopIntent(app))
-    }
-    AppLog.i("Test VPN", "fin du test : tunnel arrêté")
-}

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

@@ -75,7 +75,7 @@ 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(systemActions) }
+            composable(Destination.Journal.route) { JournalScreen() }
             composable(Destination.About.route) { AboutScreen() }
         }
     }

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

@@ -122,7 +122,7 @@
     <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_unavailable">Renseignez d\'abord la configuration Firebase ci-dessus pour pouvoir associer l\'appareil.</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>
@@ -145,4 +145,10 @@
     <string name="family_guard_desc">Plages horaires, temps d\'écran et blocage d\'applications décidés par le parent. Nécessite le service d\'accessibilité « DataControl ».</string>
     <string name="family_guard_hint">Android 13+ : si l\'activation est grisée, ouvrez Infos sur l\'application → ⋮ → « Autoriser les paramètres restreints », puis réessayez.</string>
     <string name="family_guard_enable">Activer le service</string>
+    <string name="family_firebase_title">Configuration Firebase</string>
+    <string name="family_firebase_ok">Configurée — projet %1$s</string>
+    <string name="family_firebase_edit">Modifier la configuration</string>
+    <string name="family_firebase_help">Collez ici la chaîne « fc1:… » partagée par FamilyControl (bouton « Partager pour DataControl »), ou le bloc « firebaseConfig » de la console Firebase.</string>
+    <string name="family_firebase_field">Configuration Firebase</string>
+    <string name="family_firebase_save">Enregistrer</string>
 </resources>

version.properties

@@ -1,2 +1,2 @@
-versionName=0.1.5
-versionCode=6
+versionName=0.1.8
+versionCode=9