La base de données en temps réel de Firebase

• Firestore est recommandé pour les applications modernes, structurées, ayant besoin de flexibilité dans les filtres et une évolutivité importante.
• Realtime Database est idéal pour des cas très exigeants en temps réel pur (ex. : chat instantané ou IoT), mais devient moins pratique pour des données complexes ou fortement liées.

Configuration et installation de bases de données en temps réel

1. Configuration du projet Firebase

   • Accédez à la console Firebase et créez un nouveau projet.
     • Avant de pouvoir utiliser l'un des services cloud de Google, vous devez configurer un projet sur la console Firebase . Ensuite, vous pouvez créer votre base de données en temps réel et la gérer directement depuis la console.
     • Accédez à console.firebase.google.com et connectez-vous à l'aide de votre compte Gmail.

     

     • Cliquez sur le bouton "créer un projet" puis sur le bouton continuer.

     

     • Cliquez sur "Ajouter Firebase à votre application Flutter" et suivez les instructions d'installation. Vous obtiendrez ainsi un fichier google-services.json à placer dans le répertoireandroid/app de votre projet Flutter.

2. Génération d'un fichier de configuration de projet Firebase:

   • Sur la console Firebase , ajoutez une nouvelle application Android ou sélectionnez une application Android existante pour votre projet Firebase.
   • Le "Nom du package Android" doit correspondre au nom du package de votre projet local, créé au démarrage du projet Flutter.
   • Le nom du package actuel se trouve dans votre fichier Gradle de module (au niveau de l'application), généralement android/app/build.gradle dans la section defaultConfig (exemple de nom de package : com.yourcompany.yourproject).
   • Une fois votre application Android enregistrée, téléchargez le fichier de configuration depuis la console Firebase (fichier nommé google-services.json). Ajoutez ce fichier au répertoire de android/app votre projet Flutter.

3. Installation de votre fichier de configuration Firebase :

   • Pour permettre à Firebase d'utiliser la configuration sur Android, le plugin "google-services" doit être appliqué au projet. Cela nécessite la modification de deux fichiers du android/répertoire.
   • Tout d’abord, ajoutez le plugin " google-services" en tant que dépendance à l’intérieur du fichier : android/build.gradle

     buildscript {
       dependencies {
         // ... other dependencies
         classpath 'com.google.gms:google-services:4.3.8'
       }
     }

   • Enfin, exécutez le plugin en ajoutant ce qui suit sous la ligne apply plugin: 'com.android.application', dans le fichier : /android/app/build.gradle

     buildscript {
       apply plugin: 'com.google.gms.google-services'

   • Si ton projet utilisait Gradle Kotlin DSL, les fichiers seraient en .gradle.kts (extension .kts pour Kotlin Script), et la syntaxe serait différente, par exemple :

     plugins {
         id("com.google.gms.google-services")
     }

     Donc : En Groovy ➔ tu fais apply plugin: '...' En Kotlin DSL ➔ tu fais plugins { id("...") }

4. Ajout de dépendances Firebase :

   • Ouvrez votre projet Flutter et accédez au fichier pubspec.yaml.
   • Ajoutez les dépendances suivantes sous la dependenciessection :

     dépendances : 
       flutter : 
         sdk :  flutter 
       firebase_core :  ^1.4.0 
       firebase_database :  ^11.0.0

   • Exécutez flutter pub getpour récupérer les dépendances nouvellement ajoutées.

5. Initialisation de la base de données en temps réel Firebase :

   • Ouvrez le fichier main.dart dans votre projet Flutter.
   • Importez les packages Firebase et Flutter nécessaires :

     // Importation des bibliothèques nécessaires
     // Fournit les outils pour construire l'interface utilisateur Flutter
     import 'package:flutter/material.dart';
     // Permet l'initialisation de Firebase dans l'application
     import 'package:firebase_core/firebase_core.dart';
     // Permet d'interagir avec la base de données Realtime de Firebase
     import 'package:firebase_database/firebase_database.dart';
     
     // Fonction principale de l'application, point d'entrée du programme
     void main() async {
     // S'assure que le moteur Flutter est prêt avant toute opération asynchrone
       WidgetsFlutterBinding.ensureInitialized(); 
      // Initialise Firebase avec les paramètres par défaut (configuration définie dans firebase_options ou google-services.json)
       await Firebase.initializeApp();
      // Lance l'application Flutter en affichant le widget MyApp          
       runApp(MyApp());                           
     }
     

Lecture dans la base de données en temps réel de Firebase

1. Initialisation de la base de données

   • Pour lire depuis Firebase Realtime Database, nous devons d'abord obtenir une instance de la base de données, puis référencer l'emplacement que nous souhaitons écouter.

   Mode temps réel: onValue (équivalent de .snapshots() dans Firestore)

   Lecture ponctuelle : get() (équivalent de .get())

   1. Initialisation de Firebase

      • Dans lib/main.dart:

        import 'package:flutter/material.dart';
        import 'package:firebase_core/firebase_core.dart';
        import 'home_page.dart';
        
        void main() async {
          WidgetsFlutterBinding.ensureInitialized();
          await Firebase.initializeApp();
          runApp(MyApp());
        }
        
        class MyApp extends StatelessWidget {
          @override
          Widget build(BuildContext context) {
            return MaterialApp(
              title: 'Firebase Realtime Example',
              theme: ThemeData(primarySwatch: Colors.blue),
              home: HomePage(),
            );
          }
        }
        

   2. Créer une référence à la base de données

      // Référence à la racine de la base de données
      final DatabaseReference _database = FirebaseDatabase.instance.ref();
      // Référence à un nœud spécifique (ex: "messages")
      final DatabaseReference _messageRef = _database.child('messages');

2. Lecture dans la base de données

   1. Lire une seule fois (get)

      import 'package:firebase_database/firebase_database.dart';
      final database = FirebaseDatabase.instance.ref();
      
      // Exemple de lecture unique 
      void readOnce() async { 
            final snapshot = await database.child('message').get();
                if (snapshot.exists) { 
                   print('Valeur : ${snapshot.value}'); 
                } else { 
                   print('Pas de données disponibles.');
                } 
       } 
      // get() lit une seule fois la donnée au chemin donné. 

   2. Écouter en temps réel (onValue)

      void listenToChanges() {
      database.child('message').onValue.listen((DatabaseEvent event) { 
      final data = event.snapshot.value; print('Nouveau message: $data'); 
      }); 
      } // onValue écoute toutes les modifications de la donnée en temps réel. 

   3. Lire une liste de données

      void readList() async {
      final snapshot = await database.child('utilisateurs').get(); if (snapshot.exists) { Map utilisateurs = snapshot.value as Map; utilisateurs.forEach((key, value) { print('Utilisateur $key: ${value['nomUtilisateur']}, ${value['email']}'); }); } } // Lecture d'une collection complète sous forme de Map. 

Écriture dans la base de données en temps réel de Firebase

1. Modélisation avec une classe Livre

   • Même logique qu’avec Firestore — vous utilisez une classe pour représenter vos données.

   class Livre {
     final String titre;
     final String auteur;
     final int annee;
   
     Livre({required this.titre, required this.auteur, required this.annee});
   
     Map toMap() {
       return {
         'titre': titre,
         'auteur': auteur,
         'annee': annee,
       };
     }
   
     factory Livre.fromMap(Map data) {
       return Livre(
         titre: data['titre'],
         auteur: data['auteur'],
         annee: data['annee'],
       );
     }
   }

2. Initialisation de la base de données

   • Pour interagir avec Firebase Realtime Database, nous devons d'abord initialiser Firebase et créer une référence à notre base de données.

   1. Initialisation de Firebase

      • Dans lib/main.dart:

        import 'package:firebase_core/firebase_core.dart';
        import 'package:flutter/material.dart';
        
        void main() async {
          WidgetsFlutterBinding.ensureInitialized(); // Nécessaire pour l'initialisation
          await Firebase.initializeApp(); // Initialise Firebase
          runApp(MyApp());
        }

   2. Créer une référence à la base de données

      import 'package:firebase_database/firebase_database.dart';
      
      // Référence à la racine de la base de données
      final DatabaseReference _database = FirebaseDatabase.instance.ref();
      
      // Référence à un nœud spécifique (ex: "messages")
      final DatabaseReference _messageRef = _database.child('messages');

3. Écriture dans la base de données

   1. Écrire une simple valeur

      import 'package:firebase_database/firebase_database.dart';
      
      final database = FirebaseDatabase.instance.ref();
      
      void writeSimpleValue() async {
        try {
          await database.child('message').set('Bonjour le monde!');
        } catch (e) {
          print("Erreur lors de l'écriture : $e");
        }
      }
      // set() sert à écrire une valeur (écrase si quelque chose existe déjà).

   2. Écrire un objet (Map)

      void writeObject() async {
        try {
          Map utilisateur = {
            'nomUtilisateur': 'Jean',
            'email': 'jean@example.com',
          };
      
          await database.child('utilisateurs').child('userId123').set(utilisateur);
        } catch (e) {
          print("Erreur lors de l'écriture : $e");
        }
      }

   3. Ajouter un nouvel élément avec une clé générée automatiquement (push())

      void pushNewObject() async {
        try {
          Map utilisateur = {
            'nomUtilisateur': 'Sami',
            'email': 'sami@example.com',
          };
      
          await database.child('utilisateurs').push().set(utilisateur);
        } catch (e) {
          print("Erreur lors de l'ajout : $e");
        }
      }
      // push() crée une clé unique automatiquement.

4. Structure résultante dans la base de données

   • Avec set() (remplace la valeur à un emplacement donné) :

   {
   "utilisateurs": {
     "userId123": {
       "nomUtilisateur": "Jean",
       "email": "jean@example.com"
     }
   }
   }

   • Avec push() (génère une clé unique automatiquement) :

   {
   "utilisateurs": {
     "-NyZt12a3BcD4567Ef": {
       "nomUtilisateur": "Sami",
       "email": "sami@example.com"
     }
   }
   }

Modification d’une information dans Firebase Realtime Database

1. Modifier une valeur existante

   • Dans Firebase Realtime Database, une modification consiste à changer une donnée existante. Cela peut se faire avec :
     • set(): remplace complètement la valeur ou l'objet
     • update(): modifie un ou plusieurs champs sans écraser tout l'objet
     • push().set() – ajout d’une entrée modifiable
     • runTransaction(): pour modifier des données sensibles aux conditions actuelles

   1. Modifier une valeur simple avec set()

      
      void updateSimpleValue() {
        database.child('message').set('Bonjour modifié !');
      }
            

      • set() remplace complètement le contenu du nœud message.

   2. Modifier un seul champ dans un objet avec update()

      
      void updateUserEmail() {
        database.child('utilisateurs').child('userId123').update({
          'email': 'nouveauemail@example.com',
        });
      }
            

      • update() ne modifie que le champ cité, sans toucher aux autres.

   3. Modifier plusieurs champs en même temps

      
      void updateUserData() {
        database.child('utilisateurs').child('userId123').update({
          'nomUtilisateur': 'Jean Modifié',
          'email': 'jeanmodifie@example.com',
        });
      }
            

   4. Modification atomique de plusieurs chemins (multi-location update)

      • Cette approche permet de mettre à jour plusieurs emplacements différents avec une seule requête atomique (évite les incohérences).

      
      void updateMultipleLocations() {
        final updates = {
          '/utilisateurs/userId123/email': 'newemail@example.com',
          '/messages/messageId456/contenu': 'Message modifié',
        };
        database.update(updates);
      }
            

   5. Modifier une entrée à clé générée automatiquement

      • Lorsqu’un objet est ajouté via push(), la clé est générée automatiquement. Il est nécessaire de la connaître pour la modifier.

      
      // Supposons que la clé est "cleAuto123"
      void updateAutoKeyUser() {
        database.child('utilisateurs').child('cleAuto123').update({
          'nomUtilisateur': 'Sami Modifié',
        });
      }
            

   6. Modifier un compteur en toute sécurité avec runTransaction()

      • runTransaction() permet de modifier une donnée en tenant compte de sa valeur actuelle — utile pour des compteurs, likes, etc.

      
      void incrementVisitCount() {
        final countRef = database.child('visites');
      
        countRef.runTransaction((currentData) {
          return Transaction.success((currentData ?? 0) + 1); // Incrémente de 1
        });
      }
            

      • Cette méthode garantit que l’opération est effectuée même si plusieurs utilisateurs modifient la même valeur en même temps.

Exemple Flutter complet : CRUD avec Firebase Realtime Database

1. Ajouter les dépendances dans pubspec.yaml

   dependencies:
     flutter:
       sdk: flutter
   
     # The following adds the Cupertino Icons font to your application.
     # Use with the CupertinoIcons class for iOS style icons.
     cupertino_icons: ^1.0.8
     firebase_core: ^3.13.0
     firebase_database: ^11.3.5

2. Initialiser Firebase dans main.dart

   import 'package:flutter/material.dart';
   import 'package:firebase_core/firebase_core.dart'; // Pour initialiser Firebase
   import 'home_page.dart'; // Importation de la page d'accueil
   
   void main() async {
     // S'assurer que Firebase est initialisé avant de lancer l'application
     WidgetsFlutterBinding.ensureInitialized();
     await Firebase.initializeApp(); // Initialisation de Firebase
     runApp(MyApp());
   }
   
   class MyApp extends StatelessWidget {
     @override
     Widget build(BuildContext context) {
       return MaterialApp(
         title: 'Firebase Realtime Example',
         theme: ThemeData(primarySwatch: Colors.blue),
         home: HomePage(), // Page affichée au lancement de l'application
       );
     }
   }

3. Créer la page firebaseServicefirebase_service.dart

   // firebase_service.dart
   
   import 'package:firebase_database/firebase_database.dart';
   
   class FirebaseService {
     final DatabaseReference _dbRef = FirebaseDatabase.instance.ref().child('messages');
   
     DatabaseReference get ref => _dbRef;
   
     Future<void> writeMessage(String message) async {
       await _dbRef.push().set({'text': message});
     }
   
     Future<void> deleteMessage(String key) async {
       await _dbRef.child(key).remove();
     }
   
     Future<void> updateMessage(String key, String newText) async {
       await _dbRef.child(key).update({'text': newText});
     }
   
     Stream<DatabaseEvent> getMessagesStream() {
       return _dbRef.onValue;
     }
   }
   

4. Créer la page principale home_page.dart

   import 'package:flutter/material.dart';
   import 'package:firebase_database/firebase_database.dart';
   import 'firebase_service.dart';
   
   class HomePage extends StatefulWidget {
     @override
     _HomePageState createState() => _HomePageState();
   }
   
   class _HomePageState extends State<HomePage> {
     final TextEditingController _controller = TextEditingController();
     final FirebaseService _firebaseService = FirebaseService();
   
     @override
     Widget build(BuildContext context) {
       return Scaffold(
         appBar: AppBar(title: Text('Firebase Realtime Database')),
         body: Padding(
           padding: const EdgeInsets.all(20.0),
           child: Column(
             children: [
               TextField(
                 controller: _controller,
                 decoration: InputDecoration(labelText: 'Entrez un message'),
               ),
               SizedBox(height: 10),
               ElevatedButton(
                 onPressed: _writeData,
                 child: Text('Écrire dans Firebase'),
               ),
               SizedBox(height: 20),
               Expanded(child: _buildMessageList()),
             ],
           ),
         ),
       );
     }
   
     void _writeData() {
       String message = _controller.text.trim();
       if (message.isNotEmpty) {
         _firebaseService.writeMessage(message);
         _controller.clear();
       }
     }
   
     Widget _buildMessageList() {
       return StreamBuilder<DatabaseEvent>(
         stream: _firebaseService.getMessagesStream(),
         builder: (context, snapshot) {
           if (snapshot.hasData && snapshot.data!.snapshot.value != null) {
             Map<dynamic, dynamic> messages =
                 snapshot.data!.snapshot.value as Map<dynamic, dynamic>;
             List<MapEntry<dynamic, dynamic>> entries = messages.entries.toList().reversed.toList();
   
             return ListView.builder(
               itemCount: entries.length,
               itemBuilder: (context, index) {
                 String key = entries[index].key;
                 String text = entries[index].value['text'] ?? '';
   
                 return ListTile(
                   title: Text(text),
                   trailing: PopupMenuButton<String>(
                     onSelected: (value) {
                       if (value == 'modifier') {
                         _editMessageDialog(key, text);
                       } else if (value == 'supprimer') {
                         _firebaseService.deleteMessage(key);
                       }
                     },
                     itemBuilder: (context) => [
                       PopupMenuItem(value: 'modifier', child: Text('Modifier')),
                       PopupMenuItem(value: 'supprimer', child: Text('Supprimer')),
                     ],
                   ),
                 );
               },
             );
           } else {
             return Center(child: Text('Aucun message trouvé.'));
           }
         },
       );
     }
   
     void _editMessageDialog(String key, String currentText) {
       TextEditingController editController = TextEditingController(text: currentText);
   
       showDialog(
         context: context,
         builder: (context) {
           return AlertDialog(
             title: Text('Modifier le message'),
             content: TextField(
               controller: editController,
               decoration: InputDecoration(labelText: 'Nouveau message'),
             ),
             actions: [
               TextButton(
                 child: Text('Annuler'),
                 onPressed: () => Navigator.of(context).pop(),
               ),
               ElevatedButton(
                 child: Text('Enregistrer'),
                 onPressed: () {
                   String newText = editController.text.trim();
                   if (newText.isNotEmpty) {
                     _firebaseService.updateMessage(key, newText);
                   }
                   Navigator.of(context).pop();
                 },
               ),
             ],
           );
         },
       );
     }
   }