À propos de ce cours
- Chaque utilisateur reçoit un UID unique, qui ne change pas même si son e-mail change.
- Auth ne stocke que l'identité (e-mail, mot de passe haché, UID). Le rôle et le statut de validation se rangent dans Firestore, dans le document users/{uid}.
- Dans l'application, le code suit le modèle vues → contrôleur → service : les vues n'appellent jamais Firebase directement.
Travailler avec Firebase Authentication dans Flutter

1. Objectifs et projet fil rouge
À la fin de ce cours, vous serez capable de :
- comprendre les différents modes d'authentification Firebase ;
- implémenter l'authentification e-mail / mot de passe, Google et anonyme ;
- gérer l'état de connexion dans Flutter (navigation automatique) ;
- attribuer des rôles aux utilisateurs avec Cloud Firestore ;
- sécuriser l'accès aux données avec les règles Firestore.
Comment utiliser ce cours : chaque partie présente une notion avec un exemple complet (l'application « Ma Bibliothèque »). Elle se termine par une activité où vous construisez votre propre application, étape par étape. Les activités ne donnent pas les réponses : elles posent des questions qui vous guident. Vous devez chercher dans le cours, dans la documentation officielle et en testant.
Projet fil rouge des activités : « ClubApp », l'application d'un club étudiant.
• Un membre s'inscrit et consulte les événements du club.
• Un organisateur crée des événements.
• Un administrateur valide les nouveaux comptes.
• Un visiteur peut entrer en invité sans créer de compte.
Les rôles et les écrans sont différents de l'exemple du cours : vous devez adapter le code, pas le recopier.
🛠 Activité 1 — Analyser le besoin de ClubApp
Mission : Avant d'écrire du code, rédigez une courte fiche d'analyse (½ page) de l'application ClubApp.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Quels sont les trois rôles de ClubApp ? Pour chacun, que peut-il voir et que peut-il faire?
- Quelles informations faut-il connaître sur un utilisateur pour savoir s'il a le droit de créer un événement ?
- Quelle est la différence entre s'authentifier (« qui êtes-vous ? ») et être autorisé (« avez-vous le droit ? ») ? Donnez un exemple tiré de ClubApp pour chaque notion.
- Que doit voir un visiteur qui ouvre l'application pour la première fois ? Et un membre dont le compte n'est pas encore validé ?
- Dessinez sur papier les écrans de l'application et les flèches de navigation entre eux. Combien d'écrans comptez-vous ?
Je vérifie / je rends :
- ☐ La fiche d'analyse avec le tableau rôles / droits.
- ☐ Le schéma des écrans (photo ou dessin).
2. Introduction à Firebase Authentication
Firebase Authentication est un service backend proposé par Google Firebase. Il permet d'authentifier les utilisateurs d'une application de manière simple et sécurisée. Il prend en charge plusieurs méthodes : adresse e-mail et mot de passe, numéro de téléphone, comptes Google, Apple, GitHub, etc.
En quoi consiste ce service ? Sans Firebase, vous devriez programmer vous-même :
- la création des comptes et le stockage sécurisé des mots de passe (hachage) ;
- la vérification des adresses e-mail ;
- la réinitialisation des mots de passe ;
- la gestion des sessions et des jetons de connexion ;
- la protection contre les attaques (force brute, vol de session…).
Firebase Authentication fait tout ce travail complexe pour vous. Chaque utilisateur reçoit un identifiant unique, l'UID, qui servira de « clé » pour relier ses données dans Firestore.

Figure 1 — Rôle de chaque brique : Auth identifie, Firestore stocke le profil, les règles protègent.
Fonctionnalités principales :
- Plusieurs fournisseurs: e-mail / mot de passe, téléphone, Google, Facebook, Apple, GitHub, anonyme…
- Intégration facile: des SDK officiels (dont FlutterFire pour Flutter) en quelques lignes de code.
- Sécurité: chiffrement, jetons signés et protocoles conformes aux normes du secteur.
- Gestion des utilisateurs: création, réinitialisation du mot de passe, vérification de l'e-mail, suppression.
- Personnalisation: interface libre, authentification multifacteur, politique de mots de passe.
Vidéo du cours (le code présenté dans la vidéo correspond à la partie 6, dans sa version corrigée) :
🛠 Activité 2 — Comprendre le rôle de Firebase Authentication
Mission : Répondez aux questions suivantes en vous aidant du cours et de la documentation officielle.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Pourquoi est-il dangereux de stocker soi-même les mots de passe « en clair » dans une base de données ?
- Qu'est-ce qu'un UID ? Qui le crée ? Peut-il changer si l'utilisateur modifie son e-mail ?
- Firebase Authentication peut-il stocker le rôle (membre, organisateur, admin) d'un utilisateur de ClubApp ? Si non, où le rangerez-vous ?
- Observez la figure 1 : pour ClubApp, quelle brique répond à la question « qui êtes-vous ? » et laquelle répond à « que pouvez-vous faire ? » ?
Je vérifie / je rends :
- ☐ Réponses rédigées dans votre compte rendu.
3. Les méthodes d'authentification utilisées dans ce cours
Firebase propose de nombreux fournisseurs. Dans ce cours, nous en utilisons trois :
3.1 E-mail / mot de passe
- L'utilisateur crée un compte avec un e-mail et un mot de passe, puis saisit ses identifiants pour se connecter.
- Exemple :
_auth.createUserWithEmailAndPassword(email: "...", password: "..."); - Avantage : simple, classique, ne dépend d'aucun compte externe.
- Inconvénient : l'utilisateur doit retenir un mot de passe ; l'e-mail n'est pas vérifié tant que vous n'appelez pas
sendEmailVerification().
3.2 Google Sign-In
- Aucun mot de passe à saisir : l'utilisateur clique, choisit son compte Google et il est connecté.
- Google fournit automatiquement l'e-mail, le nom, la photo et un jeton sécurisé.
- Exemple :
final googleUser = await GoogleSignIn().signIn(); - Avantage : rapide, très sécurisé, e-mail déjà vérifié par Google.
- Inconvénient : configuration plus longue (empreintes SHA-1 / SHA-256 sur Android) et compte Google obligatoire.
3.3 Anonyme
- Ni e-mail, ni mot de passe : Firebase crée un utilisateur temporaire sans identité (il possède quand même un UID).
- Exemple :
FirebaseAuth.instance.signInAnonymously(); - Avantages : accès immédiat en invité, idéal pour « essayer avant de s'inscrire ».
- Inconvénients : pas de profil, pas d'e-mail ; si l'application est désinstallée, le compte est perdu, sauf s'il a été lié à un compte e-mail ou Google.
3.4 Résumé
| Méthode | E-mail ? | Mot de passe ? | Pop-up Google ? | Identité vérifiée ? |
|---|---|---|---|---|
| E-mail / mot de passe | ✔ oui | ✔ oui | ✖ non | ⚠ seulement après vérification de l'e-mail |
| Google Sign-In | ✔ récupéré automatiquement | ✖ non | ✔ oui | ✔ oui |
| Anonyme | ✖ non | ✖ non | ✖ non | ✖ non |
🛠 Activité 3 — Choisir les méthodes de ClubApp
Mission : Décidez quelles méthodes de connexion ClubApp proposera et justifiez chaque choix.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Recopiez et complétez ce tableau : Situation | Méthode adaptée | Pourquoi ? — pour : (a) un étudiant qui veut juste voir le programme des événements ; (b) un organisateur qui se connecte chaque semaine ; (c) un membre sans compte Google.
- Un invité (anonyme) décide de s'inscrire. Que perd-il si l'on crée un nouveau compte au lieu de lier son compte anonyme ? Cherchez le nom de la méthode Firebase qui permet de lier un compte.
- Pourquoi le tableau 3.4 indique-t-il que l'identité n'est pas vérifiée pour un compte e-mail / mot de passe ? Comment ClubApp pourrait-elle la vérifier ?
- Quelle méthode demandera le plus de configuration côté Android ? Notez ce qu'il faudra préparer.
Je vérifie / je rends :
- ☐ Le tableau complété et justifié.
- ☐ La liste des méthodes retenues pour ClubApp.
4. Configurer Authentication dans la console Firebase
- Ouvrez https://console.firebase.google.com/, cliquez sur « Accéder à la console » et sélectionnez votre projet (ou créez-en un avec « Ajouter un projet »).
- Dans le menu de gauche, ouvrez Créer › Authentication:

Figure 2 — Accès au produit Authentication.
- Une page de présentation du produit s'affiche. Cliquez sur « Commencer »:

Figure 3 — Activation du produit Authentication (illustration simplifiée).
- Choisissez ensuite les méthodes de connexion que vous allez accepter (onglet Sign-in method) :

Figure 4 — Fournisseurs natifs, supplémentaires et personnalisés.
- Dans Fournisseurs natifs, cliquez sur « Adresse e-mail/Mot de passe ». Activez la première option, mais pas « Lien envoyé par e-mail (connexion sans mot de passe) », qui demande une configuration supplémentaire. Cliquez sur Enregistrer.

Figure 5 — Activation du fournisseur e-mail / mot de passe.
- Seul le fournisseur e-mail / mot de passe est activé. Cliquez sur « Ajouter un fournisseur »:

Figure 6 — Premier fournisseur activé.
- Choisissez « Anonyme », activez-le puis cliquez sur Enregistrer:

Figure 7 — Activation du mode anonyme.
- Ajoutez enfin le fournisseur « Google »: ① activez-le ; ② vous pouvez garder le « Nom public » par défaut ; ③ choisissez l'« Adresse e-mail d'assistance » (celle de votre compte Google) ; ④ cliquez sur Enregistrer. La note concernant l'empreinte SHA-1 sera traitée à la partie 7.

Figure 8 — Paramètres du fournisseur Google (illustration simplifiée).
Les trois fournisseurs apparaissent maintenant comme activés:

Figure 9 — Fournisseurs activés.
🛠 Activité 4 — Créer et configurer le projet Firebase de ClubApp
Mission : Créez votre propre projet Firebase nommé clubapp-votrenom et activez les fournisseurs que vous avez choisis à l'activité 3.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Lors de la création du projet, Firebase propose d'activer Google Analytics. Est-ce utile pour ce TP ? Quelle conséquence a votre choix ?
- Pourquoi le cours conseille-t-il de ne pas activer « Lien envoyé par e-mail » maintenant ? Que faudrait-il configurer en plus ?
- À quoi sert l'« adresse e-mail d'assistance » du fournisseur Google ? Qui la verra ?
- Dans l'onglet Users, créez à la main un utilisateur de test. Quel UID Firebase lui a-t-il attribué ? Notez-le.
- Dans l'onglet Settings › Actions utilisateur (ou User actions), que signifie l'option « Protection contre l'énumération des adresses e-mail » ? Gardez la réponse : elle servira à l'activité 6.
Je vérifie / je rends :
- ☐ Capture de l'onglet Sign-in method avec vos fournisseurs activés.
- ☐ Capture de l'onglet Users avec votre utilisateur de test.
5. Connecter une application Flutter à Firebase
5.1 Installer les dépendances
Dans le dossier de votre projet Flutter, ajoutez les paquets avec la commande flutter pub add (elle choisit des versions compatibles entre elles) :
flutter pub add firebase_core firebase_auth cloud_firestore intl
flutter pub add google_sign_in:^6.2.1
Votre pubspec.yaml doit ressembler à ceci (versions indicatives, novembre 2026) :
dependencies:
flutter:
sdk: flutter
firebase_core: ^4.2.1
firebase_auth: ^6.1.2
cloud_firestore: ^6.1.0
google_sign_in: ^6.2.1
intl: ^0.20.2
Les paquets Firebase récents exigent minSdk 23 sur Android. Ouvrez
android/app/build.gradle.kts (ou build.gradle) et vérifiez : minSdk = 23 (ou plus).5.2 Générer la configuration avec FlutterFire CLI (méthode recommandée)
La commande flutterfire configure enregistre votre application dans le projet Firebase, crée lib/firebase_options.dart et place google-services.json dans android/app/.

Figure 10 — Installation des outils et génération de la configuration.
npm install -g firebase-tools # une seule fois sur la machine
firebase login
dart pub global activate flutterfire_cli
flutterfire configure # dans le dossier du projet Flutter
Alternative manuelle (si la CLI n'est pas disponible en salle de TP) : écrivez vous-même firebase_options.dart en recopiant les valeurs de votre google-services.json.
firebase_options.dart (version manuelle)
// lib/firebase_options.dart (version manuelle, Android uniquement)
import 'package:firebase_core/firebase_core.dart';
/*
Correspondance avec android/app/google-services.json :
api_key[0].current_key -> apiKey
client[0].client_info.mobilesdk_app_id -> appId
project_info.project_number -> messagingSenderId
project_info.project_id -> projectId
project_info.storage_bucket -> storageBucket
*/
class DefaultFirebaseOptions {
static const FirebaseOptions android = FirebaseOptions(
apiKey: 'VOTRE_API_KEY',
appId: 'VOTRE_APP_ID',
messagingSenderId: 'VOTRE_PROJECT_NUMBER',
projectId: 'VOTRE_PROJECT_ID',
storageBucket: 'VOTRE_STORAGE_BUCKET',
);
static FirebaseOptions get currentPlatform => android;
}
5.3 Initialiser Firebase au démarrage
import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
Future<void> main() async {
// Obligatoire avant tout appel asynchrone fait avant runApp()
WidgetsFlutterBinding.ensureInitialized();
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
runApp(const MyApp());
}
🛠 Activité 5 — Créer l'application Flutter ClubApp et la relier à Firebase
Mission : Créez le projet club_app avec flutter create, installez les dépendances, générez la configuration et lancez l'application sur un émulateur Android.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Quel package name (applicationId) Android votre projet a-t-il reçu ? Où le trouvez-vous dans le projet ? Pourquoi Firebase en a-t-il besoin ?
- Après
flutterfire configure, quels fichiers ont été créés ou modifiés ? Ouvrezfirebase_options.dart: à quelle clé degoogle-services.jsoncorrespondprojectId? - Que se passe-t-il si vous supprimez la ligne
WidgetsFlutterBinding.ensureInitialized();? Et si vous retirez le motawaitdevantFirebase.initializeApp? Testez et notez le message d'erreur exact. - Votre fichier
build.gradle(.kts)respecte-t-il la valeur minimale deminSdk? Que se passe-t-il à la compilation sinon ? - Pourquoi
flutter pub addest-il plus sûr que de taper les numéros de version à la main ?
Je vérifie / je rends :
- ☐ L'application démarre sans erreur Firebase dans la console de débogage.
- ☐ Capture de la page « Paramètres du projet » montrant votre application Android enregistrée.
Piste (sans solution) : si l'application plante au démarrage, lisez le premier message d'erreur dans le terminal avant de modifier quoi que ce soit.
6. Authentification e-mail / mot de passe
Nous construisons une petite application avec une page de connexion, une page d'inscription et une page d'accueil. L'organisation du code suit le modèle vues / contrôleur:
lib/
├── controllers/
│ └── auth_controller.dart ← toute la logique Firebase Auth
├── views/
│ ├── login_view.dart ← page de connexion
│ ├── signup_view.dart ← page d'inscription
│ └── home_view.dart ← page d'accueil
├── firebase_options.dart
└── main.dart ← initialisation + AuthWrapper
6.1 Le contrôleur d'authentification
Les vues n'appellent jamais Firebase directement : elles passent par le contrôleur, qui renvoie null en cas de succès ou un message d'erreur lisible.
controllers/auth_controller.dart
import 'package:firebase_auth/firebase_auth.dart';
/// Contrôleur responsable de l'authentification via Firebase.
/// Chaque méthode retourne :
/// • null -> succès
/// • String -> message d'erreur à afficher dans l'interface
class AuthController {
final FirebaseAuth _auth = FirebaseAuth.instance;
/// Utilisateur actuellement connecté (ou null).
User? get currentUser => _auth.currentUser;
/// Flux qui émet un User à la connexion et null à la déconnexion.
Stream<User?> authStateChanges() => _auth.authStateChanges();
// ------------------------------------------------------------------
// Connexion e-mail / mot de passe
// ------------------------------------------------------------------
Future<String?> login({
required String email,
required String password,
}) async {
try {
await _auth.signInWithEmailAndPassword(
email: email.trim(),
password: password, // on ne "trim" pas un mot de passe
);
return null;
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
}
}
// ------------------------------------------------------------------
// Inscription e-mail / mot de passe
// ------------------------------------------------------------------
Future<String?> register({
required String email,
required String password,
}) async {
try {
await _auth.createUserWithEmailAndPassword(
email: email.trim(),
password: password,
);
return null; // l'utilisateur est automatiquement connecté
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
}
}
// ------------------------------------------------------------------
// Mot de passe oublié
// ------------------------------------------------------------------
Future<String?> resetPassword(String email) async {
try {
await _auth.sendPasswordResetEmail(email: email.trim());
return null;
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
}
}
// ------------------------------------------------------------------
// Déconnexion
// ------------------------------------------------------------------
Future<void> logout() async {
await _auth.signOut();
}
// ------------------------------------------------------------------
// Traduction des codes d'erreur Firebase
// ------------------------------------------------------------------
String getErrorMessage(FirebaseAuthException e) {
switch (e.code) {
// Projets récents : la protection contre l'énumération des e-mails
// remplace user-not-found / wrong-password par invalid-credential.
case 'invalid-credential':
case 'user-not-found':
case 'wrong-password':
return 'E-mail ou mot de passe incorrect.';
case 'invalid-email':
return "L'adresse e-mail n'est pas valide.";
case 'email-already-in-use':
return 'Cet e-mail est déjà utilisé.';
case 'weak-password':
return 'Le mot de passe est trop faible (6 caractères minimum).';
case 'user-disabled':
return 'Ce compte est désactivé.';
case 'too-many-requests':
return 'Trop de tentatives. Réessayez dans quelques minutes.';
case 'network-request-failed':
return 'Pas de connexion Internet.';
case 'operation-not-allowed':
return "Cette méthode de connexion n'est pas activée dans la console Firebase.";
default:
return 'Erreur : ${e.message}';
}
}
}
• Sur les projets créés depuis septembre 2023, Firebase renvoie
invalid-credential au lieu de user-not-found / wrong-password: l'ancien switch affichait donc un message brut en anglais.• L'ancienne page de connexion appelait
FirebaseAuth directement au lieu du contrôleur : toutes les vues passent maintenant par AuthController. 6.2 La page de connexion
views/login_view.dart
import 'package:flutter/material.dart';
import '../controllers/auth_controller.dart';
import 'signup_view.dart';
class LoginView extends StatefulWidget {
const LoginView({super.key});
@override
State<LoginView> createState() => _LoginViewState();
}
class _LoginViewState extends State<LoginView> {
final auth = AuthController();
final emailController = TextEditingController();
final passwordController = TextEditingController();
bool isLoading = false;
String? errorMessage;
@override
void dispose() {
emailController.dispose();
passwordController.dispose();
super.dispose();
}
Future<void> login() async {
setState(() {
isLoading = true;
errorMessage = null;
});
final error = await auth.login(
email: emailController.text,
password: passwordController.text,
);
// Le widget a pu disparaître pendant l'attente (connexion réussie)
if (!mounted) return;
setState(() {
isLoading = false;
errorMessage = error;
});
// En cas de succès, AuthWrapper (main.dart) affiche HomeView tout seul.
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Container(
width: double.infinity,
decoration: const BoxDecoration(
gradient: LinearGradient(
colors: [Color(0xFF6A11CB), Color(0xFF2575FC)],
begin: Alignment.topLeft,
end: Alignment.bottomRight,
),
),
child: Center(
child: SingleChildScrollView(
child: Container(
padding: const EdgeInsets.all(24),
margin: const EdgeInsets.symmetric(horizontal: 25),
decoration: BoxDecoration(
color: Colors.white.withValues(alpha: 0.95),
borderRadius: BorderRadius.circular(20),
boxShadow: [
BoxShadow(
color: Colors.black.withValues(alpha: 0.2),
blurRadius: 12,
offset: const Offset(0, 6),
),
],
),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
const Icon(Icons.lock_outline, size: 70, color: Color(0xFF6A11CB)),
const SizedBox(height: 15),
const Text(
'Bienvenue',
style: TextStyle(
fontSize: 26,
fontWeight: FontWeight.bold,
color: Color(0xFF6A11CB),
),
),
const SizedBox(height: 25),
// -------- E-mail ----------
TextField(
controller: emailController,
keyboardType: TextInputType.emailAddress,
decoration: InputDecoration(
labelText: 'E-mail',
prefixIcon: const Icon(Icons.email_outlined),
border: OutlineInputBorder(borderRadius: BorderRadius.circular(15)),
),
),
const SizedBox(height: 15),
// -------- Mot de passe ----------
TextField(
controller: passwordController,
obscureText: true,
decoration: InputDecoration(
labelText: 'Mot de passe',
prefixIcon: const Icon(Icons.lock_outline),
border: OutlineInputBorder(borderRadius: BorderRadius.circular(15)),
),
),
const SizedBox(height: 15),
// -------- Message d'erreur ----------
if (errorMessage != null)
Container(
padding: const EdgeInsets.all(12),
decoration: BoxDecoration(
color: Colors.redAccent.withValues(alpha: 0.2),
borderRadius: BorderRadius.circular(10),
),
child: Text(
errorMessage!,
style: const TextStyle(color: Colors.red, fontWeight: FontWeight.bold),
textAlign: TextAlign.center,
),
),
const SizedBox(height: 20),
// -------- Bouton Se connecter ----------
SizedBox(
width: double.infinity,
child: ElevatedButton(
onPressed: isLoading ? null : login,
style: ElevatedButton.styleFrom(
padding: const EdgeInsets.symmetric(vertical: 14),
backgroundColor: const Color(0xFF6A11CB),
shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
),
child: isLoading
? const SizedBox(
height: 22,
width: 22,
child: CircularProgressIndicator(color: Colors.white, strokeWidth: 2),
)
: const Text('Se connecter',
style: TextStyle(fontSize: 18, color: Colors.white)),
),
),
const SizedBox(height: 10),
TextButton(
onPressed: () {
Navigator.push(
context,
MaterialPageRoute(builder: (_) => const SignUpView()),
);
},
child: const Text('Créer un compte',
style: TextStyle(color: Colors.black54)),
),
],
),
),
),
),
),
);
}
}
6.3 La page d'inscription
views/signup_view.dart
import 'package:flutter/material.dart';
import '../controllers/auth_controller.dart';
class SignUpView extends StatefulWidget {
const SignUpView({super.key});
@override
State<SignUpView> createState() => _SignUpViewState();
}
class _SignUpViewState extends State<SignUpView> {
final auth = AuthController();
final emailController = TextEditingController();
final passwordController = TextEditingController();
String? errorMessage;
bool isLoading = false;
@override
void dispose() {
emailController.dispose();
passwordController.dispose();
super.dispose();
}
Future<void> register() async {
setState(() {
isLoading = true;
errorMessage = null;
});
final error = await auth.register(
email: emailController.text,
password: passwordController.text,
);
if (!mounted) return;
if (error == null) {
// Firebase a connecté le nouvel utilisateur : on ferme cette page,
// AuthWrapper affiche alors HomeView.
Navigator.pop(context);
return;
}
setState(() {
errorMessage = error;
isLoading = false;
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Container(
padding: const EdgeInsets.symmetric(horizontal: 25),
decoration: const BoxDecoration(
gradient: LinearGradient(
colors: [Color(0xFF11998E), Color(0xFF38EF7D)],
begin: Alignment.topLeft,
end: Alignment.bottomRight,
),
),
child: Center(
child: SingleChildScrollView(
child: Container(
padding: const EdgeInsets.all(25),
decoration: BoxDecoration(
color: Colors.white.withValues(alpha: 0.95),
borderRadius: BorderRadius.circular(20),
),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
const Text(
'Créer un compte',
style: TextStyle(
fontSize: 26,
fontWeight: FontWeight.bold,
color: Color(0xFF11998E),
),
),
const SizedBox(height: 25),
TextField(
controller: emailController,
keyboardType: TextInputType.emailAddress,
decoration: InputDecoration(
labelText: 'E-mail',
prefixIcon: const Icon(Icons.email_outlined),
border: OutlineInputBorder(borderRadius: BorderRadius.circular(15)),
),
),
const SizedBox(height: 15),
TextField(
controller: passwordController,
obscureText: true,
decoration: InputDecoration(
labelText: 'Mot de passe (6 caractères min.)',
prefixIcon: const Icon(Icons.lock_outline),
border: OutlineInputBorder(borderRadius: BorderRadius.circular(15)),
),
),
const SizedBox(height: 20),
if (errorMessage != null)
Text(
errorMessage!,
style: const TextStyle(color: Colors.red),
textAlign: TextAlign.center,
),
const SizedBox(height: 20),
SizedBox(
width: double.infinity,
child: ElevatedButton(
onPressed: isLoading ? null : register,
style: ElevatedButton.styleFrom(
padding: const EdgeInsets.symmetric(vertical: 12),
backgroundColor: const Color(0xFF11998E),
shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
),
child: isLoading
? const SizedBox(
height: 22,
width: 22,
child: CircularProgressIndicator(color: Colors.white, strokeWidth: 2),
)
: const Text("S'inscrire",
style: TextStyle(fontSize: 18, color: Colors.white)),
),
),
const SizedBox(height: 10),
TextButton(
onPressed: () => Navigator.pop(context),
child: const Text('Déjà un compte ? Se connecter'),
),
],
),
),
),
),
),
);
}
}
6.4 La page d'accueil
views/home_view.dart
import 'package:flutter/material.dart';
import 'package:firebase_auth/firebase_auth.dart';
import '../controllers/auth_controller.dart';
class HomeView extends StatelessWidget {
const HomeView({super.key});
@override
Widget build(BuildContext context) {
final user = FirebaseAuth.instance.currentUser;
return Scaffold(
appBar: AppBar(
title: const Text('Accueil'),
backgroundColor: Colors.deepPurple,
foregroundColor: Colors.white,
actions: [
IconButton(
icon: const Icon(Icons.logout),
tooltip: 'Se déconnecter',
// Pas de navigation manuelle : AuthWrapper réaffiche LoginView.
onPressed: () => AuthController().logout(),
),
],
),
body: Center(
child: Text(
'Bienvenue ${user?.email ?? 'Invité'}',
style: const TextStyle(fontSize: 22),
),
),
);
}
}
L'ancienne page d'accueil appelait
Navigator.pushReplacementNamed('/login') alors qu'aucune route nommée n'était déclarée : l'application plantait à la déconnexion. C'est désormais le flux authStateChanges() qui gère l'affichage.6.5 La navigation automatique (main.dart)

