问无法使用flutter_localizations刷新子页中的文本，intl

EN

//sets_bloc.dart
      void subscribeLocale(AppLanguagesCubit cubit) {
        cubit.stream.listen((event) {
          add(const OnSetCardsDownloading()); // refresh page
        });
      }
// home_view.dart
 MultiBlocProvider(
        providers: [
          BlocProvider<SetsBloc>(
            create: (_) => SetsBloc()
              ..subscribeLocale(BlocProvider.of<AppLanguagesCubit>(context))

          ),
          //..//
        ],
        child: SetsView(),
// main.dart
 /** */

Future<void> main() async {
  /** */

  await SentryFlutter.init(
    (options) {
      options.dsn =
      /** */
    },
    appRunner: () => runApp(
      MyApp(),
    ),
  );
}

class MyApp extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
 /** */

  ExtendedSecureStorage get storage => DiManager.getIt<ExtendedSecureStorage>();

  @override
  void initState() {
 /** */
  }

  @override
  void dispose() {
 /** */
  }

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: () {
        final FocusScopeNode currentFocus = FocusScope.of(context);
        if (!currentFocus.hasPrimaryFocus &&
            currentFocus.focusedChild != null) {
          FocusManager.instance.primaryFocus?.unfocus();
        }
      },
      child: MultiBlocProvider(
        providers: [
        //** */
        ],
        child: BlocBuilder<AppLanguagesCubit, AppLanguagesState>(
            builder: (_, AppLanguagesState state) {
          return OverlaySupport(
            child: MaterialApp(
              builder: (context, widget) {
                if (widget != null) {
                  return MediaQuery(
                    data: MediaQuery.of(context).copyWith(textScaleFactor: 1),
                    child: widget,
                  );
                }
                return widget ?? const SizedBox();
              },
              locale: state.status == ChangeLangStatus.success
                  ? state.selectedLanguage?.locale
                  : const Locale('en'),
              localizationsDelegates: const [
                S.delegate,
                GlobalMaterialLocalizations.delegate,
                GlobalWidgetsLocalizations.delegate,
                GlobalCupertinoLocalizations.delegate,
              ],
              supportedLocales: S.delegate.supportedLocales,
              debugShowCheckedModeBanner:
                  environmentConfig == EnvironmentConfig.dev ||
                      environmentConfig == EnvironmentConfig.qa,
              title: getAppName(),
              theme: ThemeData(
                primarySwatch: Colors.orange,
                unselectedWidgetColor:
                    LibraryColors.secondaryFont.withOpacity(0.5),
                canvasColor: Colors.white,
                primaryColorBrightness: Brightness.light,
              ),
              home: BlocConsumer<AuthBloc, AuthState>(
                listener: (context, state) {
                  if (state is ***) {
                    loadLanguage(context);
                  }
                },
                builder: (_, AuthState state) {
                  if (state is ** ) {
                    return _spinner();
                  }
                  if (state is AuthorizationCompleted) {
                    if (**) {
                      return MultiBlocProvider(
                        providers: 
                       /** */
                        child: CongratsView(),
                      );
                    }
                    if (Platform.isIOS) {
                      return const CupertinoScaffold(
                        body: HomeView(
                          initialTab: AppTab.home,
                        ),
                      );
                    }
                    return const HomeView(
                      initialTab: AppTab.home,
                    );
                  }
                  if (state is AuthorizationError) {
                    return WelcomeView();
                  }
                  return WelcomeView();
                },
              ),
            ),
          );
        }),
      ),
    );
  }

  Future<void> loadLanguage(BuildContext context) async {
    try {
      final String? code = await storage.read(key: 'languageCode');
      final Locale locale = getLocale(code, context);
      await S.load(locale);
      BlocProvider.of<AppLanguagesCubit>(context).init(locale);
      if (code == null) {
        await storage.write(
          key: 'languageCode',
          value: locale.languageCode,
        );
      }
      CurrentLocaleDi()
        ..setLocale(locale)
        ..inject();
    } catch (error) {
      await ErrorReporter.writeLogs(error);
    }
  }

  Locale getLocale(String? code, BuildContext context) {
    if (code == null) {
      return Localizations.localeOf(context);
    }
    return S.delegate.supportedLocales
            .firstWhereOrNull((locale) => locale.languageCode == code) ??
        S.delegate.supportedLocales.first;
  }

  Widget _spinner() {
    return AnnotatedRegion<SystemUiOverlayStyle>(
      value: SystemUiOverlayStyle.dark,
      child: Scaffold(
        body: Center(
          child: Image.asset(
            LibraryAssets.appLogo,
            width: 121,
            height: 121,
          ),
        ),
      ),
    );
  }

  String getAppName() {
    const String appName = '***';
    switch (environmentConfig) {
      case EnvironmentConfig.dev:
        return '$appName dev';
      case EnvironmentConfig.qa:
        return '$appName qa';
      case EnvironmentConfig.prod:
        return appName;
    }
  }
}
//app_languages_cubit.dart
//** //

