Flutter Firebase Push Notification Provider #

Un paquete Flutter que proporciona una interfaz unificada y optimizada para gestionar notificaciones push de Firebase Cloud Messaging (FCM). Maneja permisos, tokens y mensajes en todos los estados de la aplicación (foreground, background y terminada) con gestión automática de memoria y prevención de leaks.

Features #

• ✅ Manejo automático de notificaciones en foreground, background y cuando la app está cerrada
• ✅ Stream unificado para recibir todas las notificaciones
• ✅ Gestión automática de permisos de notificación
• ✅ Actualización automática de tokens FCM en el servidor MongoDB
• ✅ Filtrado de mensajes por IdPushNotification
• ✅ Prevención de memory leaks con gestión apropiada de subscriptions
• ✅ Protección contra inicialización múltiple
• ✅ Manejo robusto de errores con propagación apropiada
• ✅ Integración automática con información del dispositivo y versión de la app
• ✅ Debug logging integrado con formato consistente
• ✅ Verificación de tokens existentes para evitar duplicados
• ✅ Gestión de estados de registros (activo/bloqueado)
• ✅ Anulación de tokens con eliminación de FCM y actualización de estado

Getting started #

Prerequisitos #

• Flutter SDK >= 1.17.0
• Dart SDK >= 3.3.2
• Firebase configurado en tu proyecto (Guía de configuración)
• Servidor MongoDB configurado con la colección requerida (ver sección "Configuración del Servidor MongoDB")
• Paquetes adicionales requeridos (disponibles en pub.flutter-io.cn):
  • api_rest_flutter_web
  • flutter_utils_providers
  • flutter_models_provider

Instalación #

Agrega el paquete a tu pubspec.yaml:

dependencies:
  flutter_firebase_push_notification_provider_web: ^3.0.0

Luego ejecuta:

flutter pub get

Configuración del Servidor MongoDB #

⚠️ REQUISITO FUNDAMENTAL #

Antes de usar este paquete, es requisito fundamental que tu servidor MongoDB tenga configurada la siguiente colección según se define en EnvironmentPushNotification:

Nombre de la Colección

tokenFirebase

Estructura de la Colección MongoDB

La colección debe tener los siguientes campos en el orden especificado:

⚠️ Nota sobre nomenclatura: Actualmente existe una inconsistencia en el código donde:

• Al crear el registro se usa el campo data.token (definido en EnvironmentPushNotification.camposColeccionTokenFirebase)
• Al consultar el registro se usa el campo data.tokenFirebase (en métodos anularToken() y _verificarTokenExistente())

Recomendación: Asegúrate de que tu colección MongoDB use data.tokenFirebase como nombre del campo, o actualiza el código para usar consistentemente data.token.

Ejemplo de Documento en MongoDB (Data)

{
  "_id": "507f1f77bcf86cd799439011",
  "idServer": "507f1f77bcf86cd799439011",
  "idMobile": "mobile_123",
  "estado": "activo",
  "creadoEl": "2025-01-15T10:30:00Z",
  "data": {
    "idUsuario": "user_12345",
    "tokenFirebase": "dGh1c2lzYXRva2VuZnJvbWZpcmViYXNl...",
    "dispositivo": "Samsung Galaxy S21",
    "plataforma": "android",
    "appVersion": "1.0.0"
  }
}

Nota: El ejemplo muestra el campo como tokenFirebase según la implementación actual en las consultas.

Índices Recomendados

Para optimizar el rendimiento, crea los siguientes índices en la colección:

// Índice único compuesto para evitar duplicados
db.tokenFirebase.createIndex(
  { "data.idUsuario": 1, "data.tokenFirebase": 1 },
  { unique: true }
)

// Índice para búsquedas por usuario
db.tokenFirebase.createIndex({ "data.idUsuario": 1 })

// Índice para búsquedas por token
db.tokenFirebase.createIndex({ "data.tokenFirebase": 1 })

// Índice para búsquedas por estado
db.tokenFirebase.createIndex({ "estado": 1 })

// Índice compuesto para consultas de tokens activos
db.tokenFirebase.createIndex(
  { "data.tokenFirebase": 1, "estado": 1 }
)

⚠️ IMPORTANTE: Orden de Campos

El orden de los campos en EnvironmentPushNotification.camposColeccionTokenFirebase es crítico:

