Flutter 딥링킹 완벽 가이드 3편: 딥링크 처리 서비스 구현

// pubspec.yaml
dependencies:
  uni_links: ^0.5.1
  go_router: ^12.0.0

// services/deeplink_service.dart
import 'package:uni_links/uni_links.dart';
import 'dart:async';

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

  StreamSubscription? _linkSubscription;
  final _linkController = StreamController<String>.broadcast();
  
  Stream<String> get linkStream => _linkController.stream;

  Future<void> initialize() async {
    // 앱이 종료된 상태에서 딥링크로 시작된 경우
    try {
      final initialLink = await getInitialLink();
      if (initialLink != null) {
        _handleDeepLink(initialLink);
      }
    } catch (e) {
      print('초기 딥링크 처리 실패: $e');
    }

    // 앱이 실행 중일 때 딥링크를 받는 경우
    _linkSubscription = linkStream.listen(
      _handleDeepLink,
      onError: (err) => print('딥링크 수신 오류: $err'),
    );
  }

  void _handleDeepLink(String link) {
    print('딥링크 수신: $link');
    _linkController.add(link);
  }

  void dispose() {
    _linkSubscription?.cancel();
    _linkController.close();
  }
}

// models/deeplink_model.dart
class DeepLinkData {
  final Uri uri;
  final String scheme;
  final String? host;
  final String path;
  final Map<String, String> queryParams;
  final String? fragment;

  DeepLinkData({
    required this.uri,
    required this.scheme,
    this.host,
    required this.path,
    required this.queryParams,
    this.fragment,
  });

  factory DeepLinkData.fromUrl(String url) {
    final uri = Uri.parse(url);
    return DeepLinkData(
      uri: uri,
      scheme: uri.scheme,
      host: uri.host.isEmpty ? null : uri.host,
      path: uri.path,
      queryParams: uri.queryParameters,
      fragment: uri.fragment.isEmpty ? null : uri.fragment,
    );
  }
}

// services/deeplink_router.dart
class DeepLinkRouter {
  final GoRouter _goRouter;
  
  DeepLinkRouter(this._goRouter);

  void route(DeepLinkData data) {
    // 경로 기반 라우팅
    if (data.path.startsWith('/product/')) {
      final productId = data.path.split('/').last;
      _goRouter.go('/product/$productId');
    } 
    else if (data.path.startsWith('/user/')) {
      final userId = data.path.split('/').last;
      _goRouter.go('/user/$userId');
    }
    else if (data.path == '/home') {
      _goRouter.go('/');
    }
    else {
      // 알 수 없는 경로는 홈으로
      _goRouter.go('/');
    }
  }
}

// services/deeplink_validator.dart
class DeepLinkValidator {
  // 허용된 스킴
  static const allowedSchemes = ['https', 'myapp'];
  
  // 허용된 호스트 (유니버설 링크용)
  static const allowedHosts = [
    'myapp.com',
    'www.myapp.com',
    'link.myapp.com',
  ];
  
  // 허용된 경로 패턴
  static final allowedPaths = [
    RegExp(r'^/home$'),
    RegExp(r'^/product/[a-zA-Z0-9-]+$'),
    RegExp(r'^/user/[a-zA-Z0-9_]+$'),
    RegExp(r'^/invite/[A-Z0-9]{6,10}$'),
  ];

  static bool isValid(String url) {
    try {
      final uri = Uri.parse(url);
      
      // 1. 스킴 검증
      if (!allowedSchemes.contains(uri.scheme)) {
        print('허용되지 않은 스킴: ${uri.scheme}');
        return false;
      }
      
      // 2. 호스트 검증 (HTTPS인 경우)
      if (uri.scheme == 'https' && 
          !allowedHosts.contains(uri.host)) {
        print('허용되지 않은 호스트: ${uri.host}');
        return false;
      }
      
      // 3. 경로 패턴 검증
      final isValidPath = allowedPaths.any(
        (pattern) => pattern.hasMatch(uri.path)
      );
      
      if (!isValidPath) {
        print('허용되지 않은 경로: ${uri.path}');
        return false;
      }
      
      // 4. 파라미터 검증
      return _validateParameters(uri.queryParameters);
      
    } catch (e) {
      print('URL 파싱 오류: $e');
      return false;
    }
  }
  
  static bool _validateParameters(Map<String, String> params) {
    // 파라미터 값 길이 제한
    const maxValueLength = 200;
    
    for (final entry in params.entries) {
      if (entry.value.length > maxValueLength) {
        return false;
      }
      
      // SQL 인젝션 방지
      if (_containsSqlKeywords(entry.value)) {
        return false;
      }
      
      // XSS 방지
      if (_containsHtmlTags(entry.value)) {
        return false;
      }
    }
    
    return true;
  }
  
  static bool _containsSqlKeywords(String value) {
    final sql = value.toLowerCase();
    final keywords = [
      'select', 'insert', 'update', 'delete',
      'drop', 'union', 'exec', 'script'
    ];
    return keywords.any((k) => sql.contains(k));
  }
  
  static bool _containsHtmlTags(String value) {
    final htmlPattern = RegExp(r'<[^>]*>');
    return htmlPattern.hasMatch(value);
  }
}

// services/deeplink_error_handler.dart
enum DeepLinkError {
  invalidUrl,
  contentNotFound,
  unauthorized,
  networkError,
  versionMismatch,
  unknown,
}

class DeepLinkErrorHandler {
  final GoRouter router;
  
  DeepLinkErrorHandler(this.router);
  
  void handle(DeepLinkError error, {String? context}) {
    switch (error) {
      case DeepLinkError.invalidUrl:
        _showErrorAndRedirect(
          '잘못된 링크',
          '요청하신 링크가 올바르지 않습니다.',
          '/',
        );
        break;
        
      case DeepLinkError.contentNotFound:
        _showErrorAndRedirect(
          '콘텐츠를 찾을 수 없음',
          '요청하신 콘텐츠가 삭제되었거나 이동되었습니다.',
          '/search',
        );
        break;
        
      case DeepLinkError.unauthorized:
        // 로그인 페이지로 리다이렉트
        router.go('/login?redirect=$context');
        break;
        
      case DeepLinkError.networkError:
        _showRetryDialog(
          '네트워크 오류',
          '데이터를 불러올 수 없습니다.',
          context,
        );
        break;
        
      case DeepLinkError.versionMismatch:
        _showUpdateDialog();
        break;
        
      case DeepLinkError.unknown:
      default:
        _showErrorAndRedirect(
          '오류 발생',
          '요청을 처리할 수 없습니다.',
          '/',
        );
    }
  }
  
  void _showErrorAndRedirect(
    String title,
    String message,
    String fallbackRoute,
  ) {
    // 에러 메시지 표시 후 대체 경로로 이동
    // 실제 구현에서는 Dialog나 SnackBar 사용
    router.go(fallbackRoute);
  }
  
  void _showRetryDialog(
    String title,
    String message,
    String? retryContext,
  ) {
    // 재시도 옵션 제공
  }
  
  void _showUpdateDialog() {
    // 앱 업데이트 안내
  }
}