Flutter 푸시 노티피케이션 완벽 가이드 3편: 생명주기와 상태 관리

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

class AppLifecycleService with WidgetsBindingObserver {
  static final AppLifecycleService _instance = AppLifecycleService._internal();
  factory AppLifecycleService() => _instance;
  AppLifecycleService._internal();

  AppLifecycleState _currentState = AppLifecycleState.resumed;
  DateTime? _backgroundTime;
  DateTime? _foregroundTime;
  
  final List<Function(AppLifecycleState)> _listeners = [];

  AppLifecycleState get currentState => _currentState;
  bool get isInForeground => _currentState == AppLifecycleState.resumed;
  bool get isInBackground => _currentState == AppLifecycleState.paused;

  void initialize() {
    WidgetsBinding.instance.addObserver(this);
    _currentState = WidgetsBinding.instance.lifecycleState ?? AppLifecycleState.resumed;
  }

  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    _listeners.clear();
  }

  void addListener(Function(AppLifecycleState) listener) {
    _listeners.add(listener);
  }

  void removeListener(Function(AppLifecycleState) listener) {
    _listeners.remove(listener);
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    super.didChangeAppLifecycleState(state);
    
    final previousState = _currentState;
    _currentState = state;

    _handleLifecycleTransition(previousState, state);
    
    for (final listener in _listeners) {
      listener(state);
    }
  }

  void _handleLifecycleTransition(
    AppLifecycleState from,
    AppLifecycleState to,
  ) {
    switch (to) {
      case AppLifecycleState.resumed:
        _onAppResumed(from);
        break;
      case AppLifecycleState.paused:
        _onAppPaused();
        break;
      case AppLifecycleState.inactive:
        _onAppInactive();
        break;
      case AppLifecycleState.detached:
        _onAppDetached();
        break;
      case AppLifecycleState.hidden:
        _onAppHidden();
        break;
    }
  }

  void _onAppResumed(AppLifecycleState from) {
    _foregroundTime = DateTime.now();
    print('앱이 포그라운드로 전환됨');
    
    if (from == AppLifecycleState.paused && _backgroundTime != null) {
      final backgroundDuration = _foregroundTime!.difference(_backgroundTime!);
      _handleBackgroundReturn(backgroundDuration);
    }
  }

  void _onAppPaused() {
    _backgroundTime = DateTime.now();
    print('앱이 백그라운드로 전환됨');
    _prepareBackgroundTasks();
  }

  void _onAppInactive() {
    print('앱이 비활성 상태로 전환됨');
  }

  void _onAppHidden() {
    print('앱이 숨겨짐');
  }

  void _onAppDetached() {
    print('앱이 종료됨');
    _saveAppState();
  }

  void _handleBackgroundReturn(Duration backgroundDuration) {
    print('백그라운드 시간: \${backgroundDuration.inSeconds}초');
    
    if (backgroundDuration.inMinutes > 5) {
      _refreshAppData();
    }
    
    NotificationQueueService().processPendingNotifications();
  }

  void _prepareBackgroundTasks() {
    // 불필요한 리소스 정리
  }

  void _saveAppState() {
    // SharedPreferences 등에 현재 상태 저장
  }

  void _refreshAppData() {
    print('앱 데이터 새로고침 중...');
  }
}

import 'package:flutter_riverpod/flutter_riverpod.dart';

class NotificationItem {
  final String id;
  final String title;
  final String body;
  final NotificationType type;
  final Map<String, dynamic> data;
  final DateTime receivedAt;
  final bool isRead;
  final bool isArchived;
  final String? imageUrl;

  const NotificationItem({
    required this.id,
    required this.title,
    required this.body,
    required this.type,
    required this.data,
    required this.receivedAt,
    this.isRead = false,
    this.isArchived = false,
    this.imageUrl,
  });

  NotificationItem copyWith({
    String? id,
    String? title,
    String? body,
    NotificationType? type,
    Map<String, dynamic>? data,
    DateTime? receivedAt,
    bool? isRead,
    bool? isArchived,
    String? imageUrl,
  }) {
    return NotificationItem(
      id: id ?? this.id,
      title: title ?? this.title,
      body: body ?? this.body,
      type: type ?? this.type,
      data: data ?? this.data,
      receivedAt: receivedAt ?? this.receivedAt,
      isRead: isRead ?? this.isRead,
      isArchived: isArchived ?? this.isArchived,
      imageUrl: imageUrl ?? this.imageUrl,
    );
  }