static const camposColeccionTokenFirebase = [
  'idUsuario',      // 1. Primero
  'token',          // 2. Segundo
  'dispositivo',    // 3. Tercero
  'plataforma',     // 4. Cuarto
  'appVersion',     // 5. Quinto
];

Este orden debe coincidir con el orden en que se pasan los datos en el código. No alterar este orden.

Usage #

1. Inicialización en main.dart #

Importante: Ya no necesitas proporcionar coleccionFireBaseTokens porque ahora se usa la configuración de EnvironmentPushNotification.

import 'package:firebase_core/firebase_core.dart';
import 'package:flutter_firebase_push_notification_provider/flutter_firebase_push_notification_provider.dart';
import 'package:api_rest_flutter/api_rest.dart';
import 'package:api_rest_flutter/util/utils_data_api_rest.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // Inicializar Firebase primero
  await Firebase.initializeApp();

  // Crear instancias necesarias
  final apiRest = ApiRest(/* tu configuración */);
  final utilsDataApiRest = UtilsDataApiRest(/* tu configuración */);

  // Inicializar el manejador de notificaciones (usando el Singleton)
  try {
    final notificationProvider = FlutterFireBasePushNotificationProvider();
    await notificationProvider.initializeApp(
      apiRest: apiRest,
      utilsDataApiRest: utilsDataApiRest,
      idUsuario: 'USER_ID', // ID del usuario actual
      coleccionAuth: 'auth', // Colección de autenticación
    );

    print('✅ Notificaciones inicializadas correctamente');
  } catch (e) {
    print('❌ Error al inicializar notificaciones: $e');
  }

  runApp(MyApp());
}

2. Escuchar mensajes en tu widget #

import 'dart:async';
import 'package:flutter_firebase_push_notification_provider/flutter_firebase_push_notification_provider.dart';

class MyWidget extends StatefulWidget {
  @override
  _MyWidgetState createState() => _MyWidgetState();
}

class _MyWidgetState extends State<MyWidget> {
  StreamSubscription<Map<String, dynamic>>? _subscription;
  late final FlutterFireBasePushNotificationProvider _notificationProvider;

  @override
  void initState() {
    super.initState();

    // Obtener la instancia del Singleton (siempre devuelve la misma instancia)
    _notificationProvider = FlutterFireBasePushNotificationProvider();

    // Verificar que esté inicializado antes de suscribirse
    if (_notificationProvider.isInitialized) {
      _suscribirseANotificaciones();
    } else {
      print('⚠️ El provider no está inicializado');
    }
  }

  void _suscribirseANotificaciones() {
    // Escuchar mensajes del stream
    _subscription = _notificationProvider.messagesStream.listen(
      (mensaje) {
        // Procesar notificación
        final idNotification = mensaje['data']?['IdPushNotification'];
        if (idNotification != null) {
          print('📩 ID Notificación: $idNotification');
          print('📩 Título: ${mensaje['notification']?['title'] ?? 'Sin título'}');
          print('📩 Mensaje: ${mensaje['notification']?['body'] ?? 'Sin mensaje'}');

          // Aquí puedes navegar a una pantalla específica o mostrar un dialog
          _procesarNotificacion(mensaje);
        }
      },
      onError: (error) {
        print('❌ Error en el stream de notificaciones: $error');
      },
    );
  }

  void _procesarNotificacion(Map<String, dynamic> mensaje) {
    // Implementa tu lógica de negocio aquí
    // Por ejemplo: navegación, actualización de UI, etc.
  }

  @override
  void dispose() {
    // Cancelar la suscripción para evitar memory leaks
    _subscription?.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Notificaciones')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Estado: ${_notificationProvider.isInitialized ? "Inicializado" : "No inicializado"}'),
            SizedBox(height: 16),
            ElevatedButton(
              onPressed: _notificationProvider.hasPermission
                ? () => print('✅ Permisos otorgados')
                : () => print('⚠️ Sin permisos de notificación'),
              child: Text('Verificar Permisos'),
            ),
          ],
        ),
      ),
    );
  }
}

3. Obtener el Token FCM #

Existen dos formas de obtener el token FCM:

3.1. Acceder al token actual (Forma recomendada)

Puedes acceder directamente al token actual almacenado sin hacer una llamada asíncrona:

