Flutter × AppsFlyerでdeep linkを実装する

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
- <dict>
-	<key>com.apple.developer.associated-domains</key>
-	<array>
-		<string>applinks:$(deepLinkDomain)</string>
-	</array>
- </dict>
+	<dict>
+		<key>com.apple.developer.associated-domains</key>
+		<array>
+			<string>applinks:$(deepLinkDomain)</string>
+		</array>
+	</dict>
 </plist>

class AppsflyerDeepLinkRepository
    implements DeepLinkRepository {
  AppsflyerDeepLinkRepository({
    required this.appsflyerManager,
  });

  final AppsflyerManager appsflyerManager;

  @override
  Future<void> onListenDeepLink({
    required void Function(AppDeepLink) onOpenedLink,
    required void Function(AppDeepLink) onError,
  }) async {
    try {
      appsflyerManager.onDeepLinkLinking()((dp) {
        final appDeepLink = _convertToAppDeepLink(dp);
        switch (appDeepLink.status) {
          case AppDeepLinkStatus.found:
            onOpenedLink(appDeepLink);
          case AppDeepLinkStatus.notFound:
            onError(appDeepLink);
          case AppDeepLinkStatus.error:
            onError(appDeepLink);
          case AppDeepLinkStatus.listen:
          case null:
        }
      });
    } on Exception {
      rethrow;
    }
  }

  // DeepLinkResult（appsflyerのモデル）を、アプリ用のmodelに変換しとく。
  // queryパラメータとかアプリで使いやすいようにmodelに持たせたいよね
  AppDeepLink _convertToAppDeepLink(DeepLinkResult dp) {
    switch (dp.status) {
      case Status.FOUND:
        return AppDeepLink(
          deepLinkValue: dp.deepLink?.deepLinkValue ?? '',
          status: AppDeepLinkStatus.found,
        );
      case Status.NOT_FOUND:
        return AppDeepLink(
          deepLinkValue: dp.deepLink?.deepLinkValue ?? '',
          status: AppDeepLinkStatus.notFound,
        );
      case Status.ERROR:
      case Status.PARSE_ERROR:
        return AppDeepLink(
          errorMessage: dp.error?.name ?? '',
          status: AppDeepLinkStatus.error,
        );
    }
  }
}

@riverpod
DeepLinkRepository deepLinkRepository(DeepLinkRepositoryRef ref) {
  final appsflyerManager = ref.read(appsflyerManagerProvider);
  return AppsflyerDeepLinkRepository(
    appsflyerManager: appsflyerManager,
  );
}

class DeepLinkService {
  DeepLinkService(this._deepLinkRepository);

  final DeepLinkRepository _deepLinkRepository;
  final deepLinkStream = StreamController<AppDeepLink>.broadcast();

  void Function(AppDeepLink) get _deepLinkDispatch => deepLinkStream.add;
  Stream<AppDeepLink> get deepLinkSubscribe => deepLinkStream.stream;

  Future<void> onInitListenDeepLink() async {
    try {
      await _deepLinkRepository.onListenDeepLink(
        onOpenedLink: (appDeepLink) {
          _deepLinkDispatch(appDeepLink);
          // リンクを開いて成功したら、イベントを受け取ってaddする。
          // 中身はリンクに含まれる情報とかをmodelにしたもの。
        },
        onError: deepLinkStream.addError,
      );
    } on Exception {
      rethrow;
    }
  }

  void dispose() {
    deepLinkStream.close();
  }
}

@riverpod
DeepLinkService deepLinkService(
  DeepLinkServiceRef ref,
) {
  final deepLinkRepository = ref.read(deepLinkRepositoryProvider);
  return DeepLinkService(deepLinkRepository);
}

// こいつをviewでlistenして、イベントをサブスクする
@riverpod
Stream<AppDeepLink> appDeepLinkServiceListen(
  AppDeepLinkServiceListenRef ref,
) async* {
  final service = ref.read(deepLinkServiceProvider);
  ref.onDispose(() {
    ref.invalidateSelf();
    service.dispose();
  });
  yield* service.deepLinkSubscribe;
}

class DeepLinkNavigationWidget extends ConsumerWidget {
  const DeepLinkNavigationWidget({
    super.key,
    required this.child,
  });

  final Widget child;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    ref.listen(appDeepLinkServiceListenProvider, (previous, next) async {
      if (next.hasValue && next.value is AppDeepLink) {
        final appDeepLink = next.value!;
        final linkType =
            AppDeepLinkPath.fromDeepLinkValue(appDeepLink.deepLinkValue);

        // widgetのcontextではなく、go_routerのnavigatorKey.currentContextを使う
        final bc =
            ref.watch(routerProvider).configuration.navigatorKey.currentContext;

        if (bc is BuildContext) {
          switch (linkType) {
            case AppDeepLinkPath.start:
              const HomePageRoute().go(bc);
            case AppDeepLinkPath.app:
            case null:
            // 指定がなければアプリを立ち上げるだけ
          }
        }
      }
    });

    // 上位でwrapする（routerの初期化よりは後ろの方で）
    return child;
  }
}

    testWidgets('match home route', (WidgetTester tester) async {
      final List<GoRoute> routes = <GoRoute>[
        GoRoute(
            path: '/',
            builder: (BuildContext context, GoRouterState state) =>
                const HomeScreen()),
      ];

      final GoRouter router = await createRouter(routes, tester);
      final RouteMatchList matches = router.routerDelegate.currentConfiguration;
      expect(matches.matches, hasLength(1));
      expect(matches.uri.toString(), '/');
      expect(find.byType(HomeScreen), findsOneWidget);
    });