Figure 11 — AuthWrapper choisit l'écran selon l'état de connexion.
main.dart
import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'firebase_options.dart';
import 'views/login_view.dart';
import 'views/home_view.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return const MaterialApp(
title: 'Ma Bibliothèque',
debugShowCheckedModeBanner: false,
home: AuthWrapper(),
);
}
}
/// Affiche LoginView ou HomeView selon l'état de connexion.
class AuthWrapper extends StatelessWidget {
const AuthWrapper({super.key});
@override
Widget build(BuildContext context) {
return StreamBuilder<User?>(
stream: FirebaseAuth.instance.authStateChanges(),
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return const Scaffold(body: Center(child: CircularProgressIndicator()));
}
if (snapshot.hasData) {
return const HomeView(); // connecté
}
return const LoginView(); // non connecté
},
);
}
}
6.6 Créer un premier utilisateur pour tester
- Depuis la console (rapide) : Authentication › Users › Ajouter un utilisateur, saisissez un e-mail (ex.
test@example.com) et un mot de passe d'au moins 6 caractères. - Depuis l'application: utilisez la page « Créer un compte », qui appelle
createUserWithEmailAndPassword.
🛠 Activité 6 — Connexion et inscription par e-mail dans ClubApp
Mission : Ajoutez à ClubApp un contrôleur d'authentification, une page de connexion, une page d'inscription et une page d'accueil qui affiche « Bonjour + e-mail ». Personnalisez les couleurs et les textes pour ClubApp.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Pourquoi les méthodes du contrôleur renvoient-elles
Future<String?>plutôt que de lancer une exception vers la vue ? Quel avantage pour l'interface ? - Testez une connexion avec un mauvais mot de passe. Quel
e.codeobtenez-vous réellement ? Faites le lien avec votre réponse à la dernière question de l'activité 4. - Testez une inscription avec un mot de passe de 4 caractères, puis avec un e-mail déjà utilisé. Les messages sont-ils compréhensibles pour un membre du club ?
- Pourquoi teste-t-on
if (!mounted) return;après unawait? Que se passerait-il sans ce test quand la connexion réussit ? - À quoi sert la méthode
dispose()des pages ? Que risque-t-on si on l'oublie ? - Ajoutez un lien « Mot de passe oublié ? » qui utilise
resetPassword. Où l'e-mail de réinitialisation arrive-t-il ? Peut-on modifier son texte dans la console ? - Bonus : comment empêcher l'envoi du formulaire si l'e-mail ne contient pas « @ » ? Cherchez ce que sont
FormetTextFormField.
Je vérifie / je rends :
- ☐ Inscription, connexion, erreur et réinitialisation fonctionnent.
- ☐ Le nouvel utilisateur apparaît dans l'onglet Users de la console (capture).
🛠 Activité 7 — Comprendre la navigation automatique
Mission : Étudiez le fonctionnement de AuthWrapper dans ClubApp.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Placez un
print()dans lebuilderduStreamBuilder. Combien de fois s'affiche-t-il au démarrage, à la connexion, à la déconnexion ? - Pourquoi n'a-t-on pas besoin de
Navigator.push(... HomeView())après une connexion réussie ? - Fermez complètement l'application puis relancez-la : êtes-vous toujours connecté ? Qui a mémorisé la session ?
- Après une inscription réussie, pourquoi la page d'inscription doit-elle faire
Navigator.pop(context)? Que verrait l'utilisateur sans cette ligne ?
Je vérifie / je rends :
- ☐ Un court paragraphe qui explique, avec vos mots, le schéma de la figure 11 appliqué à ClubApp.
7. Authentification Google Sign-In

