App Onboarding with Deferred Deep Linking: Complete User Journey

class OnboardingService {
  static final FlutterRedirectly _redirectly = FlutterRedirectly();
  static bool _hasProcessedInitialLink = false;
  
  static Future<void> initialize() async {
    await _redirectly.initialize(RedirectlyConfig(
      apiKey: 'YOUR_API_KEY',
      baseUrl: 'https://redirectly.app',
      enableDebugLogging: true,
    ));
    
    // Listen for app install events
    _redirectly.onAppInstalled.listen(_handleAppInstall);
    
    // Check for initial link on app start
    await _checkInitialLink();
  }
  
  static Future<void> _checkInitialLink() async {
    if (_hasProcessedInitialLink) return;
    
    final initialLink = await _redirectly.getInitialLink();
    if (initialLink != null) {
      await _processOnboardingLink(initialLink);
      _hasProcessedInitialLink = true;
    }
  }
  
  static void _handleAppInstall(AppInstallEvent event) {
    if (event.matched && event.link != null) {
      _processOnboardingLink(event.link!);
    }
  }
  
  static Future<void> _processOnboardingLink(LinkClickEvent event) async {
    if (event.error != null) {
      print('Onboarding link error: ${event.error}');
      return;
    }
    
    final uri = Uri.parse(event.originalUrl);
    final onboardingData = _extractOnboardingData(uri);
    
    if (onboardingData != null) {
      // Store onboarding context
      await _storeOnboardingContext(onboardingData);
      
      // Navigate to appropriate onboarding flow
      _navigateToOnboardingFlow(onboardingData);
    }
  }
  
  static Map<String, dynamic>? _extractOnboardingData(Uri uri) {
    // Extract onboarding parameters from the link
    final source = uri.queryParameters['source'];
    final campaign = uri.queryParameters['campaign'];
    final feature = uri.queryParameters['feature'];
    final referrer = uri.queryParameters['ref'];
    
    if (source != null) {
      return {
        'source': source,
        'campaign': campaign,
        'feature': feature,
        'referrer': referrer,
        'timestamp': DateTime.now().toIso8601String(),
      };
    }
    
    return null;
  }
  
  static Future<void> _storeOnboardingContext(Map<String, dynamic> data) async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setString('onboarding_context', jsonEncode(data));
  }
  
  static void _navigateToOnboardingFlow(Map<String, dynamic> data) {
    final source = data['source'] as String;
    
    switch (source) {
      case 'marketing':
        _navigateToMarketingOnboarding(data);
        break;
      case 'referral':
        _navigateToReferralOnboarding(data);
        break;
      case 'feature':
        _navigateToFeatureOnboarding(data);
        break;
      default:
        _navigateToDefaultOnboarding();
    }
  }
  
  static void _navigateToMarketingOnboarding(Map<String, dynamic> data) {
    Get.offAllNamed('/onboarding/marketing', arguments: {
      'campaign': data['campaign'],
      'source': data['source'],
    });
  }
  
  static void _navigateToReferralOnboarding(Map<String, dynamic> data) {
    Get.offAllNamed('/onboarding/referral', arguments: {
      'referrer': data['referrer'],
      'source': data['source'],
    });
  }
  
  static void _navigateToFeatureOnboarding(Map<String, dynamic> data) {
    Get.offAllNamed('/onboarding/feature', arguments: {
      'feature': data['feature'],
      'source': data['source'],
    });
  }
  
  static void _navigateToDefaultOnboarding() {
    Get.offAllNamed('/onboarding/default');
  }
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // Initialize onboarding service
  await OnboardingService.initialize();
  
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return GetMaterialApp(
      title: 'My App',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: AuthService.isLoggedIn() 
        ? HomeScreen() 
        : OnboardingWrapper(),
      routes: {
        '/onboarding/default': (context) => DefaultOnboardingScreen(),
        '/onboarding/marketing': (context) => MarketingOnboardingScreen(),
        '/onboarding/referral': (context) => ReferralOnboardingScreen(),
        '/onboarding/feature': (context) => FeatureOnboardingScreen(),
        '/home': (context) => HomeScreen(),
      },
    );
  }
}

class OnboardingWrapper extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return FutureBuilder<Map<String, dynamic>?>(
      future: _getOnboardingContext(),
      builder: (context, snapshot) {
        if (snapshot.connectionState == ConnectionState.waiting) {
          return SplashScreen();
        }
        
        final context = snapshot.data;
        if (context != null) {
          // Navigate to appropriate onboarding based on context
          WidgetsBinding.instance.addPostFrameCallback((_) {
            OnboardingService._navigateToOnboardingFlow(context);
          });
        }
        
        return DefaultOnboardingScreen();
      },
    );
  }
  
  Future<Map<String, dynamic>?> _getOnboardingContext() async {
    final prefs = await SharedPreferences.getInstance();
    final contextString = prefs.getString('onboarding_context');
    
    if (contextString != null) {
      return jsonDecode(contextString) as Map<String, dynamic>;
    }
    
    return null;
  }
}