  Map<String, dynamic> toMap() {
    return {
      'id': id,
      'title': title,
      'body': body,
      'type': type.name,
      'data': data,
      'receivedAt': receivedAt.toIso8601String(),
      'isRead': isRead,
      'isArchived': isArchived,
      'imageUrl': imageUrl,
    };
  }

  factory NotificationItem.fromMap(Map<String, dynamic> map) {
    return NotificationItem(
      id: map['id'],
      title: map['title'],
      body: map['body'],
      type: NotificationType.fromString(map['type']),
      data: Map<String, dynamic>.from(map['data']),
      receivedAt: DateTime.parse(map['receivedAt']),
      isRead: map['isRead'] ?? false,
      isArchived: map['isArchived'] ?? false,
      imageUrl: map['imageUrl'],
    );
  }
}

class NotificationState {
  final List<NotificationItem> notifications;
  final int unreadCount;
  final bool isLoading;
  final String? error;

  const NotificationState({
    this.notifications = const [],
    this.unreadCount = 0,
    this.isLoading = false,
    this.error,
  });

  NotificationState copyWith({
    List<NotificationItem>? notifications,
    int? unreadCount,
    bool? isLoading,
    String? error,
  }) {
    return NotificationState(
      notifications: notifications ?? this.notifications,
      unreadCount: unreadCount ?? this.unreadCount,
      isLoading: isLoading ?? this.isLoading,
      error: error ?? this.error,
    );
  }
}

import 'package:shared_preferences/shared_preferences.dart';
import 'dart:convert';

class NotificationStorage {
  static final NotificationStorage _instance = NotificationStorage._internal();
  factory NotificationStorage() => _instance;
  NotificationStorage._internal();

  static const String _notificationsKey = 'stored_notifications';
  static const int _maxStorageCount = 100;

  Future<void> saveNotification(NotificationItem notification) async {
    final prefs = await SharedPreferences.getInstance();
    final notifications = await getNotifications();
    
    final updatedNotifications = [notification, ...notifications];
    
    if (updatedNotifications.length > _maxStorageCount) {
      updatedNotifications.removeRange(_maxStorageCount, updatedNotifications.length);
    }
    
    final jsonList = updatedNotifications.map((n) => n.toMap()).toList();
    await prefs.setString(_notificationsKey, json.encode(jsonList));
  }

  Future<List<NotificationItem>> getNotifications() async {
    final prefs = await SharedPreferences.getInstance();
    final jsonString = prefs.getString(_notificationsKey);
    
    if (jsonString == null) return [];
    
    try {
      final jsonList = json.decode(jsonString) as List;
      return jsonList.map((json) => NotificationItem.fromMap(json)).toList();
    } catch (e) {
      print('노티피케이션 로드 오류: $e');
      return [];
    }
  }

  Future<void> markAsRead(String id) async {
    final notifications = await getNotifications();
    final updatedNotifications = notifications.map((n) {
      return n.id == id ? n.copyWith(isRead: true) : n;
    }).toList();
    
    await _saveNotifications(updatedNotifications);
  }

  Future<void> markAllAsRead() async {
    final notifications = await getNotifications();
    final updatedNotifications = notifications.map((n) {
      return n.copyWith(isRead: true);
    }).toList();
    
    await _saveNotifications(updatedNotifications);
  }

  Future<void> deleteNotification(String id) async {
    final notifications = await getNotifications();
    final updatedNotifications = notifications.where((n) => n.id != id).toList();
    
    await _saveNotifications(updatedNotifications);
  }

  Future<void> cleanupOldNotifications({int daysToKeep = 30}) async {
    final notifications = await getNotifications();
    final cutoffDate = DateTime.now().subtract(Duration(days: daysToKeep));
    
    final filteredNotifications = notifications.where((n) {
      return n.receivedAt.isAfter(cutoffDate);
    }).toList();
    
    await _saveNotifications(filteredNotifications);
  }