final notificationProvider = FlutterFireBasePushNotificationProvider();

// Acceso directo al token actual
final currentToken = notificationProvider.currentToken;

if (currentToken.isNotEmpty) {
  print('Token FCM actual: $currentToken');
  // Hacer algo con el token
} else {
  print('No hay token disponible');
}

3.2. Obtener el token manualmente (Llamada asíncrona)

Si necesitas obtener el token directamente desde Firebase (por ejemplo, para forzar una actualización):

final notificationProvider = FlutterFireBasePushNotificationProvider();
final token = await notificationProvider.getToken();

if (token.isNotEmpty) {
  print('Token FCM: $token');
  // Hacer algo con el token
} else {
  print('No se pudo obtener el token');
}

Nota: La propiedad currentToken es más eficiente ya que accede directamente al token almacenado sin necesidad de hacer una llamada asíncrona a Firebase.

4. Anular un Token FCM (Cerrar Sesión/Dispositivo) #

Cuando un usuario cierra sesión o necesitas desactivar las notificaciones push en un dispositivo específico, debes anular el token de Firebase. Este método:

1. Elimina el token de Firebase Cloud Messaging en el dispositivo
2. Marca el token como bloqueado en tu base de datos MongoDB (cambia el estado de activo a bloqueado)

Importante: El método anularToken() usa automáticamente el token actual almacenado (currentToken), por lo que NO necesitas pasar el token como parámetro.

¿Cuándo usar anularToken()?

• 🔐 Cierre de sesión: Cuando el usuario hace logout
• 📱 Cambio de dispositivo: Cuando el usuario se muda a otro dispositivo
• 🔒 Seguridad: Cuando se detecta actividad sospechosa y necesitas revocar acceso
• 🚫 Desactivar notificaciones: Cuando el usuario desea dejar de recibir notificaciones

Ejemplo de Uso

import 'package:flutter_firebase_push_notification_provider/flutter_firebase_push_notification_provider.dart';

Future<void> cerrarSesionUsuario() async {
  final notificationProvider = FlutterFireBasePushNotificationProvider();

  try {
    // Anular el token en Firebase y marcar como bloqueado en MongoDB
    // El método usa automáticamente el token actual almacenado
    await notificationProvider.anularToken(
      apiRest: apiRest,
      utilsDataApiRest: utilsDataApiRest,
    );

    print('✅ Token anulado correctamente');
    print('📱 El dispositivo ya no recibirá notificaciones');

    // Continuar con el proceso de cierre de sesión
    // Navigator.pushReplacement(...);

  } catch (e) {
    print('❌ Error al anular token: $e');
    // Manejar el error apropiadamente
    // Podrías mostrar un dialog o continuar con el logout de todas formas
  }
}

Ejemplo Completo en un Botón de Logout

ElevatedButton(
  onPressed: () async {
    // Mostrar diálogo de confirmación
    final confirmar = await showDialog<bool>(
      context: context,
      builder: (context) => AlertDialog(
        title: Text('Cerrar Sesión'),
        content: Text('¿Estás seguro que deseas cerrar sesión?'),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(context, false),
            child: Text('Cancelar'),
          ),
          TextButton(
            onPressed: () => Navigator.pop(context, true),
            child: Text('Sí, cerrar sesión'),
          ),
        ],
      ),
    );

    if (confirmar == true) {
      // Mostrar indicador de carga
      showDialog(
        context: context,
        barrierDismissible: false,
        builder: (context) => Center(child: CircularProgressIndicator()),
      );

      try {
        final notificationProvider = FlutterFireBasePushNotificationProvider();

        // Anular token FCM (usa automáticamente el token actual almacenado)
        await notificationProvider.anularToken(
          apiRest: apiRest,
          utilsDataApiRest: utilsDataApiRest,
        );

        // Limpiar sesión local, SharedPreferences, etc.
        // await _limpiarSesionLocal();

        // Cerrar indicador de carga
        Navigator.pop(context);

        // Navegar a pantalla de login
        Navigator.pushReplacementNamed(context, '/login');

      } catch (e) {
        // Cerrar indicador de carga
        Navigator.pop(context);

        // Mostrar error
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text('Error al cerrar sesión: $e'),
            backgroundColor: Colors.red,
          ),
        );
      }
    }
  },
  child: Text('Cerrar Sesión'),
)

