Flutter-Integration

flutter pub add firebase_core firebase_messaging http flutter_secure_storage uuid package_info_plus

import 'dart:convert';
import 'dart:io' show Platform;
import 'dart:ui' show PlatformDispatcher;

import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:http/http.dart' as http;
import 'package:package_info_plus/package_info_plus.dart';
import 'package:uuid/uuid.dart';

class NotiPilot {
  NotiPilot._();
  static final NotiPilot instance = NotiPilot._();

  static const _baseUrl = 'https://app.notipilot.com/api/v1';
  static const _appId = 'IHRE-EXPO-PROJEKT-ID'; // "Expo Project ID" aus dem Dashboard
  static const _uidKey = 'notipilot_device_uid';

  final _storage = const FlutterSecureStorage();
  final _messaging = FirebaseMessaging.instance;

  Future<String> deviceUid() async {
    var uid = await _storage.read(key: _uidKey);
    if (uid == null) {
      uid = const Uuid().v4();
      await _storage.write(key: _uidKey, value: uid);
    }
    return uid;
  }

  /// Beim App-Start aufrufen. Fragt die Berechtigung an, ruft den Token ab und registriert ihn bei NotiPilot.
  Future<Map<String, dynamic>?> registerDevice({Map<String, Object?> extraAttributes = const {}}) async {
    final settings = await _messaging.requestPermission(alert: true, badge: true, sound: true);
    if (settings.authorizationStatus == AuthorizationStatus.denied) return null;

    final uid = await deviceUid();
    final expoToken = await _getExpoPushToken(uid);
    if (expoToken == null) return null;

    final info = await PackageInfo.fromPlatform();
    final locale = PlatformDispatcher.instance.locale;

    return _post('/register-device', {
      'app_id': _appId,
      'device_uid': uid,
      'token': expoToken,
      'platform': Platform.isIOS ? 'ios' : 'android',
      'provider': 'expo',
      'attributes': {
        'locale': locale.languageCode,   // "tr"
        'country': locale.countryCode,   // "TR"
        'app_version': info.version,
        ...extraAttributes,              // z. B. {'city': 'Istanbul'}
      },
    });
  }

  /// Aufrufen, wenn sich der Nutzer anmeldet.
  Future<Map<String, dynamic>> identify(String externalId, {Map<String, Object?>? attributes}) async {
    return _post('/identify-device', {
      'app_id': _appId,
      'device_uid': await deviceUid(),
      'external_id': externalId,
      if (attributes != null) 'attributes': attributes,
    });
  }

  /// Hält NotiPilot bei Token-Erneuerung aktuell. Einmal beim App-Start aufrufen.
  void listenForTokenRefresh() {
    _messaging.onTokenRefresh.listen((_) => registerDevice());
  }

  Future<String?> _getExpoPushToken(String uid) async {
    final isIOS = Platform.isIOS;
    String? deviceToken;

    if (isIOS) {
      // Der APNs-Token steht kurz nach dem App-Start zur Verfügung
      for (var i = 0; i < 5 && deviceToken == null; i++) {
        deviceToken = await _messaging.getAPNSToken();
        if (deviceToken == null) await Future.delayed(const Duration(seconds: 1));
      }
    } else {
      deviceToken = await _messaging.getToken();
    }
    if (deviceToken == null) return null;

    final info = await PackageInfo.fromPlatform();
    final res = await http.post(
      Uri.parse('https://exp.host/--/api/v2/push/getExpoPushToken'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'type': isIOS ? 'apns' : 'fcm',
        'deviceId': uid.toLowerCase(),
        'development': isIOS && kDebugMode, // iOS-Debug-Builds nutzen die APNs-Sandbox
        'appId': info.packageName,          // Android package / iOS bundle id
        'deviceToken': deviceToken,
        'projectId': _appId,
      }),
    );
    if (res.statusCode != 200) {
      debugPrint('[NotiPilot] Expo token exchange failed: ${res.statusCode} ${res.body}');
      return null;
    }
    return (jsonDecode(res.body)['data'] as Map<String, dynamic>)['expoPushToken'] as String;
  }

  Future<Map<String, dynamic>> _post(String path, Map<String, Object?> body, [int attempt = 0]) async {
    final res = await http.post(
      Uri.parse('$_baseUrl$path'),
      headers: {'Content-Type': 'application/json', 'Accept': 'application/json'},
      body: jsonEncode(body),
    );
    final json = res.body.isEmpty ? <String, dynamic>{} : jsonDecode(res.body) as Map<String, dynamic>;

    if ((res.statusCode == 429 || res.statusCode >= 500) && attempt < 3) {
      final wait = (json['retry_after'] as num?)?.toInt() ?? (1 << attempt);
      await Future.delayed(Duration(seconds: wait));
      return _post(path, body, attempt + 1);
    }
    if (res.statusCode >= 400) {
      debugPrint('[NotiPilot] ${res.statusCode} ${json['error']} ${json['errors'] ?? json['message']}');
    }
    return json;
  }

  /// Gibt das vom Dashboard gesendete benutzerdefinierte Feld `data` zurück.
  static Map<String, dynamic> customData(RemoteMessage message) {
    final raw = message.data['body'];
    if (raw is String) {
      try {
        return jsonDecode(raw) as Map<String, dynamic>;
      } catch (_) {}
    }
    return Map<String, dynamic>.from(message.data);
  }
}

import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/material.dart';

import 'firebase_options.dart';
import 'notipilot.dart';

@pragma('vm:entry-point')
Future<void> _onBackgroundMessage(RemoteMessage message) async {
  await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
}

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
  FirebaseMessaging.onBackgroundMessage(_onBackgroundMessage);

  // iOS: Benachrichtigung auch anzeigen, wenn die App im Vordergrund ist
  await FirebaseMessaging.instance.setForegroundNotificationPresentationOptions(
    alert: true, badge: true, sound: true,
  );

  NotiPilot.instance.registerDevice(extraAttributes: {'city': 'Istanbul'});
  NotiPilot.instance.listenForTokenRefresh();

  // Beim Tippen auf die Benachrichtigung
  FirebaseMessaging.onMessageOpenedApp.listen((message) {
    final data = NotiPilot.customData(message);
    // z. B. data['screen'] == 'product' → mit dem Navigator weiterleiten
  });

  runApp(const MyApp());
}