  Future<void> _saveNotifications(List<NotificationItem> notifications) async {
    final prefs = await SharedPreferences.getInstance();
    final jsonList = notifications.map((n) => n.toMap()).toList();
    await prefs.setString(_notificationsKey, json.encode(jsonList));
  }

  Future<void> clearAll() async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.remove(_notificationsKey);
  }
}

import 'dart:collection';
import 'dart:async';

class NotificationQueueService {
  static final NotificationQueueService _instance = NotificationQueueService._internal();
  factory NotificationQueueService() => _instance;
  NotificationQueueService._internal();

  final Queue<NotificationItem> _queue = Queue<NotificationItem>();
  final Queue<NotificationItem> _priorityQueue = Queue<NotificationItem>();
  
  Timer? _processingTimer;
  bool _isProcessing = false;
  static const Duration _processingInterval = Duration(seconds: 2);

  void start() {
    if (_processingTimer?.isActive == true) return;
    
    _processingTimer = Timer.periodic(_processingInterval, (_) {
      if (!_isProcessing) {
        _processQueue();
      }
    });
  }

  void stop() {
    _processingTimer?.cancel();
    _processingTimer = null;
  }

  void enqueue(NotificationItem notification) {
    _queue.add(notification);
    print('노티피케이션 큐에 추가: \${notification.title}');
  }

  void enqueuePriority(NotificationItem notification) {
    _priorityQueue.add(notification);
    print('우선순위 큐에 추가: \${notification.title}');
  }

  Future<void> processPendingNotifications() async {
    if (_isProcessing) return;
    
    await _processQueue();
  }

  Future<void> _processQueue() async {
    if (_isProcessing) return;
    
    _isProcessing = true;
    
    try {
      while (_priorityQueue.isNotEmpty) {
        final notification = _priorityQueue.removeFirst();
        await _processNotification(notification);
        
        await Future.delayed(const Duration(milliseconds: 500));
      }
      
      while (_queue.isNotEmpty) {
        final notification = _queue.removeFirst();
        await _processNotification(notification);
        
        await Future.delayed(const Duration(milliseconds: 500));
      }
    } finally {
      _isProcessing = false;
    }
  }

  Future<void> _processNotification(NotificationItem notification) async {
    try {
      final appLifecycle = AppLifecycleService();
      
      if (appLifecycle.isInForeground) {
        await _showInAppNotification(notification);
      } else {
        await _showSystemNotification(notification);
      }
      
      print('노티피케이션 처리 완료: \${notification.title}');
      
    } catch (e) {
      print('노티피케이션 처리 오류: $e');
    }
  }

  Future<void> _showInAppNotification(NotificationItem notification) async {
    print('인앱 노티피케이션 표시: \${notification.title}');
  }

  Future<void> _showSystemNotification(NotificationItem notification) async {
    print('시스템 노티피케이션 표시: \${notification.title}');
  }

  Map<String, int> getQueueStatus() {
    return {
      'normal': _queue.length,
      'priority': _priorityQueue.length,
      'total': _queue.length + _priorityQueue.length,
    };
  }

  void clearQueue() {
    _queue.clear();
    _priorityQueue.clear();
  }
}

class NotificationSettings {
  final bool globalEnabled;
  final Map<NotificationType, bool> typeSettings;
  final TimeOfDay? quietTimeStart;
  final TimeOfDay? quietTimeEnd;
  final bool vibrationEnabled;
  final bool soundEnabled;
  final String? customSoundPath;
  final bool showPreview;
  final int maxDailyNotifications;

  const NotificationSettings({
    this.globalEnabled = true,
    this.typeSettings = const {},
    this.quietTimeStart,
    this.quietTimeEnd,
    this.vibrationEnabled = true,
    this.soundEnabled = true,
    this.customSoundPath,
    this.showPreview = true,
    this.maxDailyNotifications = 50,
  });