¿Qué hace anularToken() internamente?

1. Verifica el token actual: Comprueba que currentToken no esté vacío
2. Elimina el token de FCM: Llama a FirebaseMessaging.instance.deleteToken() para eliminar el token del dispositivo
3. Consulta MongoDB: Busca todos los registros en la colección tokenFirebase donde:
   • tokenFirebase = token actual almacenado (_currentToken)
   • estado = "activo"
4. Actualiza el estado: Cambia el estado de todos los registros encontrados a "bloqueado"
5. Logs detallados: Registra cada operación para debugging

Gestión de Estados

El sistema utiliza dos estados para los registros de tokens:

Esto permite mantener un historial de tokens sin eliminarlos físicamente de la base de datos, lo cual es útil para:

• 📊 Auditoría: Saber qué dispositivos tenía el usuario
• 🔍 Debugging: Identificar problemas de tokens duplicados
• 📈 Análisis: Estadísticas de uso por dispositivo/plataforma

Manejo de Errores

try {
  await notificationProvider.anularToken(
    apiRest: apiRest,
    utilsDataApiRest: utilsDataApiRest,
  );
} on Exception catch (e) {
  // Error específico de la operación
  if (e.toString().contains('Error al leer registro')) {
    print('⚠️ No se pudo consultar la base de datos');
  } else if (e.toString().contains('Error al cambiar estado')) {
    print('⚠️ No se pudo actualizar el estado del token');
  } else {
    print('❌ Error desconocido: $e');
  }

  // Decidir si continuar con logout de todas formas
  // o mostrar error al usuario
} catch (e) {
  print('❌ Error inesperado: $e');
}

Notas Importantes

• ⚠️ No reinicializar: Después de anular el token, NO intentes inicializar nuevamente sin reiniciar la app
• 🔄 Nuevo login: Si el usuario inicia sesión nuevamente, la app debe reiniciarse o el token debe regenerarse
• 📝 Logging: Todos los pasos se registran en logs de debug para facilitar troubleshooting
• 🗄️ MongoDB: Los registros NO se eliminan, solo se marcan como bloqueado

5. Formato del mensaje #

Los mensajes recibidos en el stream tienen el siguiente formato:

{
  'senderId': String,
  'category': String?,
  'collapseKey': String?,
  'contentAvailable': bool,
  'data': Map<String, dynamic>, // Contiene IdPushNotification
  'from': String?,
  'messageId': String?,
  'messageType': String?,
  'mutableContent': bool,
  'notification': {
    'title': String?,
    'body': String?,
    'android': {...},
    'apple': {...}
  },
  'sentTime': int?, // millisecondsSinceEpoch
  'threadId': String?,
  'ttl': int?
}

Nota importante: Solo se procesarán mensajes que incluyan el campo IdPushNotification en el objeto data.

6. Verificar estado y permisos #

final notificationProvider = FlutterFireBasePushNotificationProvider();

// Verificar si está inicializado
if (notificationProvider.isInitialized) {
  print('✅ Provider inicializado');

  // Verificar permisos
  if (notificationProvider.hasPermission) {
    print('✅ Permisos de notificación otorgados');
  } else {
    print('⚠️ Sin permisos de notificación');
  }
} else {
  print('⚠️ Provider no inicializado');
}

// Verificar si está disposed
if (notificationProvider.isDisposed) {
  print('⚠️ Provider ya fue disposed, necesita reinicio de la app');
}

7. Actualización automática de tokens #

El paquete maneja automáticamente la actualización de tokens en tu servidor MongoDB cuando:

• Se obtiene el token inicial
• El token es actualizado por Firebase (token refresh)

Proceso de Actualización

1. Verificación: El paquete primero verifica si el token ya existe en la base de datos
2. Creación: Si no existe, crea un nuevo documento con toda la información
3. Información Guardada:
   • idUsuario: ID del usuario actual
   • token: Token FCM
   • dispositivo: Marca y modelo del dispositivo (ej: "Samsung Galaxy S21")
   • plataforma: "android" o "ios"
   • appVersion: Versión de la app (ej: "1.0.0")

No necesitas llamar manualmente ningún método, todo se maneja automáticamente una vez inicializado.

8. Manejo del ciclo de vida de la app #

