FCM (Firebase Cloud Messaging)

npm install firebase-admin
# 또는
yarn add firebase-admin

import * as admin from "firebase-admin";

// Firebase가 이미 초기화되었는지 확인
export function getFirebaseApp() {
  try {
    return admin.app(); // 이미 존재하는 앱 반환
  } catch (error) {
    // 앱이 존재하지 않는 경우 초기화
    const serviceAccount = require("../../your-service-account-key.json");
    return admin.initializeApp({
      credential: admin.credential.cert(serviceAccount as admin.ServiceAccount),
    });
  }
}

// 앱과 서비스 내보내기
export const firebaseApp = getFirebaseApp();

export const messaging = admin.messaging();

// ... (Firebase Admin SDK 초기화 코드 이후)

/**
 * 특정 FCM 토큰으로 메시지를 보냅니다.
 * @param {string} fcmToken - 메시지를 받을 클라이언트의 FCM 토큰
 * @param {string} title - 알림 제목
 * @param {string} body - 알림 본문
 * @param {object} data - 알림과 함께 전송할 추가 데이터 (선택 사항)
 */
async function sendMessageToToken(fcmToken, title, body, data = {}) {
  const message = {
    notification: {
      title: title,
      body: body,
    },
    token: fcmToken, // 특정 디바이스 토큰
    data: data,      // 선택적 데이터 페이로드
    android: { // Android 특정 옵션
      priority: 'high',
      notification: {
        sound: 'default',
        channel_id: 'channel_id' // Flutter에서 설정한 채널 ID와 일치
      }
    },
    apns: { // iOS 특정 옵션
      payload: {
        aps: {
          sound: 'default',
          badge: 1, // 앱 아이콘 배지 숫자
        }
      }
    }
  };

  try {
    const response = await admin.messaging().send(message);
    console.log('Successfully sent message:', response);
    return { success: true, messageId: response };
  } catch (error) {
    console.error('Error sending message:', error);
    return { success: false, error: error.message };
  }
}

// 예시: Express.js를 사용한 API 엔드포인트
// app.post('/send-notification', async (req, res) => {
//   const { token, title, body, data } = req.body;
//
//   if (!token || !title || !body) {
//     return res.status(400).send({ error: 'Missing required fields: token, title, body' });
//   }
//
//   const result = await sendMessageToToken(token, title, body, data);
//   if (result.success) {
//     res.status(200).send({ message: 'Notification sent successfully', messageId: result.messageId });
//   } else {
//     res.status(500).send({ error: 'Failed to send notification', details: result.error });
//   }
// });

// // 서버 시작
// const PORT = process.env.PORT || 3000;
// app.listen(PORT, () => {
//   console.log(`Server is running on port ${PORT}`);
// });

dependencies:
  flutter:
    sdk: flutter
  firebase_core: ^2.27.2 # 최신 버전 확인
  firebase_messaging: ^14.8.0 # 최신 버전 확인
  flutter_local_notifications: ^17.0.0 # 최신 버전 확인
  flutter_dotenv: ^5.1.0 # .env 파일 사용 시
  http: ^1.2.1 # 서버로 토큰 전송 시

// lib/main.dart
import 'package:flutter/material.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart'; // .env 사용 시
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'services/fcm_service.dart'; // FCM 서비스 클래스
// ... 기타 import

// 백그라운드/종료 상태에서 FCM 메시지 수신 시 호출될 핸들러
// 이 핸들러는 애플리케이션 컨텍스트 외부에 있어야 합니다 (최상위 레벨 또는 static 함수).
@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  // 백그라운드에서 Firebase가 여러 번 초기화되는 것을 방지
  if (Firebase.apps.isEmpty) {
    await Firebase.initializeApp(
      // options: FirebaseOptions(...) // main에서 사용하는 옵션과 동일하게 설정 가능
      // 또는 DefaultFirebaseOptions.currentPlatform 사용 (flutterfire configure로 생성된 경우)
    );
  }
  print("백그라운드 메시지 처리: ${message.messageId}");
  // 여기서 로컬 알림을 직접 표시하거나, 메시지 데이터를 기반으로 다른 백그라운드 작업을 수행할 수 있습니다.
  // 예: FCMService().showLocalNotification(...) - 단, FCMService 인스턴스 생성 방식에 주의
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await dotenv.load(fileName: ".env"); // .env 사용 시

  // Firebase 초기화
  // flutterfire configure를 통해 생성된 firebase_options.dart 사용 권장
  // await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
  // 또는 수동 설정
  if (Firebase.apps.isEmpty) {
    await Firebase.initializeApp(
      options: FirebaseOptions(
        apiKey: dotenv.env['FIREBASE_API_KEY'] ?? '',
        appId: dotenv.env['FIREBASE_APP_ID'] ?? '',
        messagingSenderId: dotenv.env['FIREBASE_MESSAGING_SENDER_ID'] ?? '',
        projectId: dotenv.env['FIREBASE_PROJECT_ID'] ?? '',
      ),
    );
  }


  // 백그라운드 메시지 핸들러 등록
  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);

  // FCM 서비스 초기화 (포그라운드 메시지 처리 및 로컬 알림 설정 포함)
  await FCMService().init();

  runApp(const ProviderScope(child: MyApp())); // Riverpod 사용 시
  // runApp(const MyApp()); // 일반적인 경우
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      // ... 앱 설정
      home: SplashScreen(), // 예시 시작 화면
    );
  }
}

