rothzerg 0.1.0

package/templates/mobile-app/lib/core/services/messaging_service.dart

@@ -0,0 +1,460 @@
+import 'package:firebase_messaging/firebase_messaging.dart';
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'dart:developer' as developer;
+import 'dart:io';
+import 'device_service.dart';
+import 'in_app_messaging_service.dart';
+
+/// Top-level function to handle background messages
+@pragma('vm:entry-point')
+Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
+  developer.log(
+    'Handling background message: ${message.messageId}',
+    name: 'MessagingService',
+  );
+}
+
+class MessagingService {
+  static final MessagingService _instance = MessagingService._internal();
+  factory MessagingService() => _instance;
+  MessagingService._internal();
+
+  final FirebaseMessaging _firebaseMessaging = FirebaseMessaging.instance;
+  final FlutterLocalNotificationsPlugin _localNotifications =
+      FlutterLocalNotificationsPlugin();
+  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
+
+  bool _isInitialized = false;
+  String? _fcmToken;
+  String? _userId; // Store userId for later use
+
+  String? get fcmToken => _fcmToken;
+
+  /// Initialize Firebase Cloud Messaging
+  Future<void> initialize({
+    String? userId,
+    bool requestPermission = false,
+  }) async {
+    if (_isInitialized) {
+      developer.log('FCM already initialized', name: 'MessagingService');
+      return;
+    }
+
+    try {
+      developer.log('Initializing FCM...', name: 'MessagingService');
+
+      // Store userId for later use
+      _userId = userId;
+
+      // Request notification permissions only if explicitly requested
+      if (requestPermission) {
+        await _requestPermission();
+      }
+
+      // Initialize local notifications
+      await _initializeLocalNotifications();
+
+      // Set up background message handler
+      FirebaseMessaging.onBackgroundMessage(
+        _firebaseMessagingBackgroundHandler,
+      );
+
+      // Get and save FCM token
+      await _setupTokenHandling(userId);
+
+      // Handle foreground messages
+      FirebaseMessaging.onMessage.listen(_handleForegroundMessage);
+
+      // Handle notification taps (when app is in background or terminated)
+      FirebaseMessaging.onMessageOpenedApp.listen(_handleMessageOpenedApp);
+
+      // Check if app was opened from a notification
+      final initialMessage = await _firebaseMessaging.getInitialMessage();
+      if (initialMessage != null) {
+        _handleMessageOpenedApp(initialMessage);
+      }
+
+      _isInitialized = true;
+      developer.log('✅ FCM initialized successfully', name: 'MessagingService');
+    } catch (e) {
+      developer.log(
+        '❌ FCM initialization failed: $e',
+        name: 'MessagingService',
+      );
+    }
+  }
+
+  /// Request notification permissions with optional delay
+  Future<void> requestPermissionWithDelay({
+    Duration delay = const Duration(seconds: 5),
+  }) async {
+    developer.log(
+      'Will request notification permission in ${delay.inSeconds} seconds...',
+      name: 'MessagingService',
+    );
+    await Future.delayed(delay);
+    await _requestPermission();
+  }
+
+  /// Request notification permissions
+  Future<void> _requestPermission() async {
+    try {
+      final settings = await _firebaseMessaging.requestPermission(
+        alert: true,
+        badge: true,
+        sound: true,
+        provisional: false,
+        announcement: false,
+        carPlay: false,
+        criticalAlert: false,
+      );
+
+      developer.log(
+        'Notification permission status: ${settings.authorizationStatus}',
+        name: 'MessagingService',
+      );
+
+      if (settings.authorizationStatus == AuthorizationStatus.authorized) {
+        developer.log('✅ User granted permission', name: 'MessagingService');
+        // Get and save FCM token after permission is granted
+        await _getAndSaveToken();
+      } else if (settings.authorizationStatus ==
+          AuthorizationStatus.provisional) {
+        developer.log(
+          '✅ User granted provisional permission',
+          name: 'MessagingService',
+        );
+        // Get and save FCM token after permission is granted
+        await _getAndSaveToken();
+      } else {
+        developer.log(
+          '⚠️ User declined or has not accepted permission',
+          name: 'MessagingService',
+        );
+      }
+    } catch (e) {
+      developer.log(
+        '❌ Permission request failed: $e',
+        name: 'MessagingService',
+      );
+    }
+  }
+
+  /// Initialize local notifications for displaying foreground messages
+  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(
+      settings: initSettings,
+      onDidReceiveNotificationResponse: _onNotificationTapped,
+    );
+
+    // Create notification channel for Android
+    if (Platform.isAndroid) {
+      const channel = AndroidNotificationChannel(
+        'high_importance_channel', // id
+        'High Importance Notifications', // name
+        description: 'This channel is used for important notifications.',
+        importance: Importance.high,
+      );
+
+      await _localNotifications
+          .resolvePlatformSpecificImplementation<
+            AndroidFlutterLocalNotificationsPlugin
+          >()
+          ?.createNotificationChannel(channel);
+    }
+  }
+
+  /// Get and save FCM token (called after permission is granted)
+  Future<void> _getAndSaveToken() async {
+    try {
+      developer.log('Getting FCM token...', name: 'MessagingService');
+
+      // On iOS, wait a bit for token to be ready after permission
+      if (Platform.isIOS) {
+        await Future.delayed(const Duration(milliseconds: 500));
+      }
+
+      final token = await _firebaseMessaging.getToken();
+
+      if (token != null) {
+        _fcmToken = token;
+        developer.log(
+          '📱 FCM Token obtained: $token',
+          name: 'MessagingService',
+        );
+
+        // Save to Firestore if userId is available
+        if (_userId != null && _userId!.isNotEmpty) {
+          await saveFCMToken(_userId!, token);
+        }
+      } else {
+        developer.log('⚠️ FCM token is still null', name: 'MessagingService');
+      }
+    } catch (e) {
+      developer.log('❌ Failed to get FCM token: $e', name: 'MessagingService');
+    }
+  }
+
+  /// Set up FCM token handling
+  Future<void> _setupTokenHandling(String? userId) async {
+    try {
+      // On iOS, we need to wait for APNS token before getting FCM token
+      if (Platform.isIOS) {
+        // Wait a bit for APNS token to be available
+        await Future.delayed(const Duration(seconds: 1));
+      }
+
+      // Get the FCM token
+      _fcmToken = await _firebaseMessaging.getToken();
+
+      if (_fcmToken != null) {
+        developer.log('📱 FCM Token: $_fcmToken', name: 'MessagingService');
+
+        // Save token to Firestore if user is logged in
+        if (userId != null && userId.isNotEmpty) {
+          await saveFCMToken(userId, _fcmToken!);
+        }
+      } else {
+        developer.log('⚠️ FCM token is null', name: 'MessagingService');
+
+        // On iOS, if token is null, wait for it via token refresh listener
+        if (Platform.isIOS) {
+          developer.log(
+            '⏳ Waiting for APNS token on iOS...',
+            name: 'MessagingService',
+          );
+        }
+      }
+
+      // Listen for token refresh
+      _firebaseMessaging.onTokenRefresh.listen((newToken) {
+        developer.log(
+          '🔄 FCM Token refreshed: $newToken',
+          name: 'MessagingService',
+        );
+        _fcmToken = newToken;
+
+        // Use stored userId if available
+        final currentUserId = userId ?? _userId;
+        if (currentUserId != null && currentUserId.isNotEmpty) {
+          saveFCMToken(currentUserId, newToken);
+        }
+      });
+    } catch (e) {
+      developer.log('❌ Token setup failed: $e', name: 'MessagingService');
+
+      // Don't fail the entire initialization if token retrieval fails
+      // Token will be available via onTokenRefresh listener
+      if (Platform.isIOS) {
+        developer.log(
+          '💡 Token will be available once APNS token is received',
+          name: 'MessagingService',
+        );
+      }
+    }
+  }
+
+  /// Save FCM token to Firestore devices collection
+  Future<void> saveFCMToken(String userId, String fcmToken) async {
+    try {
+      // Get device ID from device info
+      final deviceId = await _getDeviceId();
+
+      if (deviceId.isEmpty) {
+        developer.log(
+          '⚠️ Device ID is empty, skipping FCM token save',
+          name: 'MessagingService',
+        );
+        return;
+      }
+
+      developer.log(
+        '💾 Saving FCM token to Firestore...',
+        name: 'MessagingService',
+      );
+
+      // Get FIAM installation ID if available
+      final inAppMessagingService = InAppMessagingService();
+      final installationId = inAppMessagingService.installationId;
+
+      final data = {
+        'userId': userId,
+        'fcmToken': fcmToken,
+        'fcmTokenUpdatedAt': FieldValue.serverTimestamp(),
+        'lastSeenAt': FieldValue.serverTimestamp(),
+      };
+
+      // Add Firebase installation ID if available
+      if (installationId != null) {
+        data['installationId'] = installationId;
+        data['installationIdUpdatedAt'] = FieldValue.serverTimestamp();
+        developer.log(
+          '💾 Including Firebase installation ID: ${installationId.substring(0, 8)}...',
+          name: 'MessagingService',
+        );
+      }
+
+      await _firestore
+          .collection('devices')
+          .doc(deviceId)
+          .set(data, SetOptions(merge: true));
+
+      developer.log('✅ FCM token saved successfully', name: 'MessagingService');
+    } catch (e) {
+      developer.log('❌ Failed to save FCM token: $e', name: 'MessagingService');
+    }
+  }
+
+  /// Get device ID (reusing logic from DeviceService)
+  Future<String> _getDeviceId() async {
+    try {
+      final deviceService = DeviceService();
+      return await deviceService.getDeviceId();
+    } catch (e) {
+      developer.log('❌ Failed to get device ID: $e', name: 'MessagingService');
+      return '';
+    }
+  }
+
+  /// Handle foreground messages
+  void _handleForegroundMessage(RemoteMessage message) {
+    developer.log(
+      'Received foreground message: ${message.messageId}',
+      name: 'MessagingService',
+    );
+
+    // Show local notification when app is in foreground
+    _showLocalNotification(message);
+  }
+
+  /// Show local notification
+  Future<void> _showLocalNotification(RemoteMessage message) async {
+    final notification = message.notification;
+    final android = message.notification?.android;
+
+    if (notification != null) {
+      await _localNotifications.show(
+        id: notification.hashCode,
+        title: notification.title,
+        body: notification.body,
+        notificationDetails: NotificationDetails(
+          android: AndroidNotificationDetails(
+            'high_importance_channel',
+            'High Importance Notifications',
+            channelDescription:
+                'This channel is used for important notifications.',
+            importance: Importance.high,
+            priority: Priority.high,
+            icon: android?.smallIcon ?? '@mipmap/ic_launcher',
+          ),
+          iOS: const DarwinNotificationDetails(
+            presentAlert: true,
+            presentBadge: true,
+            presentSound: true,
+          ),
+        ),
+        payload: message.data.toString(),
+      );
+    }
+  }
+
+  /// Handle notification tap
+  void _onNotificationTapped(NotificationResponse response) {
+    developer.log(
+      'Notification tapped: ${response.payload}',
+      name: 'MessagingService',
+    );
+    // TODO: Navigate to specific screen based on payload
+  }
+
+  /// Handle message opened app (when app is in background or terminated)
+  void _handleMessageOpenedApp(RemoteMessage message) {
+    developer.log(
+      'Message opened app: ${message.messageId}',
+      name: 'MessagingService',
+    );
+    // TODO: Navigate to specific screen based on message data
+  }
+
+  /// Subscribe to a topic
+  Future<void> subscribeToTopic(String topic) async {
+    try {
+      await _firebaseMessaging.subscribeToTopic(topic);
+      developer.log('✅ Subscribed to topic: $topic', name: 'MessagingService');
+    } catch (e) {
+      developer.log(
+        '❌ Failed to subscribe to topic: $e',
+        name: 'MessagingService',
+      );
+    }
+  }
+
+  /// Unsubscribe from a topic
+  Future<void> unsubscribeFromTopic(String topic) async {
+    try {
+      await _firebaseMessaging.unsubscribeFromTopic(topic);
+      developer.log(
+        '✅ Unsubscribed from topic: $topic',
+        name: 'MessagingService',
+      );
+    } catch (e) {
+      developer.log(
+        '❌ Failed to unsubscribe from topic: $e',
+        name: 'MessagingService',
+      );
+    }
+  }
+
+  /// Delete FCM token
+  Future<void> deleteToken() async {
+    try {
+      await _firebaseMessaging.deleteToken();
+      _fcmToken = null;
+      developer.log('✅ FCM token deleted', name: 'MessagingService');
+    } catch (e) {
+      developer.log(
+        '❌ Failed to delete FCM token: $e',
+        name: 'MessagingService',
+      );
+    }
+  }
+
+  /// Clean up FCM token from Firestore (call on sign out)
+  Future<void> removeFCMTokenFromFirestore(String userId) async {
+    try {
+      final deviceId = await _getDeviceId();
+
+      if (deviceId.isEmpty) return;
+
+      await _firestore.collection('devices').doc(deviceId).set({
+        'fcmToken': FieldValue.delete(),
+        'fcmTokenUpdatedAt': FieldValue.delete(),
+      }, SetOptions(merge: true));
+
+      developer.log(
+        '✅ FCM token removed from Firestore',
+        name: 'MessagingService',
+      );
+    } catch (e) {
+      developer.log(
+        '❌ Failed to remove FCM token from Firestore: $e',
+        name: 'MessagingService',
+      );
+    }
+  }
+}