class MyApp extends StatefulWidget {
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);

    // SOLO disponer si la app se está cerrando completamente
    // NO llamar en dispose normal de widgets
    // final notificationProvider = FlutterFireBasePushNotificationProvider();
    // notificationProvider.dispose();

    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Mi App',
      home: HomeScreen(),
    );
  }
}

Manejo de Errores #

El paquete propaga errores apropiadamente, lo que permite manejarlos en tu código:

try {
  await notificationProvider.initializeApp(
    apiRest: apiRest,
    utilsDataApiRest: utilsDataApiRest,
    idUsuario: userId,
    coleccionAuth: 'auth',
  );
} on StateError catch (e) {
  // Error de estado (ya inicializado, disposed, Firebase no inicializado)
  print('Error de estado: $e');
} on FirebaseException catch (e) {
  // Error de Firebase
  print('Error de Firebase: ${e.message}');
} catch (e) {
  // Otros errores (red, API, esquema no encontrado, etc.)
  print('Error inesperado: $e');
}

Características Avanzadas #

Prevención de Memory Leaks #

El paquete gestiona automáticamente todas las subscriptions de Firebase:

• FirebaseMessaging.onMessage
• FirebaseMessaging.onMessageOpenedApp
• FirebaseMessaging.onTokenRefresh

Todas se cancelan apropiadamente cuando se llama a dispose().

Protección contra Inicialización Múltiple #

El método initializeApp() puede llamarse múltiples veces de forma segura. Las llamadas adicionales serán ignoradas con un log de debug.

Manejo de Background Messages #

Los mensajes en background se procesan automáticamente incluso cuando la app está cerrada, gracias al handler @pragma('vm:entry-point') que se ejecuta en un isolate separado.

Verificación de Tokens Duplicados #

Antes de crear un nuevo registro en MongoDB, el paquete verifica si el token ya existe para evitar duplicados. Esto optimiza el uso de recursos y mantiene la base de datos limpia.

Additional information #

Notas técnicas #

• El manejador de mensajes en background se ejecuta en un isolate separado
• Los mensajes se filtran por el campo IdPushNotification en data
• El logging solo aparece en modo debug (kDebugMode)
• Todas las subscriptions se manejan internamente para prevenir memory leaks
• Los tokens se actualizan automáticamente en el servidor con información del dispositivo
• La consulta MongoDB utiliza escapado de caracteres para prevenir inyecciones
• Los métodos _getDeviceInfo() y _getAppVersion() se ejecutan en paralelo para mejor performance
• La colección tokenFirebase está configurada en EnvironmentPushNotification.coleccionTokenFirebase
• El orden de campos en EnvironmentPushNotification.camposColeccionTokenFirebase es crítico y no debe alterarse
• Los tokens se gestionan con estados activo y bloqueado para mantener historial
• El método anularToken() elimina el token de FCM y marca registros como bloqueados en MongoDB
• Las consultas de verificación filtran solo tokens con estado activo
• Los tokens bloqueados se mantienen en la base de datos para auditoría y análisis

Solución de Problemas Comunes #

Error: "Firebase no está inicializado"

// Asegúrate de inicializar Firebase antes
await Firebase.initializeApp();

Error: "No se puede inicializar: la instancia ya fue disposed"

// Necesitas reiniciar la app. El singleton no puede ser reinicializado después de dispose()

Error: "No se pudo obtener esquema de la colección"

// Verifica que tu servidor tenga configurada la colección 'tokenFirebase'
// y que apiRest.obtieneEsquema() pueda acceder a ella

No recibo notificaciones en background

// Verifica que el mensaje incluya IdPushNotification en data
{
  "notification": {
    "title": "Título",
    "body": "Mensaje"
  },
  "data": {
    "IdPushNotification": "unique-id-123"  // ← Requerido
  }
}

Permisos de notificación denegados

// En iOS, los permisos solo se pueden solicitar una vez
// El usuario debe ir a Settings -> Tu App -> Notifications para habilitarlos
// En Android, se pueden solicitar múltiples veces

Token no se actualiza en el servidor

// Verifica:
// 1. Que la colección 'tokenFirebase' exista en MongoDB
// 2. Que el esquema sea correcto
// 3. Que apiRest tenga las credenciales correctas
// 4. Revisa los logs de debug para ver el error específico