<manifest xmlns:android="<http://schemas.android.com/apk/res/android>"
    package="com.example.your_app">
    <uses-permission android:name="android.permission.INTERNET"/>
    <!-- Android 12 (API 31) 이상에서 정확한 알람 권한 (필요한 경우) -->
    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
    <!-- Android 13 (API 33) 이상에서 알림 권한 -->
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
   <application
        android:label="your_app_name"
        android:name="${applicationName}"
        android:icon="@mipmap/ic_launcher">
        <activity
            // ...
            >
            <!-- FCM 클릭 시 열릴 액티비티 설정 -->
            <intent-filter>
                <action android:name="FLUTTER_NOTIFICATION_CLICK" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>
        <!-- ... -->
        <!-- FCM 메시지 수신을 위한 서비스 (firebase-messaging 플러그인이 자동으로 추가할 수 있음) -->
        <!-- <service
            android:name=".MyFirebaseMessagingService"
            android:exported="false">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT" />
            </intent-filter>
        </service> -->
        <meta-data
            android:name="com.google.firebase.messaging.default_notification_channel_id"
            android:value="00000_channel_id" /> <!-- 서버에서 보낼 때 channel_id와 일치시키거나, 여기서 기본 채널을 지정합니다. -->
    </application>
</manifest>

// lib/services/fcm_service.dart
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart'; // .env 사용 시
import 'package:http/http.dart' as http; // 서버로 토큰 전송 시
import 'dart:convert'; // 서버로 토큰 전송 시

class FCMService {
  final FirebaseMessaging _messaging = FirebaseMessaging.instance;
  final FlutterLocalNotificationsPlugin _flutterLocalNotifications =
      FlutterLocalNotificationsPlugin();
  static final FCMService _instance = FCMService._internal();
  bool _isInitialized = false;

  factory FCMService() {
    return _instance;
  }

  FCMService._internal();

  Future<void> init() async {
    if (_isInitialized) return;

    // 1. 로컬 알림 플러그인 초기화
    // Android 설정
    const AndroidInitializationSettings initializationSettingsAndroid =
        AndroidInitializationSettings('@mipmap/ic_launcher'); // 앱 아이콘 사용

    // iOS 설정
    const DarwinInitializationSettings initializationSettingsIOS =
        DarwinInitializationSettings(
      requestAlertPermission: false, // 권한 요청은 별도로 처리
      requestBadgePermission: false,
      requestSoundPermission: false,
    );

    const InitializationSettings initializationSettings =
        InitializationSettings(
      android: initializationSettingsAndroid,
      iOS: initializationSettingsIOS,
    );

    await _flutterLocalNotifications.initialize(
      initializationSettings,
      onDidReceiveNotificationResponse: (NotificationResponse response) async {
        // 알림 클릭 시 로직 (예: 특정 화면으로 이동)
        print("로컬 알림 클릭됨. Payload: ${response.payload}");
        if (response.payload != null) {
          // final Map<String, dynamic> data = jsonDecode(response.payload!);
          // Navigator.of(GlobalContext.navigatorKey.currentContext!).pushNamed('/detail', arguments: data);
        }
      },
    );

    // 2. Android 알림 채널 생성 (로컬 알림용)
    await _createNotificationChannel();


    // 3. 포그라운드 메시지 리스너 설정
    FirebaseMessaging.onMessage.listen((RemoteMessage message) {
      print('포그라운드 메시지 수신: ${message.messageId}');
      RemoteNotification? notification = message.notification;
      AndroidNotification? android = message.notification?.android;
      AppleNotification? apple = message.notification?.apple;

      // notification 페이로드가 있고, Android의 경우 channelId가 설정되어 있으면 Firebase가 자동으로 알림을 표시할 수 있음
      // 하지만, 커스텀 로컬 알림을 사용하거나 iOS에서 포그라운드 알림을 항상 표시하려면 직접 처리
      if (notification != null) {
        // iOS의 경우 포그라운드에서 기본적으로 알림이 표시되지 않으므로 로컬 알림으로 표시
        // Android도 커스텀하게 처리하고 싶다면 여기서 로컬 알림 표시
        _showLocalNotification(
          title: notification.title ?? '알림',
          body: notification.body ?? '',
          payload: jsonEncode(message.data), // message.data를 payload로 전달
        );
      }
    });

    // 4. 앱이 종료된 상태에서 알림을 클릭하여 열렸을 때 메시지 가져오기
    FirebaseMessaging.instance.getInitialMessage().then((RemoteMessage? message) {
      if (message != null) {
        print('앱 종료 상태에서 알림 클릭으로 실행됨: ${message.messageId}');
        // 여기서도 message.data를 사용하여 특정 화면으로 네비게이션 등의 작업 수행
        // 예: Navigator.of(GlobalContext.navigatorKey.currentContext!).pushNamed('/detail', arguments: message.data);
      }
    });


    // 5. 앱이 백그라운드 상태에서 알림을 클릭하여 열렸을 때 메시지 처리 리스너
    FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
      print('백그라운드에서 알림 클릭으로 앱 열림: ${message.messageId}');
      // message.data를 사용하여 특정 화면으로 네비게이션 등의 작업 수행
      // 예: Navigator.of(GlobalContext.navigatorKey.currentContext!).pushNamed('/detail', arguments: message.data);
    });


    // 6. iOS 포그라운드 알림 표시 설정 (선택 사항, 기본적으로는 로컬 알림으로 처리)
    // 이 설정을 하면 iOS 포그라운드에서도 시스템 알림이 표시됨.
    // flutter_local_notifications로 직접 표시하는 경우 중복될 수 있으므로 주의.
    await _messaging.setForegroundNotificationPresentationOptions(
      alert: true, // Required to display a heads up notification
      badge: true,
      sound: true,
    );

    _isInitialized = true;
    print('FCMService initialized.');
  }

  // Android 알림 채널 생성
  Future<void> _createNotificationChannel() async {
    const AndroidNotificationChannel channel = AndroidNotificationChannel(
      '000000_channel_id', // ID (서버에서 보낼 때 이 ID를 사용하거나, 기본 채널로 지정)
      '000 알림', // Title
      description: '0000 중요 알림 채널입니다.', // Description
      importance: Importance.max, // 중요도
      playSound: true,
      sound: RawResourceAndroidNotificationSound('notification_sound'), // res/raw/notification_sound.mp3 (확장자 없이)
    );

    await _flutterLocalNotifications
        .resolvePlatformSpecificImplementation<
            AndroidFlutterLocalNotificationsPlugin>()
        ?.createNotificationChannel(channel);
    print('Android Notification Channel "0000_channel_id" created.');
  }


  /// 알림 권한 요청 (iOS & Android 13+)
  Future<bool> requestPermission() async {
    NotificationSettings settings = await _messaging.requestPermission(
      alert: true,
      announcement: false,
      badge: true,
      carPlay: false,
      criticalAlert: false,
      provisional: false, // provisional은 사용자가 명시적으로 허용하지 않아도 조용한 알림을 받을 수 있게 함
      sound: true,
    );

    if (settings.authorizationStatus == AuthorizationStatus.authorized) {
      print('알림 권한 허용됨');
      return true;
    } else if (settings.authorizationStatus == AuthorizationStatus.provisional) {
      print('임시 알림 권한 허용됨 (iOS)');
      return true;
    } else {
      print('알림 권한 거부됨');
      return false;
    }
  }

  /// FCM 토큰 가져오기
  Future<String?> getToken() async {
    try {
      String? token = await _messaging.getToken();
      print("FCM Token: $token");
      // APNs 토큰 (iOS 전용, 디버깅 용도)
      // if (defaultTargetPlatform == TargetPlatform.iOS) {
      //   String? apnsToken = await _messaging.getAPNSToken();
      //   print("APNS Token: $apnsToken");
      // }
      return token;
    } catch (e) {
      print("FCM 토큰 가져오기 실패: $e");
      return null;
    }
  }

  /// 서버에 토큰 등록 (예시)
  Future<bool> registerTokenOnServer(String token, String userId) async {
    // 실제 서버 URL로 교체해야 합니다.
    final String serverUrl = dotenv.env['TOKEN_SERVER_URL'] ?? '<http://your-server.com/register-token>';
    try {
      final response = await http.post(
        Uri.parse(serverUrl),
        headers: {"Content-Type": "application/json"},
        body: jsonEncode({"fcm_token": token, "user_id": userId}),
      ).timeout(const Duration(seconds: 10));

      if (response.statusCode == 200 || response.statusCode == 201) {
        print("FCM 토큰 서버에 등록 성공");
        return true;
      } else {
        print("FCM 토큰 서버 등록 실패: ${response.statusCode}, ${response.body}");
        return false;
      }
    } catch (e) {
      print("FCM 토큰 서버 등록 중 오류: $e");
      return false;
    }
  }

  /// 로컬 알림 표시
  Future<void> _showLocalNotification({
    required String title,
    required String body,
    String? payload, // JSON 문자열 형태의 데이터 전달
  }) async {
    // 고유한 알림 ID 생성 (매번 다른 알림으로 표시하기 위함)
    final int notificationId = DateTime.now().millisecondsSinceEpoch.remainder(100000);

    // Android 알림 상세 설정
    const AndroidNotificationDetails androidPlatformChannelSpecifics =
        AndroidNotificationDetails(
      '000_channel_id', // 채널 ID (위에서 생성한 채널과 일치)
      '00000 알림',    // 채널 이름
      channelDescription: '0000 등 중요 알림 채널입니다.',
      importance: Importance.max,
      priority: Priority.high,
      ticker: 'ticker', // 상태 표시줄에 잠시 표시되는 텍스트
      playSound: true,
      sound: RawResourceAndroidNotificationSound('notification_sound'), // res/raw/notification_sound.mp3 (확장자 없이)
      // icon: '@mipmap/ic_launcher', // 알림 아이콘 (설정하지 않으면 앱 아이콘 사용)
    );

    // iOS 알림 상세 설정
    const DarwinNotificationDetails iOSPlatformChannelSpecifics =
        DarwinNotificationDetails(
      presentAlert: true,
      presentBadge: true,
      presentSound: true,
      sound: 'notification_sound.aiff', // ios/Runner/Assets 폴더에 추가 (확장자 포함)
      // badgeNumber: 1, // 앱 아이콘 배지 숫자
    );

    const NotificationDetails platformChannelSpecifics = NotificationDetails(
      android: androidPlatformChannelSpecifics,
      iOS: iOSPlatformChannelSpecifics,
    );

    await _flutterLocalNotifications.show(
      notificationId,
      title,
      body,
      platformChannelSpecifics,
      payload: payload,
    );
    print('로컬 알림 표시됨: $title - $body');
  }

  // 외부에서 로컬 알림을 쉽게 호출할 수 있도록 public 메소드 제공 (선택 사항)
  Future<void> showCustomLocalNotification({
    required String title,
    required String body,
    String? payload,
  }) async {
    await _showLocalNotification(title: title, body: body, payload: payload);
  }


  // 주제 구독/구독 취소 (선택 사항)
  Future<void> subscribeToTopic(String topic) async {
    await _messaging.subscribeToTopic(topic);
    print('Subscribed to topic: $topic');
  }

  Future<void> unsubscribeFromTopic(String topic) async {
    await _messaging.unsubscribeFromTopic(topic);
    print('Unsubscribed from topic: $topic');
  }
}

// 알림 클릭 시 Context 접근을 위한 GlobalKey (신중하게 사용해야 함)
// class GlobalContext {
//   static final GlobalKey<NavigatorState> navigatorKey = GlobalKey<NavigatorState>();
// }

// lib/screens/login_screen.dart (일부)
// ...
Future<void> _login() async {
  if (_formKey.currentState!.validate()) {
    // ... 로그인 로직 ...
    if (loginSuccess) {
      final fcmToken = await FCMService().getToken();
      if (fcmToken != null && mounted) {
        // 실제 사용자 ID 또는 식별자 사용
        await FCMService().registerTokenOnServer(fcmToken, "user_id_from_login");
      }
      // 홈 화면으로 이동
      Navigator.pushReplacementNamed(context, '/home');
    }
    // ...
  }
}
// ...