< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Localization.LocalizationManager
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Localization/LocalizationManager.cs
Line coverage
95%
Covered lines: 113
Uncovered lines: 5
Coverable lines: 118
Total lines: 562
Line coverage: 95.7%
Branch coverage
88%
Covered branches: 67
Total branches: 76
Branch coverage: 88.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 10/5/2025 - 12:11:27 AM Line coverage: 95% (96/101) Branch coverage: 89% (73/82) Total lines: 54512/29/2025 - 12:13:19 AM Line coverage: 95.7% (113/118) Branch coverage: 88.1% (67/76) Total lines: 562 10/5/2025 - 12:11:27 AM Line coverage: 95% (96/101) Branch coverage: 89% (73/82) Total lines: 54512/29/2025 - 12:13:19 AM Line coverage: 95.7% (113/118) Branch coverage: 88.1% (67/76) Total lines: 562

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
GetCultures()100%11100%
FindLanguageInfo(...)100%22100%
GetCountries()50%44100%
GetParentalRatings()85%202094.44%
GetParentalRatingsDictionary(...)100%44100%
GetRatingScore(...)96.87%3232100%
GetLocalizedString(...)100%11100%
GetLocalizedString(...)66.66%7675%
GetLocalizationDictionary(...)100%11100%
GetResourceFilename(...)100%22100%
TryGetISO6392TFromB(...)83.33%7671.42%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Localization/LocalizationManager.cs