Figure 12 — Google fournit des jetons, Firebase les transforme en utilisateur.
7.1 Préparer le projet
Le paquet google_sign_in a été ajouté à la partie 5.1 (version 6.x). Vérifiez que le fournisseur Google est activé dans la console (partie 4, figure 8).
7.2 Obtenir les empreintes SHA-1 et SHA-256 (étape obligatoire sur Android)
Sans cette étape, vous obtenez l'erreur PlatformException(sign_in_failed, ApiException: 10). Google doit reconnaître votre application grâce à l'empreinte du certificat qui la signe.
- Méthode recommandée (Gradle): ouvrez un terminal à la racine du projet Flutter, puis :
- macOS / Linux :
cd androidpuis./gradlew signingReport - Windows :
cd androidpuis.\gradlew signingReport
- macOS / Linux :
- Avec Android Studio: ouvrez le dossier
android/comme projet, puis Gradle › app › Tasks › android › signingReport. - Avec keytool (clé de debug) :
keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android
Copiez les valeurs SHA1 et SHA-256 de la variante debug (et release si vous publiez l'application).

Figure 13 — Les empreintes à copier (valeurs fictives).
7.3 Ajouter les empreintes dans Firebase
- Console Firebase › Paramètres du projet (roue dentée).
- Sous Vos applications, sélectionnez votre application Android.
- Dans Empreintes de certificat SHA, cliquez sur Ajouter une empreinte, collez le SHA-1 et enregistrez.
- Recommencez pour le SHA-256.
- Mettez à jour la configuration : relancez
flutterfire configure, ou téléchargez le nouveaugoogle-services.jsonet remplacezandroid/app/google-services.json.

Figure 14 — Empreintes SHA-1 et SHA-256 enregistrées.
7.4 Ajouter Google Sign-In dans le contrôleur
Ajouts dans controllers/auth_controller.dart
// En haut du fichier auth_controller.dart
import 'package:google_sign_in/google_sign_in.dart';
// Dans la classe AuthController
final GoogleSignIn _googleSignIn = GoogleSignIn(scopes: ['email']);
// ------------------------------------------------------------------
// Connexion via Google Sign-In + Firebase
// ------------------------------------------------------------------
Future<String?> signInWithGoogle() async {
try {
// 1- Ouvre la fenêtre Google. null si l'utilisateur ferme la pop-up.
final GoogleSignInAccount? googleUser = await _googleSignIn.signIn();
if (googleUser == null) return 'Connexion annulée';
// 2- Récupère les jetons Google (accessToken et idToken).
final GoogleSignInAuthentication googleAuth = await googleUser.authentication;
// 3- Transforme ces jetons en identifiants Firebase.
final AuthCredential credential = GoogleAuthProvider.credential(
accessToken: googleAuth.accessToken,
idToken: googleAuth.idToken,
);
// 4- Connexion à Firebase : authStateChanges() émet le nouvel utilisateur.
await _auth.signInWithCredential(credential);
return null;
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
} catch (e) {
// Erreurs Google (ApiException: 10, réseau…)
return 'Erreur Google Sign-In : $e';
}
}
// ------------------------------------------------------------------
// Déconnexion (remplace l'ancienne méthode logout)
// ------------------------------------------------------------------
Future<void> logout() async {
await _googleSignIn.signOut(); // sinon Google reconnecte le même compte sans demander
await _auth.signOut();
}
7.5 Ajouter le bouton Google dans la page de connexion
Ajouts dans views/login_view.dart
// Dans _LoginViewState : nouvel état et nouvelle méthode
bool isLoadingGoogle = false;
Future<void> loginWithGoogle() async {
setState(() {
isLoadingGoogle = true;
errorMessage = null;
});
final error = await auth.signInWithGoogle();
if (!mounted) return;
setState(() {
isLoadingGoogle = false;
errorMessage = error;
});
}
// Dans build(), sous le bouton « Se connecter »
const SizedBox(height: 12),
SizedBox(
width: double.infinity,
child: OutlinedButton.icon(
onPressed: isLoadingGoogle ? null : loginWithGoogle,
icon: isLoadingGoogle
? const SizedBox(height: 18, width: 18, child: CircularProgressIndicator(strokeWidth: 2))
: const Icon(Icons.g_mobiledata, size: 28, color: Colors.red),
label: const Text('Continuer avec Google'),
),
),
🛠 Activité 8 — Ajouter la connexion Google à ClubApp
Mission : Configurez les empreintes SHA de votre machine et ajoutez le bouton « Continuer avec Google » à ClubApp.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Qu'est-ce qu'une empreinte SHA-1 ? Pourquoi celle de votre PC est-elle différente de celle de votre voisin ?
- Faites volontairement l'expérience : lancez la connexion Google avant d'ajouter le SHA-1. Quel message obtenez-vous ? Notez-le dans votre fiche de dépannage.
- Pourquoi faut-il mettre à jour
google-services.jsonaprès avoir ajouté une empreinte ? - Que contient
googleUsersi l'utilisateur ferme la fenêtre Google sans choisir de compte ? Comment votre code le gère-t-il ? - Retirez la ligne
_googleSignIn.signOut()delogout(), déconnectez-vous puis reconnectez-vous avec Google. Que constatez-vous ? Remettez la ligne. - Quelles informations supplémentaires (nom, photo) pouvez-vous afficher sur la page d'accueil pour un utilisateur Google ? Quelles propriétés de
Userutiliser ? - Votre application release (publiée) utilisera-t-elle le même SHA-1 que la version debug ? Que faudra-t-il faire avant une publication ?
Je vérifie / je rends :
- ☐ Connexion Google fonctionnelle, avec le nom et la photo sur la page d'accueil.
- ☐ La fiche de dépannage commencée (erreur → cause → solution).
8. Authentification anonyme (mode invité)
Le fournisseur « Anonyme » a été activé à la partie 4. Il permet d'entrer dans l'application sans compte. L'utilisateur reçoit un UID, et user.isAnonymous vaut true.
Ajouts dans controllers/auth_controller.dart
// Dans AuthController
Future<String?> signInAsGuest() async {
try {
await _auth.signInAnonymously();
return null;
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
}
}
/// Transforme un compte invité en compte e-mail SANS changer son UID
/// (ses données éventuelles sont conservées).
Future<String?> upgradeGuestToEmail({
required String email,
required String password,
}) async {
try {
final credential = EmailAuthProvider.credential(
email: email.trim(),
password: password,
);
await _auth.currentUser!.linkWithCredential(credential);
return null;
} on FirebaseAuthException catch (e) {
return getErrorMessage(e); // ex. credential-already-in-use
}
}
Ajouts dans les vues
// Dans la page de connexion
TextButton.icon(
onPressed: () async {
final error = await auth.signInAsGuest();
if (!mounted) return;
setState(() => errorMessage = error);
},
icon: const Icon(Icons.person_outline),
label: const Text('Continuer en invité'),
),
// Dans HomeView : adapter l'affichage
final user = FirebaseAuth.instance.currentUser;
final nom = (user == null || user.isAnonymous) ? 'Invité' : (user.email ?? '');
L'ancienne version activait le mode anonyme dans la console mais ne contenait aucun code pour l'utiliser : cette partie est nouvelle.
🛠 Activité 9 — Mode invité dans ClubApp
Mission : Ajoutez un bouton « Découvrir le club en invité ». L'invité voit la page d'accueil mais un bandeau l'invite à créer un compte.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Connectez-vous en invité puis regardez l'onglet Users de la console. Comment Firebase affiche-t-il cet utilisateur ? Quel est son « identifiant » ?
- Quelle propriété de
Userpermet de savoir dans le code qu'il s'agit d'un invité ? Utilisez-la pour cacher les boutons réservés aux membres. - Un invité se déconnecte puis clique de nouveau sur « invité » : obtient-il le même UID ? Pourquoi est-ce un problème pour ses données ?
- Ajoutez sur la page d'accueil un bouton « Créer mon compte » qui transforme l'invité en membre. Quelle méthode du cours utilisez-vous ? L'UID a-t-il changé après l'opération ?
- Que se passe-t-il si l'e-mail choisi par l'invité appartient déjà à un autre compte ? Quel code d'erreur obtenez-vous ?
Je vérifie / je rends :
- ☐ Bouton invité, bandeau et transformation en compte fonctionnels.
- ☐ Capture de la console montrant le même UID avant et après la transformation.
9. Gestion des rôles avec Cloud Firestore
Objectif : combiner Firebase Authentication et Cloud Firestore pour gérer différents rôles (admin, auteur, lecteur) et la validation des comptes par un administrateur.
9.1 Pourquoi deux enregistrements ?
Firebase Authentication ne gère que l'identité (e-mail, mot de passe, UID). Pour attribuer un rôle, il faut stocker des informations supplémentaires dans Cloud Firestore, dans un document dont l'identifiant est l'UID.
| Service | Rôle principal | Exemple de données |
|---|---|---|
| Firebase Authentication | Sécurité, connexion, vérification d'identité | E-mail, mot de passe (haché), UID |
| Cloud Firestore | Informations métier sur l'utilisateur | Rôle, statut de validation, date d'inscription, préférences |
| AuthController / UserService | Logique d'inscription, de connexion et de validation | — |
| AuthWrapper | Oriente l'utilisateur vers la bonne interface | — |
Auth garantit que l'utilisateur existe et peut se connecter ; Firestore décrit qui il est et ce qu'il a le droit de faire.
9.2 Créer la base Firestore
- Console Firebase › Créer › Firestore Database › Créer une base de données.
- Choisissez un emplacement proche de vos utilisateurs (ex.
europe-west1) : il ne pourra plus être modifié. - Démarrez en mode production: tout est interdit par défaut, nous écrirons les règles à la partie 10.
9.3 Fonctionnement général
À l'inscription :
- le compte est créé dans Firebase Auth (
createUserWithEmailAndPassword), qui génère l'UID ; - un document
users/{uid}est ajouté dans Firestore ; - l'utilisateur est déconnecté automatiquement : il ne pourra se connecter qu'après validation par un administrateur.
{
"email": "exemple@domaine.com",
"role": "lecteur",
"isApproved": false,
"createdAt": "<horodatage serveur>"
}
À la connexion : Firebase Auth vérifie l'e-mail et le mot de passe, puis l'application lit users/{uid}: profil absent → refus ; isApproved == false → écran d'attente ; sinon, redirection selon le rôle.

Figure 15 — Décisions prises par AuthWrapper après la connexion.

Figure 16 — Après l'inscription, l'utilisateur apparaît dans la console Firebase.
9.4 Créer le premier administrateur
Personne ne peut valider le premier compte… sauf vous, depuis la console. Inscrivez-vous dans l'application, puis dans Firestore Database › users › (votre UID), modifiez role en "admin" et isApproved en true.

Figure 17 — Collection users : l'identifiant du document est l'UID (illustration simplifiée).
L'ancienne version ne disait pas comment créer le premier administrateur : sans cette étape, aucun compte ne pouvait jamais être validé.
9.5 Architecture du projet
lib/
├── models/
│ └── user_model.dart ← modèle UserModel (rôle, validation)
├── services/
│ └── user_service.dart ← lectures / écritures dans users/{uid}
├── controllers/
│ └── auth_controller.dart ← inscription, connexion, Google, invité
├── views/
│ ├── login_view.dart
│ ├── signup_view.dart ← + choix du rôle
│ ├── pending_view.dart ← compte en attente
│ ├── admin_dashboard_view.dart← validation des comptes
│ └── home_view.dart ← (ou ListeLivresView du chapitre précédent)
└── main.dart ← AuthWrapper : redirection selon le rôle
9.6 Le modèle UserModel
models/user_model.dart
import 'package:cloud_firestore/cloud_firestore.dart';
/// Profil applicatif d'un utilisateur, stocké dans users/{uid}.
class UserModel {
final String uid;
final String email;
final String role; // 'admin', 'auteur' ou 'lecteur'
final bool isApproved; // true si validé par un administrateur
final DateTime createdAt;
const UserModel({
required this.uid,
required this.email,
required this.role,
required this.isApproved,
required this.createdAt,
});
bool get isAdmin => role == 'admin';
/// Construit un UserModel à partir d'un document Firestore.
factory UserModel.fromMap(String uid, Map<String, dynamic> data) {
final ts = data['createdAt'];
return UserModel(
uid: uid,
email: data['email'] as String? ?? '',
role: data['role'] as String? ?? 'lecteur',
isApproved: data['isApproved'] as bool? ?? false,
// createdAt peut être null juste après l'écriture (horodatage serveur en attente)
createdAt: ts is Timestamp ? ts.toDate() : DateTime.now(),
);
}
/// Données à écrire lors de la création du profil.
Map<String, dynamic> toNewDocument() => {
'email': email,
'role': role,
'isApproved': isApproved,
'createdAt': FieldValue.serverTimestamp(),
};
}
9.7 Le service Firestore
services/user_service.dart
import 'package:cloud_firestore/cloud_firestore.dart';
import '../models/user_model.dart';
class UserService {
final CollectionReference<Map<String, dynamic>> _users =
FirebaseFirestore.instance.collection('users');
/// Crée le document users/{uid}.
Future<void> createProfile(UserModel user) {
return _users.doc(user.uid).set(user.toNewDocument());
}
/// Lit le profil une seule fois (null s'il n'existe pas).
Future<UserModel?> getUser(String uid) async {
final doc = await _users.doc(uid).get();
if (!doc.exists) return null;
return UserModel.fromMap(doc.id, doc.data()!);
}
/// Écoute le profil en temps réel (utile pour l'écran d'attente).
Stream<UserModel?> watchUser(String uid) {
return _users.doc(uid).snapshots().map(
(doc) => doc.exists ? UserModel.fromMap(doc.id, doc.data()!) : null,
);
}
/// Comptes en attente de validation (réservé à l'admin par les règles).
Stream<List<UserModel>> watchPendingUsers() {
return _users.where('isApproved', isEqualTo: false).snapshots().map(
(snapshot) => snapshot.docs
.map((doc) => UserModel.fromMap(doc.id, doc.data()))
.toList(),
);
}
Future<void> approveUser(String uid) {
return _users.doc(uid).update({'isApproved': true});
}
/// Supprime le profil Firestore.
/// Le compte Firebase Auth, lui, ne peut être supprimé que par
/// l'utilisateur lui-même ou côté serveur (Admin SDK / Cloud Functions).
Future<void> rejectUser(String uid) {
return _users.doc(uid).delete();
}
}
9.8 Le contrôleur d'authentification complet
controllers/auth_controller.dart (version finale)
import 'package:firebase_auth/firebase_auth.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:google_sign_in/google_sign_in.dart';
import '../models/user_model.dart';
import '../services/user_service.dart';
class AuthController {
final FirebaseAuth _auth = FirebaseAuth.instance;
final GoogleSignIn _googleSignIn = GoogleSignIn(scopes: ['email']);
final UserService _userService = UserService();
User? get currentUser => _auth.currentUser;
Stream<User?> authStateChanges() => _auth.authStateChanges();
// ------------------------------------------------------------------
// Inscription avec rôle (le compte attend la validation de l'admin)
// ------------------------------------------------------------------
Future<String?> register({
required String email,
required String password,
required String role, // 'auteur' ou 'lecteur' uniquement
}) async {
if (role != 'auteur' && role != 'lecteur') return 'Rôle invalide.';
try {
final cred = await _auth.createUserWithEmailAndPassword(
email: email.trim(),
password: password,
);
await _userService.createProfile(UserModel(
uid: cred.user!.uid,
email: email.trim(),
role: role,
isApproved: false,
createdAt: DateTime.now(),
));
await _auth.signOut(); // déconnexion jusqu'à la validation
return null;
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
} on FirebaseException catch (e) {
// Erreur Firestore (ex. permission-denied : vérifiez les règles)
return 'Erreur Firestore : ${e.code}';
}
}
// ------------------------------------------------------------------
// Connexion avec vérification du profil et de la validation
// ------------------------------------------------------------------
Future<String?> login({required String email, required String password}) async {
try {
final cred = await _auth.signInWithEmailAndPassword(
email: email.trim(),
password: password,
);
return await _checkProfile(cred.user!.uid);
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
} on FirebaseException catch (e) {
await _auth.signOut();
return 'Erreur Firestore : ${e.code}';
}
}
// ------------------------------------------------------------------
// Connexion Google : crée le profil à la première connexion
// ------------------------------------------------------------------
Future<String?> signInWithGoogle() async {
try {
final googleUser = await _googleSignIn.signIn();
if (googleUser == null) return 'Connexion annulée';
final googleAuth = await googleUser.authentication;
final credential = GoogleAuthProvider.credential(
accessToken: googleAuth.accessToken,
idToken: googleAuth.idToken,
);
final cred = await _auth.signInWithCredential(credential);
final user = cred.user!;
if (await _userService.getUser(user.uid) == null) {
await _userService.createProfile(UserModel(
uid: user.uid,
email: user.email ?? '',
role: 'lecteur',
isApproved: false,
createdAt: DateTime.now(),
));
}
return await _checkProfile(user.uid);
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
} catch (e) {
return 'Erreur Google Sign-In : $e';
}
}
// ------------------------------------------------------------------
// Invité
// ------------------------------------------------------------------
Future<String?> signInAsGuest() async {
try {
await _auth.signInAnonymously();
return null;
} on FirebaseAuthException catch (e) {
return getErrorMessage(e);
}
}
// ------------------------------------------------------------------
// Déconnexion
// ------------------------------------------------------------------
Future<void> logout() async {
await _googleSignIn.signOut();
await _auth.signOut();
}
/// Vérifie que le profil existe et qu'il est validé ; sinon déconnecte.
Future<String?> _checkProfile(String uid) async {
final profile = await _userService.getUser(uid);
if (profile == null) {
await logout();
return 'Profil utilisateur introuvable.';
}
if (!profile.isApproved) {
await logout();
return "Votre compte est en attente de validation par l'administrateur.";
}
return null;
}
String getErrorMessage(FirebaseAuthException e) {
switch (e.code) {
case 'invalid-credential':
case 'user-not-found':
case 'wrong-password':
return 'E-mail ou mot de passe incorrect.';
case 'invalid-email':
return "L'adresse e-mail n'est pas valide.";
case 'email-already-in-use':
return 'Cet e-mail est déjà utilisé.';
case 'weak-password':
return 'Le mot de passe est trop faible (6 caractères minimum).';
case 'user-disabled':
return 'Ce compte est désactivé.';
case 'too-many-requests':
return 'Trop de tentatives. Réessayez plus tard.';
case 'network-request-failed':
return 'Pas de connexion Internet.';
default:
return 'Erreur : ${e.message}';
}
}
}
L'ancienne version proposait deux contrôleurs différents pour la même chose (
register / signUp), et les types génériques avaient disparu (Future register, State createState, StreamBuilder>() : le code ne compilait pas. Il n'y a plus qu'un seul contrôleur, complet. Les utilisateurs Google reçoivent désormais un profil Firestore à leur première connexion : avant, ils étaient bloqués sur « profil introuvable ».9.9 Page d'inscription avec choix du rôle
On reprend signup_view.dart (partie 6.3) avec trois modifications.
Modifications de views/signup_view.dart
// 1) Nouvel état
String selectedRole = 'lecteur';
// 2) Nouvelle méthode register()
Future<void> register() async {
setState(() {
isLoading = true;
errorMessage = null;
});
final error = await auth.register(
email: emailController.text,
password: passwordController.text,
role: selectedRole,
);
if (!mounted) return;
setState(() {
isLoading = false;
errorMessage = error;
});
if (error != null) return;
await showDialog<void>(
context: context,
builder: (dialogContext) => AlertDialog(
title: const Text('Inscription réussie'),
content: const Text("Votre compte est en attente de validation par l'administrateur."),
actions: [
TextButton(
onPressed: () => Navigator.pop(dialogContext), // ferme la boîte
child: const Text('OK'),
),
],
),
);
if (mounted) Navigator.pop(context); // retour à la page de connexion
}
// 3) Dans build(), entre le mot de passe et le message d'erreur
const SizedBox(height: 15),
DropdownButtonFormField<String>(
initialValue: selectedRole, // Flutter < 3.35 : utilisez « value: »
decoration: InputDecoration(
labelText: 'Rôle',
prefixIcon: const Icon(Icons.person_outline),
border: OutlineInputBorder(borderRadius: BorderRadius.circular(15)),
),
items: const [
DropdownMenuItem(value: 'lecteur', child: Text('Lecteur')),
DropdownMenuItem(value: 'auteur', child: Text('Auteur')),
],
onChanged: (value) => setState(() => selectedRole = value!),
),
9.10 Écran d'attente et tableau de bord administrateur
views/pending_view.dart
import 'package:flutter/material.dart';
import '../controllers/auth_controller.dart';
class PendingView extends StatelessWidget {
const PendingView({super.key});
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: Padding(
padding: const EdgeInsets.all(24),
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
const Icon(Icons.schedule, size: 80, color: Colors.orange),
const SizedBox(height: 20),
const Text(
"En attente d'approbation",
style: TextStyle(fontSize: 24, fontWeight: FontWeight.bold),
),
const SizedBox(height: 10),
const Text(
"Votre compte est en cours de validation par l'administrateur.",
textAlign: TextAlign.center,
style: TextStyle(fontSize: 16),
),
const SizedBox(height: 30),
ElevatedButton(
onPressed: () => AuthController().logout(),
child: const Text('Se déconnecter'),
),
],
),
),
),
);
}
}
views/admin_dashboard_view.dart
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import '../controllers/auth_controller.dart';
import '../models/user_model.dart';
import '../services/user_service.dart';
class AdminDashboardView extends StatelessWidget {
const AdminDashboardView({super.key});
@override
Widget build(BuildContext context) {
final userService = UserService();
return Scaffold(
appBar: AppBar(
title: const Text('Tableau de bord Admin'),
backgroundColor: Colors.red,
foregroundColor: Colors.white,
actions: [
IconButton(
icon: const Icon(Icons.logout),
onPressed: () => AuthController().logout(),
),
],
),
body: StreamBuilder<List<UserModel>>(
stream: userService.watchPendingUsers(),
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return const Center(child: CircularProgressIndicator());
}
if (snapshot.hasError) {
return Center(child: Text('Erreur : ${snapshot.error}'));
}
final pendingUsers = snapshot.data ?? [];
if (pendingUsers.isEmpty) {
return const Center(child: Text("Aucune demande d'inscription en attente"));
}
return ListView.builder(
itemCount: pendingUsers.length,
itemBuilder: (context, index) {
final user = pendingUsers[index];
return Card(
margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
child: ListTile(
title: Text(user.email),
subtitle: Text(
'Rôle : ${user.role} — inscrit le '
'${DateFormat('dd/MM/yyyy').format(user.createdAt)}',
),
trailing: Row(
mainAxisSize: MainAxisSize.min,
children: [
IconButton(
icon: const Icon(Icons.check, color: Colors.green),
tooltip: 'Approuver',
onPressed: () => userService.approveUser(user.uid),
),
IconButton(
icon: const Icon(Icons.close, color: Colors.red),
tooltip: 'Refuser',
onPressed: () => userService.rejectUser(user.uid),
),
],
),
),
);
},
);
},
),
);
}
}
9.11 Redirection selon le rôle (main.dart)
main.dart (version finale)
import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'firebase_options.dart';
import 'controllers/auth_controller.dart';
import 'models/user_model.dart';
import 'services/user_service.dart';
import 'views/login_view.dart';
import 'views/home_view.dart';
import 'views/pending_view.dart';
import 'views/admin_dashboard_view.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Ma Bibliothèque',
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: const Color(0xFF4CAF50)),
home: const AuthWrapper(),
);
}
}
class AuthWrapper extends StatelessWidget {
const AuthWrapper({super.key});
static const _loading = Scaffold(body: Center(child: CircularProgressIndicator()));
@override
Widget build(BuildContext context) {
// 1) Qui est connecté ?
return StreamBuilder<User?>(
stream: FirebaseAuth.instance.authStateChanges(),
builder: (context, authSnap) {
if (authSnap.connectionState == ConnectionState.waiting) return _loading;
final user = authSnap.data;
if (user == null) return const LoginView();
if (user.isAnonymous) return const HomeView(); // invité : lecture seule
// 2) Quel est son profil ? (écoute en temps réel)
return StreamBuilder<UserModel?>(
stream: UserService().watchUser(user.uid),
builder: (context, profileSnap) {
if (profileSnap.connectionState == ConnectionState.waiting) return _loading;
final profile = profileSnap.data;
if (profileSnap.hasError || profile == null) {
return Scaffold(
body: Center(
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
const Text('Profil utilisateur introuvable.'),
TextButton(
onPressed: () => AuthController().logout(),
child: const Text('Retour à la connexion'),
),
],
),
),
);
}
if (!profile.isApproved) return const PendingView();
if (profile.isAdmin) return const AdminDashboardView();
return const HomeView(); // ou ListeLivresView() du chapitre précédent
},
);
},
);
}
}
Corrections : l'ancien
main.dart affichait des écrans qui n'existaient pas (AuthorDashboard, ReaderDashboard), appelait const AdminDashboard() alors que le constructeur ne pouvait pas être const, utilisait DateFormat sans importer intl, et un bloc de code était intitulé « auth_controller.dart » alors qu'il s'agissait de main.dart. Le profil est désormais écouté (snapshots()) : l'écran d'attente se met à jour seul dès que l'admin valide le compte.🛠 Activité 10 — Rôles et validation des comptes dans ClubApp
Mission : Ajoutez à ClubApp les rôles membre, organisateur et admin, l'écran d'attente et le tableau de bord de validation.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Quels champs mettez-vous dans le document
users/{uid}de ClubApp ? Faut-il un champ supplémentaire par rapport au cours (ex. filière, téléphone) ? Justifiez. - Pourquoi utilise-t-on l'UID comme identifiant du document plutôt qu'un identifiant automatique ? Que deviendrait la lecture du profil sinon ?
- Dans la liste déroulante d'inscription, quels rôles proposez-vous ? Pourquoi le rôle « admin » ne doit-il jamais y figurer ?
- Comment allez-vous créer le premier administrateur de ClubApp ? Faites-le et décrivez les étapes.
- Pourquoi
createdAtutilise-t-ilFieldValue.serverTimestamp()plutôt queDateTime.now()? Pourquoi la lecture doit-elle gérer une valeurnull? - Un membre s'inscrit avec Google. Que contient son document Firestore après sa première connexion ? Vérifiez dans la console.
- Ouvrez l'application sur deux appareils (ou émulateur + console) : le membre attend sur l'écran d'attente, l'admin le valide. Que se passe-t-il sur l'écran du membre ? Quelle ligne de code produit cet effet ?
- Créez l'écran « Organisateur » (liste des événements + bouton « Ajouter »). Où modifiez-vous
AuthWrapperpour l'afficher ? - Quand l'admin refuse un membre, le compte Firebase Auth existe toujours. Que se passe-t-il si cette personne se reconnecte ? Est-ce acceptable ? Quelle solution côté serveur pourriez-vous proposer ?
Je vérifie / je rends :
- ☐ Inscription → attente → validation → bon tableau de bord, pour chaque rôle.
- ☐ Capture de la collection
usersavec au moins un compte de chaque rôle.
10. Règles de sécurité Firestore
Les contrôles faits dans l'application ne suffisent pas : n'importe qui peut écrire un programme qui appelle directement votre base. Ce sont les règles de sécurité, exécutées sur les serveurs de Google, qui protègent réellement les données. Collez-les dans Firestore Database › Règles, puis cliquez sur Publier.
Règles Firestore (version corrigée)
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
function isSignedIn() {
return request.auth != null;
}
function isAdmin() {
return isSignedIn()
&& exists(/databases/$(database)/documents/users/$(request.auth.uid))
&& get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == 'admin';
}
match /users/{userId} {
// Création : uniquement SON document, sans rôle admin et non validé
allow create: if isSignedIn()
&& request.auth.uid == userId
&& request.resource.data.role in ['auteur', 'lecteur']
&& request.resource.data.isApproved == false;
// Lecture : son propre profil, ou tous les profils pour un admin
allow read: if isSignedIn() && (request.auth.uid == userId || isAdmin());
// Mise à jour : l'admin peut tout modifier ;
// l'utilisateur peut modifier son profil SAUF role et isApproved
allow update: if isAdmin()
|| (isSignedIn()
&& request.auth.uid == userId
&& !request.resource.data.diff(resource.data).affectedKeys()
.hasAny(['role', 'isApproved']));
// Suppression : admin uniquement
allow delete: if isAdmin();
}
// Tout le reste est interdit (ajoutez ici les règles de vos autres collections)
match /{document=**} {
allow read, write: if false;
}
}
}
Faille corrigée : les deux anciennes versions des règles autorisaient un utilisateur à modifier son propre document sans restriction. Un simple lecteur pouvait donc écrire
role: "admin" et isApproved: true et devenir administrateur. Les nouvelles règles l'interdisent, et empêchent aussi de créer un compte déjà validé ou avec le rôle admin.Le bloc final
match /{document=**} interdit tout ce qui n'est pas listé. Si votre application utilise une collection livres, ajoutez-lui ses propres règles, sinon elle deviendra illisible.🛠 Activité 11 — Sécuriser les données de ClubApp
Mission : Écrivez les règles de ClubApp pour les collections users et evenements, puis prouvez qu'elles résistent à une tentative de triche.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Avec les règles corrigées, ouvrez le Rules Playground (simulateur de règles) de la console. Simulez une mise à jour de
users/{votre uid}qui changeroleen"admin": le résultat est-il « autorisé » ou « refusé » ? Quelle ligne des règles est responsable ? - Dans l'application, ajoutez temporairement un bouton qui exécute
update({'role': 'admin'})sur votre propre profil. Quel code d'erreur s'affiche ? Supprimez ensuite ce bouton. - Pour la collection
evenements: qui peut lire ? qui peut créer ? qui peut modifier ou supprimer un événement ? Traduisez vos réponses de l'activité 1 en conditionsallow. - Un invité (anonyme) a-t-il
request.auth != null? Comment l'empêcher de créer un événement tout en le laissant lire le programme ? Cherchez ce que contientrequest.auth.token.firebase.sign_in_provider. - La fonction
isAdmin()fait une lecture supplémentaire (get) à chaque requête. Quel est l'impact sur la facturation ? Cherchez ce que sont les custom claims et expliquez en deux phrases pourquoi ils seraient une alternative. - Pourquoi ne faut-il jamais laisser les règles « mode test » (
allow read, write: if true;) sur une application publiée ?
Je vérifie / je rends :
- ☐ Fichier de règles commenté pour
usersetevenements. - ☐ Captures du Rules Playground : un test autorisé et un test refusé.
11. Problèmes courants et solutions
| Problème | Cause probable | Solution |
|---|---|---|
[core/no-app] No Firebase App '[DEFAULT]' has been created |
Firebase.initializeApp() absent ou sans await |
Vérifier main() (partie 5.3) |
| Erreur de compilation « minSdkVersion » | minSdk trop bas | Mettre minSdk = 23 dans android/app/build.gradle(.kts) |
ApiException: 10 |
SHA-1 / SHA-256 manquantes ou fichier de configuration non mis à jour | Ajouter les empreintes puis relancer flutterfire configure |
invalid-credential au lieu de wrong-password |
Protection contre l'énumération des e-mails activée | Traiter invalid-credential dans getErrorMessage |
operation-not-allowed |
Fournisseur non activé dans la console | Activer le fournisseur (partie 4) |
[cloud_firestore/permission-denied] |
Règles trop strictes ou utilisateur non connecté | Tester dans le Rules Playground ; vérifier l'UID utilisé |
| « Profil utilisateur introuvable » après Google | Aucun document users/{uid} créé |
Créer le profil à la première connexion (partie 9.8) |
| Crash ou écran blanc au démarrage | google-services.json absent ou périmé |
Relancer flutterfire configure |
| Application non reconnue | Mauvais package name | Comparer applicationId (build.gradle) et la console Firebase |
| Pop-up Google en anglais | La langue suit celle de l'appareil | Changer la langue du téléphone ou de l'émulateur |
12. Projet de synthèse : ClubApp complète
Assemblez toutes les activités en une application fonctionnelle et présentez-la en 5 minutes. Vous devez être capable de répondre aux questions ci-dessous sans lire vos notes.
🛠 Activité 12 — Soutenance de ClubApp
Mission : Préparez une démonstration complète : inscription d'un membre, validation par l'admin, création d'un événement par un organisateur, consultation en invité, tentative de triche bloquée par les règles.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Montrez le parcours d'un nouvel utilisateur, de l'inscription jusqu'à son premier écran. Quelles données sont écrites, et dans quel service (Auth ou Firestore) ?
- Si l'on supprime l'écran d'attente de l'application, un membre non validé peut-il quand même lire les événements ? Pourquoi ?
- Quelle partie de votre code supprimeriez-vous si vous deviez retirer Google Sign-In ? Votre architecture rend-elle ce changement facile ?
- Quelle est, selon vous, la faille de sécurité la plus dangereuse que vous avez évitée ? Montrez la règle qui la bloque.
- Que faudrait-il ajouter pour publier ClubApp sur le Play Store (empreinte release, vérification de l'e-mail, suppression de compte…) ?
Je vérifie / je rends :
- ☐ Démonstration vidéo (2 à 3 min) ou démonstration en direct.
- ☐ Dépôt du code (GitHub ou archive) + compte rendu des activités 1 à 11.
- ☐ Fiche de dépannage personnelle (au moins 5 erreurs rencontrées).
Grille d'évaluation indicative :
| Critère | Points |
|---|---|
| Configuration Firebase (projet, fournisseurs, SHA, Firestore) | 3 |
| Connexion e-mail, inscription, mot de passe oublié, messages d'erreur clairs | 3 |
| Google Sign-In et mode invité (avec transformation en compte) | 3 |
| Rôles, écran d'attente, tableau de bord admin, écran organisateur | 4 |
| Règles de sécurité testées (triche bloquée) | 4 |
Qualité du code (contrôleur, service, modèle, mounted, dispose) |
2 |
| Compte rendu et réponses aux questions | 1 |
| Total | 20 |
13. Testez vos connaissances
Avant de passer à la suite, vérifiez que vous avez bien compris Firebase Authentication et Cloud Firestore avec cet exercice interactif : 25 questions à choix multiple puis 5 textes à trous. Chaque réponse est corrigée et expliquée ; vous pouvez recommencer autant de fois que vous le souhaitez.
Faites l'exercice sans relire le cours : les questions manquées vous indiquent les parties à revoir (règles de sécurité, requêtes, codes d'erreur…).
Ressource PDF disponible
Ce cours contient une version PDF téléchargeable. Le lien sera disponible prochainement.
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !