edde746
369c6279d6
A Portuguese user reported "Skip Intro" rendering in English on Android TV.
The locale files were not the problem - all 22 were structurally complete.
skip_marker_button.dart simply never imported strings.g.dart and assigned
'Skip Intro' / 'Skip Credits' / 'Next Episode' as plain literals. An audit of
lib/ found ~120 more sites in the same state, in four shapes that need
different fixes:
A literal in a file that never imported the i18n layer is the easy one -
skip_marker_button, performance_stats, track_label_builder and codec_utils all
render text with no `t` in the file at all. TrackLabelBuilder._compose now takes
a fallbackLabel builder instead of an English fallbackPrefix, so the caller
supplies t.audioTracks.track / t.videoControls.subtitleTrack and every unnamed
audio and subtitle row in the track menus is localized.
English reaching the user through an exception message is the widest one, and
it needs care: MediaServerException.message feeds both toString() - logs and
Sentry grouping - and verbatim UI display. Localizing it in place would make
bug-report logs follow the user's locale and split one Sentry issue into 22.
The MediaServer and Seerr families instead gain a nullable `display` alongside
the English `message`, and the six screens that print these errors read
`display ?? message`. PlaybackException keeps the opposite rule, because it
already carries a PlaybackFailureReason for logic and classifyPlaybackFailure
already builds it from t.messages: its stragglers are localized at the throw
site. That also removes the literal "Exception: " prefix Live TV users saw on
a tune failure, since PlaybackException.toString() returns the bare message.
Localized parts hand-concatenated with bare English are the shape no search for
Text('...') can find: '${t.common.pause} auto-scroll' on the home carousel,
'${day} at ${time}' on the Live TV schedule row, and an actor-screen count that
hand-rolled its plural as `n == 1 ? 'title' : 'titles'` - wrong for ru and pl
regardless of translation, now a real Slang plural.
Finally a literal assigned to provider state that a widget renders later:
DownloadProgress.errorMessage, and the four background_downloader notification
bodies, which sit inside a plugin config call where no widget-shaped search
reaches them.
Two things surfaced while converting. track_chapter_controls compared a track
label against 'Audio Track N' to swap in a localized version; once the builder
localized its own fallback that branch became unreachable, so it and the
orphaned _joinTrackLabel are gone. And discovery_view's PeerError fallback arm
looks like a leak but is not - its producers already localize, and a test says
so - so it stays as it is.
All 21 non-base locales are translated, including the 21 keys left empty by
earlier commits that were falling back to English. No locale has an empty value.
scripts/check_hardcoded_strings.py guards the three shapes a structural check
can see, and runs in ci_checks.sh after translation hygiene. Its first draft
passed its own tests while missing this very bug, because 'Skip Intro' is bound
to a local rather than handed to Text(); the name-bound rule that closes that
gap is restricted to phrase-shaped literals, or it cannot tell copy from the
identifiers this codebase binds constantly ('cast_row', 'auto', 'liveTv'). It
cannot see English inside a throw or assigned to a provider field - neither is
distinguishable from a log message without dataflow analysis - and the docstring
says so. label: and actionLabel: are deliberately unscanned: here they name a
diagnostic operation, and a check that is chronically red is a check that gets
switched off.
One commit rather than one per area: the keys, the 22 locale files and the
generated output are a single unit, and any partial split fails the repo's own
unused-key scan on the way through.
close #1856
482 lines
15 KiB
Dart
482 lines
15 KiB
Dart
/// Generated file. Do not edit.
|
|
///
|
|
/// Source: lib/i18n
|
|
/// To regenerate, run: `dart run slang`
|
|
///
|
|
/// Locales: 22
|
|
/// Strings: 40700 (1850 per locale)
|
|
|
|
// coverage:ignore-file
|
|
// ignore_for_file: type=lint, unused_import
|
|
// dart format off
|
|
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'package:slang/generated.dart';
|
|
import 'package:slang_flutter/slang_flutter.dart';
|
|
export 'package:slang_flutter/slang_flutter.dart';
|
|
|
|
import 'strings_az.g.dart' deferred as l_az;
|
|
import 'strings_bg.g.dart' deferred as l_bg;
|
|
import 'strings_da.g.dart' deferred as l_da;
|
|
import 'strings_de.g.dart' deferred as l_de;
|
|
import 'strings_es.g.dart' deferred as l_es;
|
|
import 'strings_fr.g.dart' deferred as l_fr;
|
|
import 'strings_hu.g.dart' deferred as l_hu;
|
|
import 'strings_it.g.dart' deferred as l_it;
|
|
import 'strings_ja.g.dart' deferred as l_ja;
|
|
import 'strings_kk.g.dart' deferred as l_kk;
|
|
import 'strings_ko.g.dart' deferred as l_ko;
|
|
import 'strings_nb.g.dart' deferred as l_nb;
|
|
import 'strings_nl.g.dart' deferred as l_nl;
|
|
import 'strings_pl.g.dart' deferred as l_pl;
|
|
import 'strings_pt.g.dart' deferred as l_pt;
|
|
import 'strings_ru.g.dart' deferred as l_ru;
|
|
import 'strings_sv.g.dart' deferred as l_sv;
|
|
import 'strings_tr.g.dart' deferred as l_tr;
|
|
import 'strings_uz.g.dart' deferred as l_uz;
|
|
import 'strings_zh.g.dart' deferred as l_zh;
|
|
import 'strings_zh_Hant.g.dart' deferred as l_zh_Hant;
|
|
part 'strings_en.g.dart';
|
|
|
|
/// Supported locales.
|
|
///
|
|
/// Usage:
|
|
/// - LocaleSettings.setLocale(AppLocale.en) // set locale
|
|
/// - Locale locale = AppLocale.en.flutterLocale // get flutter locale from enum
|
|
/// - if (LocaleSettings.currentLocale == AppLocale.en) // locale check
|
|
enum AppLocale with BaseAppLocale<AppLocale, Translations> {
|
|
en(languageCode: 'en'),
|
|
az(languageCode: 'az'),
|
|
bg(languageCode: 'bg'),
|
|
da(languageCode: 'da'),
|
|
de(languageCode: 'de'),
|
|
es(languageCode: 'es'),
|
|
fr(languageCode: 'fr'),
|
|
hu(languageCode: 'hu'),
|
|
it(languageCode: 'it'),
|
|
ja(languageCode: 'ja'),
|
|
kk(languageCode: 'kk'),
|
|
ko(languageCode: 'ko'),
|
|
nb(languageCode: 'nb'),
|
|
nl(languageCode: 'nl'),
|
|
pl(languageCode: 'pl'),
|
|
pt(languageCode: 'pt'),
|
|
ru(languageCode: 'ru'),
|
|
sv(languageCode: 'sv'),
|
|
tr(languageCode: 'tr'),
|
|
uz(languageCode: 'uz'),
|
|
zh(languageCode: 'zh'),
|
|
zhHant(languageCode: 'zh', scriptCode: 'Hant');
|
|
|
|
const AppLocale({
|
|
required this.languageCode,
|
|
this.scriptCode, // ignore: unused_element, unused_element_parameter
|
|
this.countryCode, // ignore: unused_element, unused_element_parameter
|
|
});
|
|
|
|
@override final String languageCode;
|
|
@override final String? scriptCode;
|
|
@override final String? countryCode;
|
|
|
|
@override
|
|
Future<Translations> build({
|
|
Map<String, Node>? overrides,
|
|
PluralResolver? cardinalResolver,
|
|
PluralResolver? ordinalResolver,
|
|
}) async {
|
|
switch (this) {
|
|
case AppLocale.en:
|
|
return TranslationsEn(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.az:
|
|
await l_az.loadLibrary();
|
|
return l_az.TranslationsAz(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.bg:
|
|
await l_bg.loadLibrary();
|
|
return l_bg.TranslationsBg(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.da:
|
|
await l_da.loadLibrary();
|
|
return l_da.TranslationsDa(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.de:
|
|
await l_de.loadLibrary();
|
|
return l_de.TranslationsDe(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.es:
|
|
await l_es.loadLibrary();
|
|
return l_es.TranslationsEs(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.fr:
|
|
await l_fr.loadLibrary();
|
|
return l_fr.TranslationsFr(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.hu:
|
|
await l_hu.loadLibrary();
|
|
return l_hu.TranslationsHu(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.it:
|
|
await l_it.loadLibrary();
|
|
return l_it.TranslationsIt(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.ja:
|
|
await l_ja.loadLibrary();
|
|
return l_ja.TranslationsJa(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.kk:
|
|
await l_kk.loadLibrary();
|
|
return l_kk.TranslationsKk(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.ko:
|
|
await l_ko.loadLibrary();
|
|
return l_ko.TranslationsKo(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.nb:
|
|
await l_nb.loadLibrary();
|
|
return l_nb.TranslationsNb(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.nl:
|
|
await l_nl.loadLibrary();
|
|
return l_nl.TranslationsNl(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.pl:
|
|
await l_pl.loadLibrary();
|
|
return l_pl.TranslationsPl(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.pt:
|
|
await l_pt.loadLibrary();
|
|
return l_pt.TranslationsPt(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.ru:
|
|
await l_ru.loadLibrary();
|
|
return l_ru.TranslationsRu(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.sv:
|
|
await l_sv.loadLibrary();
|
|
return l_sv.TranslationsSv(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.tr:
|
|
await l_tr.loadLibrary();
|
|
return l_tr.TranslationsTr(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.uz:
|
|
await l_uz.loadLibrary();
|
|
return l_uz.TranslationsUz(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.zh:
|
|
await l_zh.loadLibrary();
|
|
return l_zh.TranslationsZh(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.zhHant:
|
|
await l_zh_Hant.loadLibrary();
|
|
return l_zh_Hant.TranslationsZhHant(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
}
|
|
}
|
|
|
|
@override
|
|
Translations buildSync({
|
|
Map<String, Node>? overrides,
|
|
PluralResolver? cardinalResolver,
|
|
PluralResolver? ordinalResolver,
|
|
}) {
|
|
switch (this) {
|
|
case AppLocale.en:
|
|
return TranslationsEn(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.az:
|
|
return l_az.TranslationsAz(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.bg:
|
|
return l_bg.TranslationsBg(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.da:
|
|
return l_da.TranslationsDa(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.de:
|
|
return l_de.TranslationsDe(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.es:
|
|
return l_es.TranslationsEs(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.fr:
|
|
return l_fr.TranslationsFr(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.hu:
|
|
return l_hu.TranslationsHu(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.it:
|
|
return l_it.TranslationsIt(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.ja:
|
|
return l_ja.TranslationsJa(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.kk:
|
|
return l_kk.TranslationsKk(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.ko:
|
|
return l_ko.TranslationsKo(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.nb:
|
|
return l_nb.TranslationsNb(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.nl:
|
|
return l_nl.TranslationsNl(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.pl:
|
|
return l_pl.TranslationsPl(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.pt:
|
|
return l_pt.TranslationsPt(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.ru:
|
|
return l_ru.TranslationsRu(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.sv:
|
|
return l_sv.TranslationsSv(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.tr:
|
|
return l_tr.TranslationsTr(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.uz:
|
|
return l_uz.TranslationsUz(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.zh:
|
|
return l_zh.TranslationsZh(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
case AppLocale.zhHant:
|
|
return l_zh_Hant.TranslationsZhHant(
|
|
overrides: overrides,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Gets current instance managed by [LocaleSettings].
|
|
Translations get translations => LocaleSettings.instance.getTranslations(this);
|
|
}
|
|
|
|
/// Method A: Simple
|
|
///
|
|
/// No rebuild after locale change.
|
|
/// Translation happens during initialization of the widget (call of t).
|
|
/// Configurable via 'translate_var'.
|
|
///
|
|
/// Usage:
|
|
/// String a = t.someKey.anotherKey;
|
|
/// String b = t['someKey.anotherKey']; // Only for edge cases!
|
|
Translations get t => LocaleSettings.instance.currentTranslations;
|
|
|
|
/// Method B: Advanced
|
|
///
|
|
/// All widgets using this method will trigger a rebuild when locale changes.
|
|
/// Use this if you have e.g. a settings page where the user can select the locale during runtime.
|
|
///
|
|
/// Step 1:
|
|
/// wrap your App with
|
|
/// TranslationProvider(
|
|
/// child: MyApp()
|
|
/// );
|
|
///
|
|
/// Step 2:
|
|
/// final t = Translations.of(context); // Get t variable.
|
|
/// String a = t.someKey.anotherKey; // Use t variable.
|
|
/// String b = t['someKey.anotherKey']; // Only for edge cases!
|
|
class TranslationProvider extends BaseTranslationProvider<AppLocale, Translations> {
|
|
TranslationProvider({required super.child}) : super(settings: LocaleSettings.instance);
|
|
|
|
static InheritedLocaleData<AppLocale, Translations> of(BuildContext context) => InheritedLocaleData.of<AppLocale, Translations>(context);
|
|
}
|
|
|
|
/// Method B shorthand via [BuildContext] extension method.
|
|
/// Configurable via 'translate_var'.
|
|
///
|
|
/// Usage (e.g. in a widget's build method):
|
|
/// context.t.someKey.anotherKey
|
|
extension BuildContextTranslationsExtension on BuildContext {
|
|
Translations get t => TranslationProvider.of(this).translations;
|
|
}
|
|
|
|
/// Manages all translation instances and the current locale
|
|
class LocaleSettings extends BaseFlutterLocaleSettings<AppLocale, Translations> {
|
|
LocaleSettings._() : super(
|
|
utils: AppLocaleUtils.instance,
|
|
lazy: true,
|
|
);
|
|
|
|
static final instance = LocaleSettings._();
|
|
|
|
// static aliases (checkout base methods for documentation)
|
|
static AppLocale get currentLocale => instance.currentLocale;
|
|
static Stream<AppLocale> getLocaleStream() => instance.getLocaleStream();
|
|
static Future<AppLocale> setLocale(AppLocale locale, {bool? listenToDeviceLocale = false}) => instance.setLocale(locale, listenToDeviceLocale: listenToDeviceLocale);
|
|
static Future<AppLocale> setLocaleRaw(String rawLocale, {bool? listenToDeviceLocale = false}) => instance.setLocaleRaw(rawLocale, listenToDeviceLocale: listenToDeviceLocale);
|
|
static Future<AppLocale> useDeviceLocale() => instance.useDeviceLocale();
|
|
static Future<void> setPluralResolver({String? language, AppLocale? locale, PluralResolver? cardinalResolver, PluralResolver? ordinalResolver}) => instance.setPluralResolver(
|
|
language: language,
|
|
locale: locale,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
|
|
// synchronous versions
|
|
static AppLocale setLocaleSync(AppLocale locale, {bool? listenToDeviceLocale = false}) => instance.setLocaleSync(locale, listenToDeviceLocale: listenToDeviceLocale);
|
|
static AppLocale setLocaleRawSync(String rawLocale, {bool? listenToDeviceLocale = false}) => instance.setLocaleRawSync(rawLocale, listenToDeviceLocale: listenToDeviceLocale);
|
|
static AppLocale useDeviceLocaleSync() => instance.useDeviceLocaleSync();
|
|
static void setPluralResolverSync({String? language, AppLocale? locale, PluralResolver? cardinalResolver, PluralResolver? ordinalResolver}) => instance.setPluralResolverSync(
|
|
language: language,
|
|
locale: locale,
|
|
cardinalResolver: cardinalResolver,
|
|
ordinalResolver: ordinalResolver,
|
|
);
|
|
}
|
|
|
|
/// Provides utility functions without any side effects.
|
|
class AppLocaleUtils extends BaseAppLocaleUtils<AppLocale, Translations> {
|
|
AppLocaleUtils._() : super(
|
|
baseLocale: AppLocale.en,
|
|
locales: AppLocale.values,
|
|
);
|
|
|
|
static final instance = AppLocaleUtils._();
|
|
|
|
// static aliases (checkout base methods for documentation)
|
|
static AppLocale parse(String rawLocale) => instance.parse(rawLocale);
|
|
static AppLocale parseLocaleParts({required String languageCode, String? scriptCode, String? countryCode}) => instance.parseLocaleParts(languageCode: languageCode, scriptCode: scriptCode, countryCode: countryCode);
|
|
static AppLocale findDeviceLocale() => instance.findDeviceLocale();
|
|
static List<Locale> get supportedLocales => instance.supportedLocales;
|
|
static List<String> get supportedLocalesRaw => instance.supportedLocalesRaw;
|
|
}
|