Initialisation du projet geosector complet (web + flutter)

flutt/lib/chat/services/notifications/README_MQTT.md

@@ -0,0 +1,214 @@
+# Notifications MQTT pour le Chat GEOSECTOR
+
+## Vue d'ensemble
+
+Ce système de notifications utilise MQTT pour fournir des notifications push en temps réel pour le module chat. Il offre une alternative légère à Firebase Cloud Messaging (FCM) et peut être auto-hébergé dans votre infrastructure.
+
+## Architecture
+
+### Composants principaux
+
+1. **MqttNotificationService** (Flutter)
+   - Service de notification côté client
+   - Gère la connexion au broker MQTT
+   - Traite les messages entrants
+   - Affiche les notifications locales
+
+2. **MqttConfig** (Flutter)
+   - Configuration centralisée pour MQTT
+   - Gestion des topics
+   - Paramètres de connexion
+
+3. **MqttNotificationSender** (PHP)
+   - Service backend pour envoyer les notifications
+   - Interface avec la base de données
+   - Gestion des cibles d'audience
+
+## Configuration du broker MQTT
+
+### Container Incus
+
+Le broker MQTT (Eclipse Mosquitto recommandé) doit être installé dans votre container Incus :
+
+```bash
+# Installer Mosquitto
+apt-get update
+apt-get install mosquitto mosquitto-clients
+
+# Configurer Mosquitto
+vi /etc/mosquitto/mosquitto.conf
+```
+
+Configuration recommandée :
+```
+listener 1883
+allow_anonymous false
+password_file /etc/mosquitto/passwd
+
+# Pour SSL/TLS
+listener 8883
+cafile /etc/mosquitto/ca.crt
+certfile /etc/mosquitto/server.crt
+keyfile /etc/mosquitto/server.key
+```
+
+### Sécurité
+
+Pour un environnement de production, il est fortement recommandé :
+
+1. D'utiliser SSL/TLS (port 8883)
+2. De configurer l'authentification par mot de passe
+3. De limiter les IPs pouvant se connecter
+4. De configurer des ACLs pour restreindre l'accès aux topics
+
+## Structure des topics MQTT
+
+### Topics utilisateur
+- `chat/user/{userId}/messages` - Messages personnels pour l'utilisateur
+- `chat/user/{userId}/groups/{groupId}` - Messages des groupes de l'utilisateur
+
+### Topics globaux
+- `chat/announcement` - Annonces générales
+- `chat/broadcast` - Diffusions à grande échelle
+
+### Topics conversation
+- `chat/conversation/{conversationId}` - Messages spécifiques à une conversation
+
+## Intégration Flutter
+
+### Dépendances requises
+
+Ajoutez ces dépendances à votre `pubspec.yaml` :
+
+```yaml
+dependencies:
+  mqtt5_client: ^4.0.0  # ou mqtt_client selon votre préférence
+  flutter_local_notifications: ^17.0.0
+```
+
+### Initialisation
+
+```dart
+// Dans main.dart
+void main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  
+  final notificationService = MqttNotificationService();
+  await notificationService.initialize(userId: currentUserId);
+  
+  runApp(const GeoSectorApp());
+}
+```
+
+### Utilisation
+
+```dart
+// Écouter les messages
+notificationService.onMessageTap = (messageId) {
+  // Naviguer vers le message
+  Navigator.pushNamed(context, '/chat/$messageId');
+};
+
+// Publier un message
+await notificationService.publishMessage(
+  'chat/user/$userId/messages',
+  {'content': 'Test message'},
+);
+```
+
+## Gestion des notifications
+
+### Paramètres utilisateur
+
+Les utilisateurs peuvent configurer :
+- Activation/désactivation des notifications
+- Conversations en silencieux
+- Mode "Ne pas déranger"
+- Aperçu du contenu
+
+### Persistance des notifications
+
+Les notifications sont enregistrées dans la table `chat_notifications` pour :
+- Traçabilité
+- Statistiques
+- Synchronisation
+
+## Tests
+
+### Test de connexion
+
+```dart
+final service = MqttNotificationService();
+await service.initialize(userId: 'test_user');
+// Vérifie les logs pour confirmer la connexion
+```
+
+### Test d'envoi
+
+```php
+$sender = new MqttNotificationSender($db, $mqttConfig);
+$result = $sender->sendMessageNotification(
+  'receiver_id',
+  'sender_id',
+  'message_id',
+  'Test message',
+  'conversation_id'
+);
+```
+
+## Surveillance et maintenance
+
+### Logs
+
+Les logs sont disponibles dans :
+- Logs Flutter (console debug)
+- Logs Mosquitto (`/var/log/mosquitto/mosquitto.log`)
+- Logs PHP (selon configuration)
+
+### Métriques à surveiller
+
+- Nombre de connexions actives
+- Latence des messages
+- Taux d'échec des notifications
+- Consommation mémoire/CPU du broker
+
+## Comparaison avec Firebase
+
+### Avantages MQTT
+
+1. **Auto-hébergé** : Contrôle total de l'infrastructure
+2. **Léger** : Moins de ressources que Firebase
+3. **Coût** : Gratuit (uniquement coûts d'infrastructure)
+4. **Personnalisable** : Configuration fine du broker
+
+### Inconvénients
+
+1. **Maintenance** : Nécessite une gestion du broker
+2. **Évolutivité** : Requiert dimensionnement et clustering
+3. **Fonctionnalités** : Moins de services intégrés que Firebase
+
+## Évolutions futures
+
+1. **WebSocket** : Ajout optionnel pour temps réel strict
+2. **Clustering** : Pour haute disponibilité
+3. **Analytics** : Dashboard de monitoring
+4. **Webhooks** : Intégration avec d'autres services
+
+## Dépannage
+
+### Problèmes courants
+
+1. **Connexion échouée**
+   - Vérifier username/password
+   - Vérifier port/hostname
+   - Vérifier firewall
+
+2. **Messages non reçus**
+   - Vérifier abonnement aux topics
+   - Vérifier QoS
+   - Vérifier paramètres notifications
+
+3. **Performance dégradée**
+   - Augmenter keepAlive
+   - Ajuster reconnectInterval
+   - Vérifier charge serveur

flutt/lib/chat/services/notifications/chat_notification_service.dart

@@ -0,0 +1,202 @@
+import 'package:firebase_messaging/firebase_messaging.dart';
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
+import 'package:flutter/foundation.dart';
+
+/// Service de gestion des notifications chat
+/// 
+/// Gère l'envoi et la réception des notifications pour le module chat
+
+class ChatNotificationService {
+  static final ChatNotificationService _instance = ChatNotificationService._internal();
+  factory ChatNotificationService() => _instance;
+  ChatNotificationService._internal();
+
+  final FirebaseMessaging _firebaseMessaging = FirebaseMessaging.instance;
+  final FlutterLocalNotificationsPlugin _localNotifications = FlutterLocalNotificationsPlugin();
+  
+  // Callback pour les actions sur les notifications
+  Function(String messageId)? onMessageTap;
+  Function(Map<String, dynamic>)? onBackgroundMessage;
+
+  /// Initialise le service de notifications
+  Future<void> initialize() async {
+    // Demander les permissions
+    await _requestPermissions();
+    
+    // Initialiser les notifications locales
+    await _initializeLocalNotifications();
+    
+    // Configurer les handlers de messages
+    _configureFirebaseHandlers();
+    
+    // Obtenir le token du device
+    await _initializeDeviceToken();
+  }
+
+  /// Demande les permissions pour les notifications
+  Future<bool> _requestPermissions() async {
+    NotificationSettings settings = await _firebaseMessaging.requestPermission(
+      alert: true,
+      badge: true,
+      sound: true,
+      provisional: false,
+    );
+
+    return settings.authorizationStatus == AuthorizationStatus.authorized;
+  }
+
+  /// Initialise les notifications locales
+  Future<void> _initializeLocalNotifications() async {
+    const AndroidInitializationSettings androidSettings = 
+        AndroidInitializationSettings('@mipmap/ic_launcher');
+    
+    final DarwinInitializationSettings iosSettings = DarwinInitializationSettings(
+      requestAlertPermission: true,
+      requestBadgePermission: true,
+      requestSoundPermission: true,
+      onDidReceiveLocalNotification: _onDidReceiveLocalNotification,
+    );
+
+    final InitializationSettings initSettings = InitializationSettings(
+      android: androidSettings,
+      iOS: iosSettings,
+    );
+
+    await _localNotifications.initialize(
+      initSettings,
+      onDidReceiveNotificationResponse: _onNotificationTap,
+    );
+  }
+
+  /// Configure les handlers Firebase
+  void _configureFirebaseHandlers() {
+    // Message reçu quand l'app est au premier plan
+    FirebaseMessaging.onMessage.listen(_onForegroundMessage);
+    
+    // Message reçu quand l'app est en arrière-plan
+    FirebaseMessaging.onMessageOpenedApp.listen(_onBackgroundMessageOpened);
+    
+    // Handler pour les messages en arrière-plan terminé
+    FirebaseMessaging.onBackgroundMessage(_firebaseBackgroundHandler);
+  }
+
+  /// Handler pour les messages reçus au premier plan
+  Future<void> _onForegroundMessage(RemoteMessage message) async {
+    if (message.notification != null) {
+      // Afficher une notification locale
+      await _showLocalNotification(
+        title: message.notification!.title ?? 'Nouveau message',
+        body: message.notification!.body ?? '',
+        payload: message.data['messageId'] ?? '',
+      );
+    }
+  }
+
+  /// Handler pour les messages ouverts depuis l'arrière-plan
+  void _onBackgroundMessageOpened(RemoteMessage message) {
+    final messageId = message.data['messageId'];
+    if (messageId != null) {
+      onMessageTap?.call(messageId);
+    }
+  }
+
+  /// Affiche une notification locale
+  Future<void> _showLocalNotification({
+    required String title,
+    required String body,
+    required String payload,
+  }) async {
+    const AndroidNotificationDetails androidDetails = AndroidNotificationDetails(
+      'chat_messages',
+      'Messages de chat',
+      channelDescription: 'Notifications pour les nouveaux messages de chat',
+      importance: Importance.high,
+      priority: Priority.high,
+      icon: '@mipmap/ic_launcher',
+    );
+
+    const DarwinNotificationDetails iosDetails = DarwinNotificationDetails(
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+
+    const NotificationDetails notificationDetails = NotificationDetails(
+      android: androidDetails,
+      iOS: iosDetails,
+    );
+
+    await _localNotifications.show(
+      DateTime.now().microsecondsSinceEpoch,
+      title,
+      body,
+      notificationDetails,
+      payload: payload,
+    );
+  }
+
+  /// Handler pour le clic sur une notification
+  void _onNotificationTap(NotificationResponse response) {
+    final payload = response.payload;
+    if (payload != null) {
+      onMessageTap?.call(payload);
+    }
+  }
+
+  /// Handler pour les notifications iOS reçues au premier plan
+  void _onDidReceiveLocalNotification(int id, String? title, String? body, String? payload) {
+    // Traitement spécifique iOS si nécessaire
+  }
+
+  /// Obtient et stocke le token du device
+  Future<String?> _initializeDeviceToken() async {
+    String? token = await _firebaseMessaging.getToken();
+    if (token != null) {
+      // Envoyer le token au serveur pour stocker
+      await _sendTokenToServer(token);
+    }
+    
+    // Écouter les changements de token
+    _firebaseMessaging.onTokenRefresh.listen(_sendTokenToServer);
+    
+    return token;
+  }
+
+  /// Envoie le token FCM au serveur
+  Future<void> _sendTokenToServer(String token) async {
+    try {
+      // Appel API pour enregistrer le token
+      // await chatApiService.registerDeviceToken(token);
+      debugPrint('Device token enregistré : $token');
+    } catch (e) {
+      debugPrint('Erreur lors de l\'enregistrement du token : $e');
+    }
+  }
+
+  /// S'abonner aux notifications pour une conversation
+  Future<void> subscribeToConversation(String conversationId) async {
+    await _firebaseMessaging.subscribeToTopic('chat_$conversationId');
+  }
+
+  /// Se désabonner des notifications pour une conversation
+  Future<void> unsubscribeFromConversation(String conversationId) async {
+    await _firebaseMessaging.unsubscribeFromTopic('chat_$conversationId');
+  }
+
+  /// Désactive temporairement les notifications
+  Future<void> pauseNotifications() async {
+    await _firebaseMessaging.setAutoInitEnabled(false);
+  }
+
+  /// Réactive les notifications
+  Future<void> resumeNotifications() async {
+    await _firebaseMessaging.setAutoInitEnabled(true);
+  }
+}
+
+/// Handler pour les messages en arrière-plan
+@pragma('vm:entry-point')
+Future<void> _firebaseBackgroundHandler(RemoteMessage message) async {
+  // Traitement des messages en arrière-plan
+  debugPrint('Message reçu en arrière-plan : ${message.messageId}');
+}

flutt/lib/chat/services/notifications/mqtt_config.dart

@@ -0,0 +1,74 @@
+/// Configuration pour le broker MQTT
+///
+/// Centralise les paramètres de connexion au broker MQTT
+
+class MqttConfig {
+  // Configuration du serveur MQTT
+  static const String host = 'mqtt.geosector.fr';
+  static const int port = 1883;
+  static const int securePort = 8883;
+  static const bool useSsl = false;
+  
+  // Configuration d'authentification
+  static const String username = 'geosector_chat';
+  static const String password = 'secure_password_here';
+  
+  // Préfixes des topics MQTT
+  static const String topicBase = 'chat';
+  static const String topicUserMessages = '$topicBase/user';
+  static const String topicAnnouncements = '$topicBase/announcement';
+  static const String topicGroups = '$topicBase/groups';
+  static const String topicConversations = '$topicBase/conversation';
+  
+  // Configuration des sessions
+  static const int keepAliveInterval = 60;
+  static const int reconnectInterval = 5;
+  static const bool cleanSession = true;
+  
+  // Configuration des notifications
+  static const int notificationRetryCount = 3;
+  static const Duration notificationTimeout = Duration(seconds: 30);
+  
+  /// Génère un client ID unique pour chaque session
+  static String generateClientId(String userId) {
+    return 'chat_${userId}_${DateTime.now().millisecondsSinceEpoch}';
+  }
+  
+  /// Retourne l'URL complète du broker selon la configuration SSL
+  static String get brokerUrl {
+    if (useSsl) {
+      return '$host:$securePort';
+    } else {
+      return '$host:$port';
+    }
+  }
+  
+  /// Retourne le topic pour les messages d'un utilisateur
+  static String getUserMessageTopic(String userId) {
+    return '$topicUserMessages/$userId/messages';
+  }
+  
+  /// Retourne le topic pour les annonces globales
+  static String getAnnouncementTopic() {
+    return topicAnnouncements;
+  }
+  
+  /// Retourne le topic pour une conversation spécifique
+  static String getConversationTopic(String conversationId) {
+    return '$topicConversations/$conversationId';
+  }
+  
+  /// Retourne le topic pour un groupe spécifique
+  static String getGroupTopic(String groupId) {
+    return '$topicGroups/$groupId';
+  }
+  
+  /// Retourne les topics auxquels un utilisateur doit s'abonner
+  static List<String> getUserSubscriptionTopics(String userId) {
+    return [
+      getUserMessageTopic(userId),
+      getAnnouncementTopic(),
+      // Ajoutez d'autres topics selon les besoins
+    ];
+  }
+}

flutt/lib/chat/services/notifications/mqtt_notification_service.dart

@@ -0,0 +1,322 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:mqtt5_client/mqtt5_client.dart';
+import 'package:mqtt5_client/mqtt5_server_client.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
+
+/// Service de gestion des notifications chat via MQTT
+///
+/// Utilise MQTT pour recevoir des notifications en temps réel
+/// et afficher des notifications locales
+
+class MqttNotificationService {
+  static final MqttNotificationService _instance = MqttNotificationService._internal();
+  factory MqttNotificationService() => _instance;
+  MqttNotificationService._internal();
+
+  late MqttServerClient _client;
+  final FlutterLocalNotificationsPlugin _localNotifications = FlutterLocalNotificationsPlugin();
+  
+  // Configuration
+  final String mqttHost;
+  final int mqttPort;
+  final String mqttUsername;
+  final String mqttPassword;
+  final String clientId;
+  
+  // État
+  bool _initialized = false;
+  String? _userId;
+  StreamSubscription? _messageSubscription;
+  
+  // Callbacks
+  Function(String messageId)? onMessageTap;
+  Function(Map<String, dynamic>)? onNotificationReceived;
+  
+  MqttNotificationService({
+    this.mqttHost = 'mqtt.geosector.fr',
+    this.mqttPort = 1883,
+    this.mqttUsername = '',
+    this.mqttPassword = '',
+    String? clientId,
+  }) : clientId = clientId ?? 'geosector_chat_${DateTime.now().millisecondsSinceEpoch}';
+
+  /// Initialise le service de notifications
+  Future<void> initialize({required String userId}) async {
+    if (_initialized) return;
+    
+    _userId = userId;
+    
+    // Initialiser les notifications locales
+    await _initializeLocalNotifications();
+    
+    // Initialiser le client MQTT
+    await _initializeMqttClient();
+    
+    _initialized = true;
+  }
+
+  /// Initialise le client MQTT
+  Future<void> _initializeMqttClient() async {
+    try {
+      _client = MqttServerClient.withPort(mqttHost, clientId, mqttPort);
+      
+      _client.logging(on: kDebugMode);
+      _client.keepAlivePeriod = 60;
+      _client.onConnected = _onConnected;
+      _client.onDisconnected = _onDisconnected;
+      _client.onSubscribed = _onSubscribed;
+      _client.autoReconnect = true;
+      
+      // Configurer les options de connexion
+      final connMessage = MqttConnectMessage()
+          .authenticateAs(mqttUsername, mqttPassword)
+          .withClientIdentifier(clientId)
+          .startClean()
+          .keepAliveFor(60);
+      
+      _client.connectionMessage = connMessage;
+      
+      // Se connecter
+      await _connect();
+      
+    } catch (e) {
+      debugPrint('Erreur lors de l\'initialisation MQTT : $e');
+      rethrow;
+    }
+  }
+
+  /// Se connecte au broker MQTT
+  Future<void> _connect() async {
+    try {
+      await _client.connect();
+    } catch (e) {
+      debugPrint('Erreur de connexion MQTT : $e');
+      _client.disconnect();
+      rethrow;
+    }
+  }
+
+  /// Callback lors de la connexion
+  void _onConnected() {
+    debugPrint('Connecté au broker MQTT');
+    
+    // S'abonner aux topics de l'utilisateur
+    if (_userId != null) {
+      _subscribeToUserTopics(_userId!);
+    }
+    
+    // Écouter les messages
+    _messageSubscription = _client.updates?.listen(_onMessageReceived);
+  }
+
+  /// Callback lors de la déconnexion
+  void _onDisconnected() {
+    debugPrint('Déconnecté du broker MQTT');
+    
+    // Tenter une reconnexion
+    if (_client.autoReconnect) {
+      Future.delayed(const Duration(seconds: 5), () {
+        _connect();
+      });
+    }
+  }
+
+  /// Callback lors de l'abonnement
+  void _onSubscribed(MqttSubscription subscription) {
+    debugPrint('Abonné au topic : ${subscription.topic.rawTopic}');
+  }
+
+  /// S'abonner aux topics de l'utilisateur
+  void _subscribeToUserTopics(String userId) {
+    // Topic pour les messages personnels
+    _client.subscribe('chat/user/$userId/messages', MqttQos.atLeastOnce);
+    
+    // Topic pour les annonces
+    _client.subscribe('chat/announcement', MqttQos.atLeastOnce);
+    
+    // Topic pour les groupes de l'utilisateur (si disponibles)
+    _client.subscribe('chat/user/$userId/groups/+', MqttQos.atLeastOnce);
+  }
+
+  /// Gère les messages reçus
+  void _onMessageReceived(List<MqttReceivedMessage<MqttMessage>> messages) {
+    for (var message in messages) {
+      final topic = message.topic;
+      final payload = message.payload as MqttPublishMessage;
+      final messageText = MqttUtilities.bytesToStringAsString(payload.payload.message!);
+      
+      try {
+        final data = jsonDecode(messageText) as Map<String, dynamic>;
+        _handleNotification(topic, data);
+      } catch (e) {
+        debugPrint('Erreur lors du décodage du message : $e');
+      }
+    }
+  }
+
+  /// Traite la notification reçue
+  Future<void> _handleNotification(String topic, Map<String, dynamic> data) async {
+    // Vérifier les paramètres de notification de l'utilisateur
+    if (!await _shouldShowNotification(data)) {
+      return;
+    }
+    
+    String title = '';
+    String body = '';
+    String messageId = '';
+    String conversationId = '';
+    
+    if (topic.startsWith('chat/user/')) {
+      // Message personnel
+      title = data['senderName'] ?? 'Nouveau message';
+      body = data['content'] ?? '';
+      messageId = data['messageId'] ?? '';
+      conversationId = data['conversationId'] ?? '';
+    } else if (topic.startsWith('chat/announcement')) {
+      // Annonce
+      title = data['title'] ?? 'Annonce';
+      body = data['content'] ?? '';
+      messageId = data['messageId'] ?? '';
+      conversationId = data['conversationId'] ?? '';
+    }
+    
+    // Afficher la notification locale
+    await _showLocalNotification(
+      title: title,
+      body: body,
+      payload: jsonEncode({
+        'messageId': messageId,
+        'conversationId': conversationId,
+      }),
+    );
+    
+    // Appeler le callback si défini
+    onNotificationReceived?.call(data);
+  }
+
+  /// Vérifie si la notification doit être affichée
+  Future<bool> _shouldShowNotification(Map<String, dynamic> data) async {
+    // TODO: Vérifier les paramètres de notification de l'utilisateur
+    // - Notifications désactivées
+    // - Conversation en silencieux
+    // - Mode Ne pas déranger
+    return true;
+  }
+
+  /// Initialise les notifications locales
+  Future<void> _initializeLocalNotifications() async {
+    const androidSettings = AndroidInitializationSettings('@mipmap/ic_launcher');
+    const iosSettings = DarwinInitializationSettings(
+      requestAlertPermission: true,
+      requestBadgePermission: true,
+      requestSoundPermission: true,
+    );
+    
+    const initSettings = InitializationSettings(
+      android: androidSettings,
+      iOS: iosSettings,
+    );
+    
+    await _localNotifications.initialize(
+      initSettings,
+      onDidReceiveNotificationResponse: _onNotificationTap,
+    );
+  }
+
+  /// Affiche une notification locale
+  Future<void> _showLocalNotification({
+    required String title,
+    required String body,
+    required String payload,
+  }) async {
+    const androidDetails = AndroidNotificationDetails(
+      'chat_messages',
+      'Messages de chat',
+      channelDescription: 'Notifications pour les nouveaux messages de chat',
+      importance: Importance.high,
+      priority: Priority.high,
+      icon: '@mipmap/ic_launcher',
+    );
+    
+    const iosDetails = DarwinNotificationDetails(
+      presentAlert: true,
+      presentBadge: true,
+      presentSound: true,
+    );
+    
+    const notificationDetails = NotificationDetails(
+      android: androidDetails,
+      iOS: iosDetails,
+    );
+    
+    await _localNotifications.show(
+      DateTime.now().microsecondsSinceEpoch,
+      title,
+      body,
+      notificationDetails,
+      payload: payload,
+    );
+  }
+
+  /// Handler pour le clic sur une notification
+  void _onNotificationTap(NotificationResponse response) {
+    final payload = response.payload;
+    if (payload != null) {
+      try {
+        final data = jsonDecode(payload) as Map<String, dynamic>;
+        final messageId = data['messageId'] as String?;
+        if (messageId != null) {
+          onMessageTap?.call(messageId);
+        }
+      } catch (e) {
+        debugPrint('Erreur lors du traitement du clic sur notification : $e');
+      }
+    }
+  }
+
+  /// Publie un message MQTT
+  Future<void> publishMessage(String topic, Map<String, dynamic> message) async {
+    if (_client.connectionStatus?.state != MqttConnectionState.connected) {
+      await _connect();
+    }
+    
+    final messagePayload = jsonEncode(message);
+    final builder = MqttPayloadBuilder();
+    builder.addString(messagePayload);
+    
+    _client.publishMessage(topic, MqttQos.atLeastOnce, builder.payload!);
+  }
+
+  /// S'abonner à une conversation spécifique
+  Future<void> subscribeToConversation(String conversationId) async {
+    if (_client.connectionStatus?.state == MqttConnectionState.connected) {
+      _client.subscribe('chat/conversation/$conversationId', MqttQos.atLeastOnce);
+    }
+  }
+
+  /// Se désabonner d'une conversation
+  Future<void> unsubscribeFromConversation(String conversationId) async {
+    if (_client.connectionStatus?.state == MqttConnectionState.connected) {
+      _client.unsubscribeStringTopic('chat/conversation/$conversationId');
+    }
+  }
+
+  /// Désactive temporairement les notifications
+  void pauseNotifications() {
+    _client.pause();
+  }
+
+  /// Réactive les notifications
+  void resumeNotifications() {
+    _client.resume();
+  }
+
+  /// Libère les ressources
+  void dispose() {
+    _messageSubscription?.cancel();
+    _client.disconnect();
+    _initialized = false;
+  }
+}