#LineLine coverage
 1using System;
 2using System.Collections.Concurrent;
 3using System.Collections.Frozen;
 4using System.Collections.Generic;
 5using System.Diagnostics.CodeAnalysis;
 6using System.IO;
 7using System.Linq;
 8using System.Reflection;
 9using System.Text.Json;
 10using System.Threading.Tasks;
 11using Jellyfin.Extensions;
 12using Jellyfin.Extensions.Json;
 13using MediaBrowser.Controller.Configuration;
 14using MediaBrowser.Model.Entities;
 15using MediaBrowser.Model.Globalization;
 16using Microsoft.Extensions.Logging;
 17
 18namespace Emby.Server.Implementations.Localization
 19{
 20    /// <summary>
 21    /// Class LocalizationManager.
 22    /// </summary>
 23    public class LocalizationManager : ILocalizationManager
 24    {
 25        private const string DefaultCulture = "en-US";
 26        private const string RatingsPath = "Emby.Server.Implementations.Localization.Ratings.";
 27        private const string CulturesPath = "Emby.Server.Implementations.Localization.iso6392.txt";
 28        private const string CountriesPath = "Emby.Server.Implementations.Localization.countries.json";
 229        private static readonly Assembly _assembly = typeof(LocalizationManager).Assembly;
 230        private static readonly string[] _unratedValues = ["n/a", "unrated", "not rated", "nr"];
 31
 32        private readonly IServerConfigurationManager _configurationManager;
 33        private readonly ILogger<LocalizationManager> _logger;
 34
 5635        private readonly Dictionary<string, Dictionary<string, ParentalRatingScore?>> _allParentalRatings = new(StringCo
 36
 5637        private readonly ConcurrentDictionary<string, Dictionary<string, string>> _dictionaries = new(StringComparer.Ord
 38
 5639        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
 40
 5641        private readonly ConcurrentDictionary<string, CultureDto?> _cultureCache = new(StringComparer.OrdinalIgnoreCase)
 5642        private List<CultureDto> _cultures = [];
 43
 44        private FrozenDictionary<string, string> _iso6392BtoT = null!;
 45
 46        /// <summary>
 47        /// Initializes a new instance of the <see cref="LocalizationManager" /> class.
 48        /// </summary>
 49        /// <param name="configurationManager">The configuration manager.</param>
 50        /// <param name="logger">The logger.</param>
 51        public LocalizationManager(
 52            IServerConfigurationManager configurationManager,
 53            ILogger<LocalizationManager> logger)
 54        {
 5655            _configurationManager = configurationManager;
 5656            _logger = logger;
 5657        }
 58
 59        /// <summary>
 60        /// Loads all resources into memory.
 61        /// </summary>
 62        /// <returns><see cref="Task" />.</returns>
 63        public async Task LoadAll()
 64        {
 65            // Extract from the assembly
 66            foreach (var resource in _assembly.GetManifestResourceNames())
 67            {
 68                if (!resource.StartsWith(RatingsPath, StringComparison.Ordinal))
 69                {
 70                    continue;
 71                }
 72
 73                using var stream = _assembly.GetManifestResourceStream(resource);
 74                if (stream is not null)
 75                {
 76                    var ratingSystem = await JsonSerializer.DeserializeAsync<ParentalRatingSystem>(stream, _jsonOptions)
 77                                ?? throw new InvalidOperationException($"Invalid resource path: '{CountriesPath}'");
 78
 79                    var dict = new Dictionary<string, ParentalRatingScore?>();
 80                    if (ratingSystem.Ratings is not null)
 81                    {
 82                        foreach (var ratingEntry in ratingSystem.Ratings)
 83                        {
 84                            foreach (var ratingString in ratingEntry.RatingStrings)
 85                            {
 86                                dict[ratingString] = ratingEntry.RatingScore;
 87                            }
 88                        }
 89
 90                        _allParentalRatings[ratingSystem.CountryCode] = dict;
 91                    }
 92                }
 93            }
 94
 95            await LoadCultures().ConfigureAwait(false);
 96        }
 97
 98        /// <summary>
 99        /// Gets the cultures.
 100        /// </summary>
 101        /// <returns><see cref="IEnumerable{CultureDto}" />.</returns>
 102        public IEnumerable<CultureDto> GetCultures()
 1103            => _cultures;
 104
 105        private async Task LoadCultures()
 106        {
 107            List<CultureDto> list = [];
 108            Dictionary<string, string> iso6392BtoTdict = new Dictionary<string, string>();
 109
 110            using var stream = _assembly.GetManifestResourceStream(CulturesPath);
 111            if (stream is null)
 112            {
 113                throw new InvalidOperationException($"Invalid resource path: '{CulturesPath}'");
 114            }
 115            else
 116            {
 117                using var reader = new StreamReader(stream);
 118                await foreach (var line in reader.ReadAllLinesAsync().ConfigureAwait(false))
 119                {
 120                    if (string.IsNullOrWhiteSpace(line))
 121                    {
 122                        continue;
 123                    }
 124
 125                    var parts = line.Split('|');
 126                    if (parts.Length != 5)
 127                    {
 128                        throw new InvalidDataException($"Invalid culture data found at: '{line}'");
 129                    }
 130
 131                    string name = parts[3];
 132                    string displayname = parts[3];
 133                    if (string.IsNullOrWhiteSpace(displayname))
 134                    {
 135                        continue;
 136                    }
 137
 138                    string twoCharName = parts[2];
 139                    if (string.IsNullOrWhiteSpace(twoCharName))
 140                    {
 141                        continue;
 142                    }
 143                    else if (twoCharName.Contains('-', StringComparison.OrdinalIgnoreCase))
 144                    {
 145                        name = twoCharName;
 146                    }
 147
 148                    string[] threeLetterNames;
 149                    if (string.IsNullOrWhiteSpace(parts[1]))
 150                    {
 151                        threeLetterNames = [parts[0]];
 152                    }
 153                    else
 154                    {
 155                        threeLetterNames = [parts[0], parts[1]];
 156
 157                        // In cases where there are two TLN the first one is ISO 639-2/T and the second one is ISO 639-2
 158                        // We need ISO 639-2/T for the .NET cultures so we cultivate a dictionary for the translation B-
 159                        iso6392BtoTdict.TryAdd(parts[1], parts[0]);
 160                    }
 161
 162                    list.Add(new CultureDto(name, displayname, twoCharName, threeLetterNames));
 163                }
 164
 165                _cultureCache.Clear();
 166                _cultures = list;
 167                _iso6392BtoT = iso6392BtoTdict.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
 168            }
 169        }
 170
 171        /// <inheritdoc />
 172        public CultureDto? FindLanguageInfo(string language)
 173        {
 6174            if (string.IsNullOrEmpty(language))
 175            {
 1176                return null;
 177            }
 178
 5179            return _cultureCache.GetOrAdd(
 5180                language,
 5181                static (lang, cultures) =>
 5182                {
 5183                    // TODO language should ideally be a ReadOnlySpan but moq cannot mock ref structs
 5184                    for (var i = 0; i < cultures.Count; i++)
 5185                    {
 5186                        var culture = cultures[i];
 5187                        if (lang.Equals(culture.DisplayName, StringComparison.OrdinalIgnoreCase)
 5188                            || lang.Equals(culture.Name, StringComparison.OrdinalIgnoreCase)
 5189                            || culture.ThreeLetterISOLanguageNames.Contains(lang, StringComparison.OrdinalIgnoreCase)
 5190                            || lang.Equals(culture.TwoLetterISOLanguageName, StringComparison.OrdinalIgnoreCase))
 5191                        {
 5192                            return culture;
 5193                        }
 5194                    }
 5195
 5196                    return null;
 5197                },
 5198                _cultures);
 199        }
 200
 201        /// <inheritdoc />
 202        public IReadOnlyList<CountryInfo> GetCountries()
 203        {
 1204            using var stream = _assembly.GetManifestResourceStream(CountriesPath) ?? throw new InvalidOperationException
 205
 1206            return JsonSerializer.Deserialize<IReadOnlyList<CountryInfo>>(stream, _jsonOptions) ?? [];
 1207        }
 208
 209        /// <inheritdoc />
 210        public IReadOnlyList<ParentalRating> GetParentalRatings()
 211        {
 212            // Use server default language for ratings
 213            // Fall back to empty list if there are no parental ratings for that language
 2214            var ratings = GetParentalRatingsDictionary()?.Select(x => new ParentalRating(x.Key, x.Value)).ToList() ?? []
 215
 216            // Add common ratings to ensure them being available for selection
 217            // Based on the US rating system due to it being the main source of rating in the metadata providers
 218            // Unrated
 2219            if (!ratings.Any(x => x is null))
 220            {
 2221                ratings.Add(new("Unrated", null));
 222            }
 223
 224            // Minimum rating possible
 2225            if (ratings.All(x => x.RatingScore?.Score != 0))
 226            {
 0227                ratings.Add(new("Approved", new(0, null)));
 228            }
 229
 230            // Matches PG (this has different age restrictions depending on country)
 2231            if (ratings.All(x => x.RatingScore?.Score != 10))
 232            {
 1233                ratings.Add(new("10", new(10, null)));
 234            }
 235
 236            // Matches PG-13
 2237            if (ratings.All(x => x.RatingScore?.Score != 13))
 238            {
 1239                ratings.Add(new("13", new(13, null)));
 240            }
 241
 242            // Matches TV-14
 2243            if (ratings.All(x => x.RatingScore?.Score != 14))
 244            {
 1245                ratings.Add(new("14", new(14, null)));
 246            }
 247
 248            // Catchall if max rating of country is less than 21
 249            // Using 21 instead of 18 to be sure to allow access to all rated content except adult and banned
 2250            if (!ratings.Any(x => x.RatingScore?.Score >= 21))
 251            {
 2252                ratings.Add(new ParentalRating("21", new(21, null)));
 253            }
 254
 255            // A lot of countries don't explicitly have a separate rating for adult content
 2256            if (ratings.All(x => x.RatingScore?.Score != 1000))
 257            {
 2258                ratings.Add(new ParentalRating("XXX",  new(1000, null)));
 259            }
 260
 261            // A lot of countries don't explicitly have a separate rating for banned content
 2262            if (ratings.All(x => x.RatingScore?.Score != 1001))
 263            {
 2264                ratings.Add(new ParentalRating("Banned",  new(1001, null)));
 265            }
 266
 2267            return [.. ratings.OrderBy(r => r.RatingScore?.Score).ThenBy(r => r.RatingScore?.SubScore)];
 268        }
 269
 270        /// <summary>
 271        /// Gets the parental ratings dictionary.
 272        /// </summary>
 273        /// <param name="countryCode">The optional two letter ISO language string.</param>
 274        /// <returns><see cref="Dictionary{String, ParentalRatingScore}" />.</returns>
 275        private Dictionary<string, ParentalRatingScore?>? GetParentalRatingsDictionary(string? countryCode = null)
 276        {
 277            // Fallback to server default if no country code is specified.
 20278            if (string.IsNullOrEmpty(countryCode))
 279            {
 19280                countryCode = _configurationManager.Configuration.MetadataCountryCode;
 281            }
 282
 20283            if (_allParentalRatings.TryGetValue(countryCode, out var countryValue))
 284            {
 19285                return countryValue;
 286            }
 287
 1288            return null;
 289        }
 290
 291        /// <inheritdoc />
 292        public ParentalRatingScore? GetRatingScore(string rating, string? countryCode = null)
 293        {
 28294            ArgumentException.ThrowIfNullOrEmpty(rating);
 295
 296            // Handle unrated content
 28297            if (_unratedValues.Contains(rating.AsSpan(), StringComparison.OrdinalIgnoreCase))
 298            {
 4299                return null;
 300            }
 301
 302            // Convert ints directly
 303            // This may override some of the locale specific age ratings (but those always map to the same age)
 24304            if (int.TryParse(rating, out var ratingAge))
 305            {
 6306                return new(ratingAge, null);
 307            }
 308
 309            // Fairly common for some users to have "Rated R" in their rating field
 18310            rating = rating.Replace("Rated :", string.Empty, StringComparison.OrdinalIgnoreCase)
 18311                            .Replace("Rated:", string.Empty, StringComparison.OrdinalIgnoreCase)
 18312                            .Replace("Rated ", string.Empty, StringComparison.OrdinalIgnoreCase)
 18313                            .Trim();
 314
 315            // Use rating system matching the language
 18316            if (!string.IsNullOrEmpty(countryCode))
 317            {
 1318                var ratingsDictionary = GetParentalRatingsDictionary(countryCode);
 1319                if (ratingsDictionary is not null && ratingsDictionary.TryGetValue(rating, out ParentalRatingScore? valu
 320                {
 1321                    return value;
 322                }
 323            }
 324            else
 325            {
 326                // Fall back to server default language for ratings check
 17327                var ratingsDictionary = GetParentalRatingsDictionary();
 17328                if (ratingsDictionary is not null && ratingsDictionary.TryGetValue(rating, out ParentalRatingScore? valu
 329                {
 8330                    return value;
 331                }
 332            }
 333
 334            // If we don't find anything, check all ratings systems, starting with US
 9335            if (_allParentalRatings.TryGetValue("us", out var usRatings) && usRatings.TryGetValue(rating, out var usValu
 336            {
 3337                return usValue;
 338            }
 339
 386340            foreach (var dictionary in _allParentalRatings.Values)
 341            {
 188342                if (dictionary.TryGetValue(rating, out var value))
 343                {
 2344                    return value;
 345                }
 346            }
 347
 348            // Try splitting by : to handle "Germany: FSK-18"
 4349            if (rating.Contains(':', StringComparison.OrdinalIgnoreCase))
 350            {
 2351                var ratingLevelRightPart = rating.AsSpan().RightPart(':');
 2352                if (ratingLevelRightPart.Length != 0)
 353                {
 1354                    return GetRatingScore(ratingLevelRightPart.ToString());
 355                }
 356            }
 357
 358            // Handle prefix country code to handle "DE-18"
 3359            if (rating.Contains('-', StringComparison.OrdinalIgnoreCase))
 360            {
 2361                var ratingSpan = rating.AsSpan();
 362
 363                // Extract culture from country prefix
 2364                var culture = FindLanguageInfo(ratingSpan.LeftPart('-').ToString());
 365
 2366                var ratingLevelRightPart = ratingSpan.RightPart('-');
 2367                if (ratingLevelRightPart.Length != 0)
 368                {
 369                    // Check rating system of culture
 1370                    return GetRatingScore(ratingLevelRightPart.ToString(), culture?.TwoLetterISOLanguageName);
 371                }
 372            }
 373
 2374            return null;
 2375        }
 376
 377        /// <inheritdoc />
 378        public string GetLocalizedString(string phrase)
 379        {
 535380            return GetLocalizedString(phrase, _configurationManager.Configuration.UICulture);
 381        }
 382
 383        /// <inheritdoc />
 384        public string GetLocalizedString(string phrase, string culture)
 385        {
 535386            if (string.IsNullOrEmpty(culture))
 387            {
 0388                culture = _configurationManager.Configuration.UICulture;
 389            }
 390
 535391            if (string.IsNullOrEmpty(culture))
 392            {
 0393                culture = DefaultCulture;
 394            }
 395
 535396            var dictionary = GetLocalizationDictionary(culture);
 397
 535398            if (dictionary.TryGetValue(phrase, out var value))
 399            {
 513400                return value;
 401            }
 402
 22403            return phrase;
 404        }
 405
 406        private Dictionary<string, string> GetLocalizationDictionary(string culture)
 407        {
 535408            ArgumentException.ThrowIfNullOrEmpty(culture);
 409
 410            const string Prefix = "Core";
 411
 535412            return _dictionaries.GetOrAdd(
 535413                culture,
 535414                static (key, localizationManager) => localizationManager.GetDictionary(Prefix, key, DefaultCulture + ".j
 535415                this);
 416        }
 417
 418        private async Task<Dictionary<string, string>> GetDictionary(string prefix, string culture, string baseFilename)
 419        {
 420            ArgumentException.ThrowIfNullOrEmpty(culture);
 421
 422            var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 423
 424            var namespaceName = GetType().Namespace + "." + prefix;
 425
 426            await CopyInto(dictionary, namespaceName + "." + baseFilename).ConfigureAwait(false);
 427            await CopyInto(dictionary, namespaceName + "." + GetResourceFilename(culture)).ConfigureAwait(false);
 428
 429            return dictionary;
 430        }
 431
 432        private async Task CopyInto(IDictionary<string, string> dictionary, string resourcePath)
 433        {
 434            using var stream = _assembly.GetManifestResourceStream(resourcePath);
 435            // If a Culture doesn't have a translation the stream will be null and it defaults to en-us further up the c
 436            if (stream is null)
 437            {
 438                _logger.LogError("Missing translation/culture resource: {ResourcePath}", resourcePath);
 439                return;
 440            }
 441
 442            var dict = await JsonSerializer.DeserializeAsync<Dictionary<string, string>>(stream, _jsonOptions).Configure
 443            foreach (var key in dict.Keys)
 444            {
 445                dictionary[key] = dict[key];
 446            }
 447        }
 448
 449        private static string GetResourceFilename(string culture)
 450        {
 25451            var parts = culture.Split('-');
 452
 25453            if (parts.Length == 2)
 454            {
 24455                culture = parts[0].ToLowerInvariant() + "-" + parts[1].ToUpperInvariant();
 456            }
 457            else
 458            {
 1459                culture = culture.ToLowerInvariant();
 460            }
 461
 25462            return culture + ".json";
 463        }
 464
 465        /// <inheritdoc />
 466        public IEnumerable<LocalizationOption> GetLocalizationOptions()
 467        {
 468            yield return new LocalizationOption("Afrikaans", "af");
 469            yield return new LocalizationOption("العربية", "ar");
 470            yield return new LocalizationOption("Беларуская", "be");
 471            yield return new LocalizationOption("Български", "bg-BG");
 472            yield return new LocalizationOption("বাংলা (বাংলাদেশ)", "bn");
 473            yield return new LocalizationOption("Català", "ca");
 474            yield return new LocalizationOption("Čeština", "cs");
 475            yield return new LocalizationOption("Cymraeg", "cy");
 476            yield return new LocalizationOption("Dansk", "da");
 477            yield return new LocalizationOption("Deutsch", "de");
 478            yield return new LocalizationOption("English (United Kingdom)", "en-GB");
 479            yield return new LocalizationOption("English", "en-US");
 480            yield return new LocalizationOption("Ελληνικά", "el");
 481            yield return new LocalizationOption("Esperanto", "eo");
 482            yield return new LocalizationOption("Español", "es");
 483            yield return new LocalizationOption("Español americano", "es_419");
 484            yield return new LocalizationOption("Español (Argentina)", "es-AR");
 485            yield return new LocalizationOption("Español (Dominicana)", "es_DO");
 486            yield return new LocalizationOption("Español (México)", "es-MX");
 487            yield return new LocalizationOption("Eesti", "et");
 488            yield return new LocalizationOption("Basque", "eu");
 489            yield return new LocalizationOption("فارسی", "fa");
 490            yield return new LocalizationOption("Suomi", "fi");
 491            yield return new LocalizationOption("Filipino", "fil");
 492            yield return new LocalizationOption("Français", "fr");
 493            yield return new LocalizationOption("Français (Canada)", "fr-CA");
 494            yield return new LocalizationOption("Galego", "gl");
 495            yield return new LocalizationOption("Schwiizerdütsch", "gsw");
 496            yield return new LocalizationOption("עִבְרִית", "he");
 497            yield return new LocalizationOption("हिन्दी", "hi");
 498            yield return new LocalizationOption("Hrvatski", "hr");
 499            yield return new LocalizationOption("Magyar", "hu");
 500            yield return new LocalizationOption("Bahasa Indonesia", "id");
 501            yield return new LocalizationOption("Íslenska", "is");
 502            yield return new LocalizationOption("Italiano", "it");
 503            yield return new LocalizationOption("日本語", "ja");
 504            yield return new LocalizationOption("Qazaqşa", "kk");
 505            yield return new LocalizationOption("한국어", "ko");
 506            yield return new LocalizationOption("Lietuvių", "lt");
 507            yield return new LocalizationOption("Latviešu", "lv");
 508            yield return new LocalizationOption("Македонски", "mk");
 509            yield return new LocalizationOption("മലയാളം", "ml");
 510            yield return new LocalizationOption("मराठी", "mr");
 511            yield return new LocalizationOption("Bahasa Melayu", "ms");
 512            yield return new LocalizationOption("Norsk bokmål", "nb");
 513            yield return new LocalizationOption("नेपाली", "ne");
 514            yield return new LocalizationOption("Nederlands", "nl");
 515            yield return new LocalizationOption("Norsk nynorsk", "nn");
 516            yield return new LocalizationOption("ਪੰਜਾਬੀ", "pa");
 517            yield return new LocalizationOption("Polski", "pl");
 518            yield return new LocalizationOption("Pirate", "pr");
 519            yield return new LocalizationOption("Português", "pt");
 520            yield return new LocalizationOption("Português (Brasil)", "pt-BR");
 521            yield return new LocalizationOption("Português (Portugal)", "pt-PT");
 522            yield return new LocalizationOption("Românește", "ro");
 523            yield return new LocalizationOption("Русский", "ru");
 524            yield return new LocalizationOption("Slovenčina", "sk");
 525            yield return new LocalizationOption("Slovenščina", "sl-SI");
 526            yield return new LocalizationOption("Shqip", "sq");
 527            yield return new LocalizationOption("Српски", "sr");
 528            yield return new LocalizationOption("Svenska", "sv");
 529            yield return new LocalizationOption("தமிழ்", "ta");
 530            yield return new LocalizationOption("తెలుగు", "te");
 531            yield return new LocalizationOption("ภาษาไทย", "th");
 532            yield return new LocalizationOption("Türkçe", "tr");
 533            yield return new LocalizationOption("Українська", "uk");
 534            yield return new LocalizationOption("اُردُو", "ur_PK");
 535            yield return new LocalizationOption("Tiếng Việt", "vi");
 536            yield return new LocalizationOption("汉语 (简体字)", "zh-CN");
 537            yield return new LocalizationOption("漢語 (繁體字)", "zh-TW");
 538            yield return new LocalizationOption("廣東話 (香港)", "zh-HK");
 539        }
 540
 541        /// <inheritdoc />
 542        public bool TryGetISO6392TFromB(string isoB, [NotNullWhen(true)] out string? isoT)
 543        {
 544            // Unlikely case the dictionary is not (yet) initialized properly
 3545            if (_iso6392BtoT is null)
 546            {
 0547                isoT = null;
 0548                return false;
 549            }
 550
 3551            var result = _iso6392BtoT.TryGetValue(isoB, out isoT) && !string.IsNullOrEmpty(isoT);
 552
 553            // Ensure the ISO code being null if the result is false
 3554            if (!result)
 555            {
 1556                isoT = null;
 557            }
 558
 3559            return result;
 560        }
 561    }
 562}
Generated by: ReportGenerator 5.5.1.0
1/14/2026 - 12:10:21 AM
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(MediaBrowser.Controller.Configuration.IServerConfigurationManager,Microsoft.Extensions.Logging.ILogger`1<Emby.Server.Implementations.Localization.LocalizationManager>)
GetCultures()
FindLanguageInfo(System.String)
GetCountries()
GetParentalRatings()
GetParentalRatingsDictionary(System.String)
GetRatingScore(System.String,System.String)
GetLocalizedString(System.String)
GetLocalizedString(System.String,System.String)
GetLocalizationDictionary(System.String)
GetResourceFilename(System.String)
TryGetISO6392TFromB(System.String,System.String&)