Unable to refresh text in child pages using flutter_localizations,intl - flutter

Question

I'm trying to change localized words through my whole app. But it only changes when I restart my App or when I do subscription on lang changes. Is there any native way to change localized word without any subscription and have the same result as I get when restart the app?
As an example by what do I mean under subscription:
//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;
}
}

Answer 1

You can change the whole app without any subscription and set state. You have to use await WidgetsBinding.instance.performReassemble(); which is triggered the whole app with your updated value.This is the function