Future<GoRouter> createRouter(
  List<RouteBase> routes,
  WidgetTester tester, {
  GoRouterRedirect? redirect,
  String initialLocation = '/',
  Object? initialExtra,
  int redirectLimit = 5,
  GlobalKey<NavigatorState>? navigatorKey,
  GoRouterWidgetBuilder? errorBuilder,
  String? restorationScopeId,
  Codec<Object?, Object?>? extraCodec,
  GoExceptionHandler? onException,
  bool requestFocus = true,
  bool overridePlatformDefaultLocation = false,
}) async {
  final GoRouter goRouter = GoRouter(
    routes: routes,
    redirect: redirect,
    extraCodec: extraCodec,
    initialLocation: initialLocation,
    onException: onException,
    initialExtra: initialExtra,
    redirectLimit: redirectLimit,
    errorBuilder: errorBuilder,
    navigatorKey: navigatorKey,
    restorationScopeId: restorationScopeId,
    requestFocus: requestFocus,
    overridePlatformDefaultLocation: overridePlatformDefaultLocation,
  );
  await tester.pumpWidget(
    MaterialApp.router(
      restorationScopeId:
          restorationScopeId != null ? '$restorationScopeId-root' : null,
      routerConfig: goRouter,
    ),
  );
  return goRouter;
}

Future<GoRouter> createRouter(
  List<RouteBase> routes,
  WidgetTester tester, {
  GoRouterRedirect? redirect,
  String initialLocation = '/',
  Object? initialExtra,
  int redirectLimit = 5,
  GlobalKey<NavigatorState>? navigatorKey,
  GoRouterWidgetBuilder? errorBuilder,
  String? restorationScopeId,
  Codec<Object?, Object?>? extraCodec,
  GoExceptionHandler? onException,
  bool requestFocus = true,
  bool overridePlatformDefaultLocation = false,
  bool isLoggedIn = true,
}) async {
  final goRouter = GoRouter(
    observers: [],
    routes: routes,
    redirect: (context, state) {
      final loggedIn = isLoggedIn;
      final isPublicRoute = publicRoutes.contains(state.matchedLocation);
      final goingToLogin =
          state.matchedLocation == const SignUpLoginPageRoute().location;

      if (!loggedIn && !isPublicRoute) {
        if (!goingToLogin) {
          return const SignUpLoginPageRoute().location;
        }
      }

      if (loggedIn && goingToLogin) {
        return const HomePageRoute().location;
      }

      return null;
    },
    extraCodec: extraCodec,
    initialLocation: initialLocation,
    onException: onException,
    initialExtra: initialExtra,
    redirectLimit: redirectLimit,
    errorBuilder: errorBuilder,
    navigatorKey: navigatorKey,
    restorationScopeId: restorationScopeId,
    requestFocus: requestFocus,
    overridePlatformDefaultLocation: overridePlatformDefaultLocation,
  );
  await tester.pumpWidget(
    MaterialApp.router(
      restorationScopeId:
          restorationScopeId != null ? '$restorationScopeId-root' : null,
      routerConfig: goRouter,
    ),
  );
  return goRouter;
}

// ページのmock
final homePageRoute = GoRoute(
  path: RouterPath.home,
  pageBuilder: (context, state) => const MaterialPage(
    child: SizedBox(
      child: Text('HOME'),
    ),
  ),
);

final signUpLoginPageRoute = GoRoute(
  path: RouterPath.signUpLogin,
  pageBuilder: (context, state) => const MaterialPage(
    child: SizedBox(
      child: Text('LOGIN'),
    ),
  ),
);

class _TestWidget extends StatelessWidget {
  const _TestWidget({
    required this.container,
    required this.testDeepLink,
    required this.goRouter,
  });

  final ProviderContainer container;
  final Stream<AppDeepLink> testDeepLink;
  final GoRouter goRouter;

  @override
  Widget build(BuildContext context) {
    return UncontrolledProviderScope(
      container: container,
      child: MaterialApp.router(
        routerConfig: goRouter,
        builder: (context, child) => DeepLinkNavigationWidget(
          child: child!,
        ),
      ),
    );
  }
}

void main() {
  late Stream<AppDeepLink> testDeepLink;

  group('DeepLinkNavigationWidget /start', () {
    setUp(() {
      testDeepLink = Stream.value(
        AppDeepLink(
          deepLinkValue: AppDeepLinkPath.start.deepLinkValue,
          status: AppDeepLinkStatus.found,
        ),
      );
    });

    testWidgets('ログイン中の場合HomePageRouteにナビゲートする', (
      WidgetTester tester,
    ) async {
      // ルートの定義
      final routes = <RouteBase>[
        homePageRoute,
      ];

      // GoRouter の設定
      final goRouter = await createRouter(routes, tester);
      final container = ProviderContainer(
        overrides: [
          appDeepLinkServiceListenProvider.overrideWith(
            (_) => testDeepLink,
          ),
          routerProvider.overrideWithValue(goRouter),
        ],
      );

      await tester.pumpWidget(
        _TestWidget(
          container: container,
          testDeepLink: testDeepLink,
          goRouter: goRouter,
        ),
      );

      // ディープリンクイベントをシミュレート
      await tester.pumpAndSettle();
      expect(find.text('HOME'), findsOneWidget);
      container.dispose();
    });
  });
}