  NotificationSettings copyWith({
    bool? globalEnabled,
    Map<NotificationType, bool>? typeSettings,
    TimeOfDay? quietTimeStart,
    TimeOfDay? quietTimeEnd,
    bool? vibrationEnabled,
    bool? soundEnabled,
    String? customSoundPath,
    bool? showPreview,
    int? maxDailyNotifications,
  }) {
    return NotificationSettings(
      globalEnabled: globalEnabled ?? this.globalEnabled,
      typeSettings: typeSettings ?? this.typeSettings,
      quietTimeStart: quietTimeStart ?? this.quietTimeStart,
      quietTimeEnd: quietTimeEnd ?? this.quietTimeEnd,
      vibrationEnabled: vibrationEnabled ?? this.vibrationEnabled,
      soundEnabled: soundEnabled ?? this.soundEnabled,
      customSoundPath: customSoundPath ?? this.customSoundPath,
      showPreview: showPreview ?? this.showPreview,
      maxDailyNotifications: maxDailyNotifications ?? this.maxDailyNotifications,
    );
  }

  bool isTypeEnabled(NotificationType type) {
    if (!globalEnabled) return false;
    return typeSettings[type] ?? true;
  }

  bool isQuietTime() {
    if (quietTimeStart == null || quietTimeEnd == null) return false;
    
    final now = TimeOfDay.now();
    return _isTimeBetween(now, quietTimeStart!, quietTimeEnd!);
  }

  bool _isTimeBetween(TimeOfDay time, TimeOfDay start, TimeOfDay end) {
    final timeMinutes = time.hour * 60 + time.minute;
    final startMinutes = start.hour * 60 + start.minute;
    final endMinutes = end.hour * 60 + end.minute;
    
    if (startMinutes <= endMinutes) {
      return timeMinutes >= startMinutes && timeMinutes <= endMinutes;
    } else {
      return timeMinutes >= startMinutes || timeMinutes <= endMinutes;
    }
  }

  Map<String, dynamic> toMap() {
    return {
      'globalEnabled': globalEnabled,
      'typeSettings': typeSettings.map((k, v) => MapEntry(k.name, v)),
      'quietTimeStart': quietTimeStart != null 
          ? '\${quietTimeStart!.hour}:\${quietTimeStart!.minute}'
          : null,
      'quietTimeEnd': quietTimeEnd != null 
          ? '\${quietTimeEnd!.hour}:\${quietTimeEnd!.minute}'
          : null,
      'vibrationEnabled': vibrationEnabled,
      'soundEnabled': soundEnabled,
      'customSoundPath': customSoundPath,
      'showPreview': showPreview,
      'maxDailyNotifications': maxDailyNotifications,
    };
  }

  factory NotificationSettings.fromMap(Map<String, dynamic> map) {
    return NotificationSettings(
      globalEnabled: map['globalEnabled'] ?? true,
      typeSettings: Map<NotificationType, bool>.fromEntries(
        (map['typeSettings'] as Map<String, dynamic>? ?? {}).entries.map(
          (e) => MapEntry(NotificationType.fromString(e.key), e.value),
        ),
      ),
      quietTimeStart: map['quietTimeStart'] != null
          ? _parseTimeOfDay(map['quietTimeStart'])
          : null,
      quietTimeEnd: map['quietTimeEnd'] != null
          ? _parseTimeOfDay(map['quietTimeEnd'])
          : null,
      vibrationEnabled: map['vibrationEnabled'] ?? true,
      soundEnabled: map['soundEnabled'] ?? true,
      customSoundPath: map['customSoundPath'],
      showPreview: map['showPreview'] ?? true,
      maxDailyNotifications: map['maxDailyNotifications'] ?? 50,
    );
  }

  static TimeOfDay _parseTimeOfDay(String timeString) {
    final parts = timeString.split(':');
    return TimeOfDay(hour: int.parse(parts[0]), minute: int.parse(parts[1]));
  }
}