class AppLanguagesCubit extends Cubit<AppLanguagesState> {
  AppLanguagesCubit()
      : super(
          const AppLanguagesState.loading(),
        );

  ExtendedSecureStorage get _storage =>
      DiManager.getIt<ExtendedSecureStorage>();

  final List<AppLanguage> appLanguages = List<AppLanguage>.from(
    S.delegate.supportedLocales.map(
      (locale) => AppLanguage(
        locale: locale,
        code: locale.languageCode,
        lang: targetLangs[locale.languageCode] ?? '',
        langInNativeForm: locale.scriptCode ?? '',
      ),
    ),
  );
  void init(Locale locale) {
    final AppLanguage selectedLanguage = AppLanguage(
      code: locale.languageCode,
      lang: targetLangs[locale.languageCode] ?? '',
      locale: locale,
    );
    Intl.defaultLocale = selectedLanguage.locale.languageCode;
    emit(
      AppLanguagesState.success(
        status: ChangeLangStatus.success,
        selectedLanguage: selectedLanguage,
      ),
    );
  }

  Future<void> changeLanguage(AppLanguage selectedLanguage) async {
    try {
      emit(
        const AppLanguagesState.loading(),
      );
      Intl.defaultLocale = selectedLanguage.locale.languageCode;
      await S.load(selectedLanguage.locale);
      await _storage.write(
        key: 'languageCode',
        value: selectedLanguage.locale.languageCode,
      );
      CurrentLocaleDi()
        ..setLocale(selectedLanguage.locale)
        ..inject();


        emit(
            AppLanguagesState.success(
              status: ChangeLangStatus.success,
              selectedLanguage: selectedLanguage,
            ),
          );
        } catch (error) {
          await ErrorReporter.writeLogs(error);
          emit(
            const AppLanguagesState.failure(),
          );
        }
      }
    }
//ln10.dart
// GENERATED CODE - DO NOT MODIFY BY HAND
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import 'intl/messages_all.dart';

// **************************************************************************
// Generator: Flutter Intl IDE plugin
// Made by Localizely
// **************************************************************************

// ignore_for_file: non_constant_identifier_names, lines_longer_than_80_chars
// ignore_for_file: join_return_with_assignment, prefer_final_in_for_each
// ignore_for_file: avoid_redundant_argument_values, avoid_escaping_inner_quotes

class S {
  S();

  static S? _current;

  static S get current {
    assert(_current != null,
        'No instance of S was loaded. Try to initialize the S delegate before accessing S.current.');
    return _current!;
  }

  static const AppLocalizationDelegate delegate = AppLocalizationDelegate();

  static Future<S> load(Locale locale) {
    final name = (locale.countryCode?.isEmpty ?? false)
        ? locale.languageCode
        : locale.toString();
    final localeName = Intl.canonicalizedLocale(name);
    return initializeMessages(localeName).then((_) {
      Intl.defaultLocale = localeName;
      final instance = S();
      S._current = instance;

      return instance;
    });
  }

  static S of(BuildContext context) {
    final instance = S.maybeOf(context);
    assert(instance != null,
        'No instance of S present in the widget tree. Did you add S.delegate in localizationsDelegates?');
    return instance!;
  }

  static S? maybeOf(BuildContext context) {
    return Localizations.of<S>(context, S);
  }

  /// `**`
  String get sliderText1 {
    return Intl.message(
      'some text'
      name: 'sliderText1',
      desc: '',
      args: [],
    );
  }
//** */
}

class AppLocalizationDelegate extends LocalizationsDelegate<S> {
  const AppLocalizationDelegate();

  List<Locale> get supportedLocales {
    return const <Locale>[
      Locale.fromSubtags(languageCode: 'en'),
      Locale.fromSubtags(languageCode: 'de'),
      Locale.fromSubtags(languageCode: 'es'),
      Locale.fromSubtags(languageCode: 'fr'),
      Locale.fromSubtags(languageCode: 'ja'),
      Locale.fromSubtags(languageCode: 'pl'),
      Locale.fromSubtags(languageCode: 'pt'),
      Locale.fromSubtags(languageCode: 'ru'),
      Locale.fromSubtags(languageCode: 'tr'),
      Locale.fromSubtags(languageCode: 'uk'),
      Locale.fromSubtags(languageCode: 'zh'),
    ];
  }

  @override
  bool isSupported(Locale locale) => _isSupported(locale);
  @override
  Future<S> load(Locale locale) => S.load(locale);
  @override
  bool shouldReload(AppLocalizationDelegate old) => false;

  bool _isSupported(Locale locale) {
    for (var supportedLocale in supportedLocales) {
      if (supportedLocale.languageCode == locale.languageCode) {
        return true;
      }
    }
    return false;
  }
}