package/templates/mobile-app/lib/core/services/remote_config_service.dart

@@ -0,0 +1,167 @@
+import 'package:firebase_remote_config/firebase_remote_config.dart';
+import 'dart:developer' as developer;
+
+import '../constants/app_constants.dart';
+
+/// Service for managing Firebase Remote Config
+/// Provides feature flags and remote configuration
+class RemoteConfigService {
+  static final RemoteConfigService _instance = RemoteConfigService._internal();
+  factory RemoteConfigService() => _instance;
+  RemoteConfigService._internal();
+
+  final FirebaseRemoteConfig _remoteConfig = FirebaseRemoteConfig.instance;
+  bool _initialized = false;
+
+  /// Initialize Remote Config with default values
+  Future<void> initialize() async {
+    if (_initialized) return;
+
+    try {
+      // Set config settings
+      await _remoteConfig.setConfigSettings(
+        RemoteConfigSettings(
+          fetchTimeout: AppConstants.remoteConfigFetchTimeout,
+          minimumFetchInterval: AppConstants.remoteConfigCacheDuration,
+        ),
+      );
+
+      // Set default values
+      await _remoteConfig.setDefaults(_defaultValues);
+
+      // Fetch and activate
+      await _remoteConfig.fetchAndActivate();
+
+      _initialized = true;
+      developer.log('RemoteConfigService initialized', name: 'RemoteConfig');
+    } catch (e) {
+      developer.log(
+        'Failed to initialize RemoteConfig: $e',
+        name: 'RemoteConfig',
+        error: e,
+      );
+      // Don't rethrow - app should work with defaults
+    }
+  }
+
+  /// Default values for remote config
+  static const Map<String, dynamic> _defaultValues = {
+    AppConstants.rcEnableGoogleAuth: false,
+    AppConstants.rcEnableAppleAuth: false,
+    AppConstants.rcEnableAnonymousAuth: true,
+    AppConstants.rcMaintenanceMode: false,
+    AppConstants.rcMinimumVersion: '1.0.0',
+    AppConstants.rcForceUpdate: false,
+  };
+
+  // ============= Feature Flags =============
+
+  bool get enableGoogleAuth {
+    return _remoteConfig.getBool(AppConstants.rcEnableGoogleAuth);
+  }
+
+  bool get enableAppleAuth {
+    return _remoteConfig.getBool(AppConstants.rcEnableAppleAuth);
+  }
+
+  bool get enableAnonymousAuth {
+    return _remoteConfig.getBool(AppConstants.rcEnableAnonymousAuth);
+  }
+
+  bool get maintenanceMode {
+    return _remoteConfig.getBool(AppConstants.rcMaintenanceMode);
+  }
+
+  String get minimumVersion {
+    return _remoteConfig.getString(AppConstants.rcMinimumVersion);
+  }
+
+  bool get forceUpdate {
+    return _remoteConfig.getBool(AppConstants.rcForceUpdate);
+  }
+
+  // ============= Generic Getters =============
+
+  bool getBool(String key) {
+    return _remoteConfig.getBool(key);
+  }
+
+  String getString(String key) {
+    return _remoteConfig.getString(key);
+  }
+
+  int getInt(String key) {
+    return _remoteConfig.getInt(key);
+  }
+
+  double getDouble(String key) {
+    return _remoteConfig.getDouble(key);
+  }
+
+  // ============= Refresh Config =============
+
+  Future<bool> fetchConfig() async {
+    try {
+      final updated = await _remoteConfig.fetchAndActivate();
+      developer.log(
+        'Config fetched: ${updated ? "updated" : "no changes"}',
+        name: 'RemoteConfig',
+      );
+      return updated;
+    } catch (e) {
+      developer.log(
+        'Failed to fetch config: $e',
+        name: 'RemoteConfig',
+        error: e,
+      );
+      return false;
+    }
+  }
+
+  /// Force fetch config (ignores cache)
+  Future<bool> forceFetchConfig() async {
+    try {
+      await _remoteConfig.setConfigSettings(
+        RemoteConfigSettings(
+          fetchTimeout: AppConstants.remoteConfigFetchTimeout,
+          minimumFetchInterval: Duration.zero,
+        ),
+      );
+      final updated = await _remoteConfig.fetchAndActivate();
+
+      // Reset to normal fetch interval
+      await _remoteConfig.setConfigSettings(
+        RemoteConfigSettings(
+          fetchTimeout: AppConstants.remoteConfigFetchTimeout,
+          minimumFetchInterval: AppConstants.remoteConfigCacheDuration,
+        ),
+      );
+
+      developer.log('Config force fetched', name: 'RemoteConfig');
+      return updated;
+    } catch (e) {
+      developer.log(
+        'Failed to force fetch config: $e',
+        name: 'RemoteConfig',
+        error: e,
+      );
+      return false;
+    }
+  }
+
+  // ============= Utility Methods =============
+
+  Map<String, dynamic> getAllValues() {
+    return _remoteConfig.getAll().map(
+      (key, value) => MapEntry(key, value.asString()),
+    );
+  }
+
+  DateTime get lastFetchTime {
+    return _remoteConfig.lastFetchTime;
+  }
+
+  RemoteConfigFetchStatus get lastFetchStatus {
+    return _remoteConfig.lastFetchStatus;
+  }
+}