class NotificationListScreen extends ConsumerWidget {
  const NotificationListScreen({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final notificationState = ref.watch(notificationStateProvider);
    final notificationNotifier = ref.read(notificationStateProvider.notifier);

    return Scaffold(
      appBar: AppBar(
        title: const Text('알림'),
        actions: [
          if (notificationState.unreadCount > 0)
            TextButton(
              onPressed: () => notificationNotifier.markAllAsRead(),
              child: const Text('모두 읽음'),
            ),
        ],
      ),
      body: notificationState.isLoading
          ? const Center(child: CircularProgressIndicator())
          : notificationState.notifications.isEmpty
              ? const Center(
                  child: Column(
                    mainAxisAlignment: MainAxisAlignment.center,
                    children: [
                      Icon(Icons.notifications_off, size: 64, color: Colors.grey),
                      SizedBox(height: 16),
                      Text('받은 알림이 없습니다', style: TextStyle(color: Colors.grey)),
                    ],
                  ),
                )
              : ListView.builder(
                  itemCount: notificationState.notifications.length,
                  itemBuilder: (context, index) {
                    final notification = notificationState.notifications[index];
                    return NotificationListItem(
                      notification: notification,
                      onTap: () => _handleNotificationTap(context, ref, notification),
                      onDismiss: () => notificationNotifier.deleteNotification(notification.id),
                    );
                  },
                ),
    );
  }

  void _handleNotificationTap(
    BuildContext context,
    WidgetRef ref,
    NotificationItem notification,
  ) {
    if (!notification.isRead) {
      ref.read(notificationStateProvider.notifier).markAsRead(notification.id);
    }

    NotificationRoutingService().handleNotificationRoute(notification.data);
  }
}

class NotificationListItem extends StatelessWidget {
  final NotificationItem notification;
  final VoidCallback onTap;
  final VoidCallback onDismiss;

  const NotificationListItem({
    required this.notification,
    required this.onTap,
    required this.onDismiss,
    super.key,
  });

  @override
  Widget build(BuildContext context) {
    return Dismissible(
      key: Key(notification.id),
      direction: DismissDirection.endToStart,
      onDismissed: (_) => onDismiss(),
      background: Container(
        color: Colors.red,
        alignment: Alignment.centerRight,
        padding: const EdgeInsets.only(right: 16),
        child: const Icon(Icons.delete, color: Colors.white),
      ),
      child: ListTile(
        leading: _buildLeadingIcon(),
        title: Text(
          notification.title,
          style: TextStyle(
            fontWeight: notification.isRead ? FontWeight.normal : FontWeight.bold,
          ),
        ),
        subtitle: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(notification.body),
            const SizedBox(height: 4),
            Text(
              _formatTime(notification.receivedAt),
              style: Theme.of(context).textTheme.bodySmall,
            ),
          ],
        ),
        trailing: notification.isRead
            ? null
            : Container(
                width: 8,
                height: 8,
                decoration: const BoxDecoration(
                  color: Colors.blue,
                  shape: BoxShape.circle,
                ),
              ),
        onTap: onTap,
      ),
    );
  }

  Widget _buildLeadingIcon() {
    switch (notification.type) {
      case NotificationType.chat:
        return const CircleAvatar(
          backgroundColor: Colors.green,
          child: Icon(Icons.chat, color: Colors.white),
        );
      case NotificationType.post:
        return const CircleAvatar(
          backgroundColor: Colors.blue,
          child: Icon(Icons.article, color: Colors.white),
        );
      default:
        return const CircleAvatar(
          backgroundColor: Colors.grey,
          child: Icon(Icons.notifications, color: Colors.white),
        );
    }
  }

  String _formatTime(DateTime dateTime) {
    final now = DateTime.now();
    final difference = now.difference(dateTime);

    if (difference.inDays > 0) {
      return '\${difference.inDays}일 전';
    } else if (difference.inHours > 0) {
      return '\${difference.inHours}시간 전';
    } else if (difference.inMinutes > 0) {
      return '\${difference.inMinutes}분 전';
    } else {
      return '방금 전';
    }
  }
}

class EnhancedNotificationService extends NotificationService {
  final AppLifecycleService _lifecycleService = AppLifecycleService();
  final NotificationQueueService _queueService = NotificationQueueService();
  
  @override
  Future<void> initialize({GoRouter? router}) async {
    await super.initialize(router: router);
    
    _lifecycleService.initialize();
    _lifecycleService.addListener(_onLifecycleChanged);
    
    _queueService.start();
    
    await _processPendingOnStartup();
  }

  void _onLifecycleChanged(AppLifecycleState state) {
    switch (state) {
      case AppLifecycleState.resumed:
        _onAppResumed();
        break;
      case AppLifecycleState.paused:
        _onAppPaused();
        break;
      default:
        break;
    }
  }

  void _onAppResumed() {
    _queueService.processPendingNotifications();
    _updateBadgeCount();
  }