Error: "Token ya existe en la base de datos"

// Esto es normal. El paquete verifica si el token existe antes de crear uno nuevo
// Este mensaje solo aparece en logs de debug y no es un error

Error al anular token

// Si anularToken() falla:
// 1. Verifica que haya un token actual almacenado (currentToken no vacío)
// 2. Verifica la conexión a MongoDB
// 3. Revisa los logs de debug para ver el error específico
// 4. Considera continuar con el logout incluso si falla (seguridad)

try {
  await notificationProvider.anularToken(
    apiRest: apiRest,
    utilsDataApiRest: utilsDataApiRest,
  );
} catch (e) {
  print('Error al anular token: $e');
  // Continuar con logout de todas formas
  _procederConLogout();
}

Token bloqueado sigue recibiendo notificaciones

// Los tokens bloqueados en MongoDB NO bloquean el envío desde Firebase
// Para detener las notificaciones completamente debes:
// 1. Usar anularToken() que elimina el token del dispositivo
// 2. NO enviar notificaciones a tokens marcados como 'bloqueado' desde tu servidor
// 3. Filtrar tokens activos al enviar notificaciones masivas

Ejemplo de Implementación Completa con BLoC #

Este ejemplo muestra cómo integrar el paquete en una aplicación Flutter usando el patrón BLoC para gestionar el estado de las notificaciones push.

1. Listener de Autenticación #

Primero, configuramos los listeners en relación al login para inicializar Firebase o anular el token cuando el usuario cierra sesión:

///[AUTH]
BlocListener<AuthBloc, AuthState>(
  listenWhen: (previous, current) => !current.isWorking,
  listener: (context, state) {
    if (state.error.isEmpty) {
      if (state.accion == AuthBloc.blocOnLoginAuth) {
        final estadoUsuario =
            FlutterUtilsProvider.determinaValorCampo([
              EnvironmentApiRest.estado,
            ], state.usuarioAuth);
        if (estadoUsuario == EstadoRegistro.bloqueado.valor) {
          ///TODO - Mostrar dialogo de cuenta bloqueada
          return;
        }
        final DataShpProvider shp = DataShpProvider();
        if (state.isLoggedIn &&
            !shp.keyLogin.startsWith(
              EnvironmentApiRest.userFlutter,
            )) {
          //
          context.read<ConfigAppBloc>().add(
            OnInitPushNotificaciones(
              usuarioAuth: state.usuarioAuth,
            ),
          );
        }
      }
      if (state.accion == AuthBloc.blocOnLogoutAuth) {
        context.read<ConfigAppBloc>().add(OnAnulaTokenFirebase());
      }
    }
  },
)

2. Eventos del BLoC #

Define los eventos que se dispararán para manejar las notificaciones push:

///Evento que inicializa las push notificaciones de Firebase
class OnInitPushNotificaciones extends ConfigAppEvent {
  final Map<String, dynamic> usuarioAuth;
  OnInitPushNotificaciones({required this.usuarioAuth});
  @override
  List<Object> get props => [usuarioAuth];
}

///Evento que se lanza cuando llega una nueva notificacion desde Firebase
class OnNuevaNotificacionFirebase extends ConfigAppEvent {
  final Map<String, dynamic> firebaseNotification;
  OnNuevaNotificacionFirebase({required this.firebaseNotification});
  @override
  List<Object> get props => [firebaseNotification];
}

///Evento que se lanza cuando se cierra sesion entonces se debe anular el token
///de firebase para que no lleguen mas notificaciones a este usuario
class OnAnulaTokenFirebase extends ConfigAppEvent {
  OnAnulaTokenFirebase();
  @override
  List<Object> get props => [];
}

3. Manejadores de Eventos en el BLoC #

Implementa los métodos que responden a estos eventos:

Future<void> _onInitPushNotificaciones(
  OnInitPushNotificaciones event,
  Emitter<ConfigAppState> emit,
) async {
  await _handleAction(onInitPushNotificaciones, emit, () async {
    if (notificationFireBaseProvider.isInitialized) {
      debugPrint(
        'Push notifications ya inicializadas, se omite reinicialización.',
      );
      return;
    }
    debugPrint('🔔 notificationFireBaseProvider.initializeApp Inicializa');
    await notificationFireBaseProvider.initializeApp(
      apiRest: apiRest,
      utilsDataApiRest: UtilsDataApiRest(apiRest: apiRest),
      idUsuario: event.usuarioAuth[EnvironmentApiRest.idServer],
      coleccionAuth: Environment.origenColeccion,
    );

    debugPrint('🔔 notificationFireBaseProvider.initializeApp');

    notificationFireBaseProvider.messagesStream.listen((mensaje) {
      debugPrint('🔔 Mensaje Firebase recibido: $mensaje');

      add(OnNuevaNotificacionFirebase(firebaseNotification: mensaje));
    });
  });
}

Future<void> _onNuevaNotificacionFirebase(
  OnNuevaNotificacionFirebase event,
  Emitter<ConfigAppState> emit,
) async {
  await _handleAction(onNuevaNotificacionFirebase, emit, () async {
    emit(state.copyWith(firebaseNotification: event.firebaseNotification));
  });
}

Future<void> _onAnulaTokenFirebase(
  OnAnulaTokenFirebase event,
  Emitter<ConfigAppState> emit,
) async {
  await _handleAction(onAnulaTokenFirebase, emit, () async {
    if (!notificationFireBaseProvider.isInitialized) {
      debugPrint(
        'Push notifications no están inicializadas, no hay nada que anular.',
      );
      return;
    }
    await notificationFireBaseProvider.anularToken(
      apiRest: apiRest,
      utilsDataApiRest: UtilsDataApiRest(apiRest: apiRest),
    );
  });
}

Flujo Completo #

1. Login: Cuando el usuario inicia sesión exitosamente, se dispara OnInitPushNotificaciones
2. Inicialización: El BLoC inicializa el provider de notificaciones con el ID del usuario
3. Escucha de Mensajes: Se suscribe al stream de mensajes y dispara OnNuevaNotificacionFirebase cuando llega una notificación
4. Actualización de Estado: El evento actualiza el estado del BLoC con la nueva notificación
5. Logout: Cuando el usuario cierra sesión, se dispara OnAnulaTokenFirebase que elimina el token y lo marca como bloqueado en MongoDB

Ventajas de este Patrón #

• ✅ Separación de Responsabilidades: La lógica de notificaciones está separada de la UI
• ✅ Testeable: Los eventos y estados pueden ser fácilmente testeados
• ✅ Mantenible: Cambios en la lógica de notificaciones no afectan otros componentes
• ✅ Escalable: Fácil agregar nuevos eventos o estados relacionados con notificaciones
• ✅ Reactivo: La UI se actualiza automáticamente cuando cambia el estado

Arquitectura Interna #

Flujo de Actualización de Token #

┌─────────────────┐
│ Inicialización  │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Obtener Token   │
└────────┬────────┘
         │
         ▼
┌──────────────────────┐
│ Verificar Existencia │ ──► Si existe: Log y Retornar
└──────────┬───────────┘
           │
           ▼ No existe
┌──────────────────────┐
│ Obtener Info Device  │ ──┐
│ & App Version        │   │ (Paralelo)
└──────────┬───────────┘   │
           │               │
           ▼               ▼
┌──────────────────────────┐
│ Crear Documento MongoDB  │
└──────────┬───────────────┘
           │
           ▼
┌──────────────────────┐
│ Guardar en Servidor  │
└──────────────────────┘

Licencia #

Este proyecto está bajo la licencia especificada en el archivo LICENSE.

Versión #

v3.0.0 - Versión estable para web con:

• ✅ Gestión automática de memoria
• ✅ Prevención de memory leaks
• ✅ Protección contra inicialización múltiple
• ✅ Manejo robusto de errores
• ✅ Actualización automática de tokens
• ✅ Integración con información del dispositivo
• ✅ Verificación de tokens existentes
• ✅ Configuración centralizada en EnvironmentPushNotification
• ✅ Escapado de consultas MongoDB para seguridad
• ✅ Performance optimizado con llamadas paralelas
• ✅ Método getToken() para obtener token manualmente
• ✅ Método anularToken() para eliminar y bloquear tokens
• ✅ Gestión de estados (activo/bloqueado) para tokens
• ✅ Historial de tokens con estado bloqueado

Changelog #

Ver CHANGELOG.md para el historial completo de cambios.