  void _onAppPaused() {
    NotificationStorage().cleanupOldNotifications();
  }

  @override
  void _handleForegroundMessage(RemoteMessage message) {
    print('포그라운드 메시지 수신: \${message.messageId}');
    
    final notificationItem = _createNotificationItem(message);
    
    if (_shouldShowNotification(notificationItem)) {
      if (_lifecycleService.isInForeground) {
        _queueService.enqueue(notificationItem);
      } else {
        _showLocalNotification(message);
      }
    }
  }

  @override
  void _handleBackgroundMessage(RemoteMessage message) {
    print('백그라운드 메시지 처리: \${message.messageId}');
    
    final notificationItem = _createNotificationItem(message);
    
    NotificationStorage().saveNotification(notificationItem);
    
    _routingService.handleNotificationRoute(message.data);
  }

  NotificationItem _createNotificationItem(RemoteMessage message) {
    return NotificationItem(
      id: message.messageId ?? DateTime.now().millisecondsSinceEpoch.toString(),
      title: message.notification?.title ?? '알림',
      body: message.notification?.body ?? '',
      type: NotificationType.fromString(message.data['type'] ?? 'general'),
      data: message.data,
      receivedAt: DateTime.now(),
      imageUrl: message.notification?.android?.imageUrl ?? 
                message.notification?.apple?.imageUrl,
    );
  }

  bool _shouldShowNotification(NotificationItem notification) {
    return true;
  }

  Future<void> _processPendingOnStartup() async {
    final notifications = await NotificationStorage().getNotifications();
    final unprocessedNotifications = notifications.where((n) => !n.isRead).toList();
    
    for (final notification in unprocessedNotifications) {
      _queueService.enqueue(notification);
    }
  }

  void _updateBadgeCount() {
    // 실제 구현에서는 flutter_app_badger 패키지 사용
  }

  @override
  void dispose() {
    _lifecycleService.removeListener(_onLifecycleChanged);
    _lifecycleService.dispose();
    _queueService.stop();
    super.dispose();
  }
}

class NotificationPerformanceMonitor {
  static final NotificationPerformanceMonitor _instance = 
      NotificationPerformanceMonitor._internal();
  factory NotificationPerformanceMonitor() => _instance;
  NotificationPerformanceMonitor._internal();

  final Map<String, DateTime> _startTimes = {};
  final List<PerformanceMetric> _metrics = [];
  
  void startMeasure(String operationId) {
    _startTimes[operationId] = DateTime.now();
  }

  void endMeasure(String operationId, {Map<String, dynamic>? metadata}) {
    final startTime = _startTimes.remove(operationId);
    if (startTime == null) return;

    final duration = DateTime.now().difference(startTime);
    final metric = PerformanceMetric(
      operationId: operationId,
      duration: duration,
      timestamp: DateTime.now(),
      metadata: metadata,
    );

    _metrics.add(metric);
    _logMetric(metric);

    if (_metrics.length > 1000) {
      _metrics.removeRange(0, 100);
    }
  }

  void _logMetric(PerformanceMetric metric) {
    print('Performance: \${metric.operationId} took \${metric.duration.inMilliseconds}ms');
    
    if (metric.duration.inMilliseconds > 1000) {
      print('WARNING: Slow operation detected: \${metric.operationId}');
    }
  }

  Map<String, dynamic> getPerformanceStats() {
    if (_metrics.isEmpty) return {};

    final durations = _metrics.map((m) => m.duration.inMilliseconds).toList();
    durations.sort();

    return {
      'totalOperations': _metrics.length,
      'averageMs': durations.reduce((a, b) => a + b) / durations.length,
      'medianMs': durations[durations.length ~/ 2],
      'p95Ms': durations[(durations.length * 0.95).floor()],
      'maxMs': durations.last,
      'minMs': durations.first,
    };
  }

  void clearMetrics() {
    _metrics.clear();
    _startTimes.clear();
  }
}

class PerformanceMetric {
  final String operationId;
  final Duration duration;
  final DateTime timestamp;
  final Map<String, dynamic>? metadata;

  const PerformanceMetric({
    required this.operationId,
    required this.duration,
    required this.timestamp,
    this.metadata,
  });
}