1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/soda/constants.h"
#include <optional>
#include <string>
#include "base/containers/flat_map.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/metrics/field_trial_params.h"
#include "base/notreached.h"
#include "base/path_service.h"
#include "base/strings/strcat.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "build/build_config.h"
#include "components/component_updater/component_updater_paths.h"
#include "components/crx_file/id_util.h"
#include "components/language/core/browser/pref_names.h"
#include "components/prefs/pref_service.h"
#include "media/base/media_switches.h"
#include "ui/base/l10n/l10n_util.h"
namespace speech {
namespace {
// If `language_name` is Chinese variant, then return the master locale.
// Otherwise, return `language_name`.
const std::string MaybeMapToChineseLocale(const std::string& language_name) {
const base::flat_map<std::string, std::string> chinese_locale_map = {
{"cmn-hans-cn", "cmn-hans-cn"}, {"cmn-hant-tw", "cmn-hant-tw"},
{"zh-cn", "cmn-hans-cn"}, {"zh-hans-cn", "cmn-hans-cn"},
{"zh-hant-tw", "cmn-hant-tw"}, {"zh-tw", "cmn-hant-tw"},
};
auto chinese_locale =
chinese_locale_map.find(base::ToLowerASCII(language_name));
if (chinese_locale != chinese_locale_map.end()) {
return chinese_locale->second;
}
return language_name;
}
} // namespace
const char kUsEnglishLocale[] = "en-US";
const char kEnglishLocaleNoCountry[] = "en";
const char kChineseLocaleNoCountry[] = "cmn";
const char kSodaBinaryInstallationResult[] =
"SodaInstaller.BinaryInstallationResult";
const char kSodaBinaryInstallationSuccessTimeTaken[] =
"SodaInstaller.BinaryInstallationSuccessTime";
const char kSodaBinaryInstallationFailureTimeTaken[] =
"SodaInstaller.BinaryInstallationFailureTime";
#if BUILDFLAG(IS_WIN)
constexpr base::FilePath::CharType kSodaBinaryRelativePath[] =
FILE_PATH_LITERAL("SODAFiles/SODA.dll");
#else
constexpr base::FilePath::CharType kSodaBinaryRelativePath[] =
FILE_PATH_LITERAL("SODAFiles/libsoda.so");
#endif
constexpr base::FilePath::CharType kSodaTestBinaryRelativePath[] =
FILE_PATH_LITERAL("libsoda.so");
constexpr base::FilePath::CharType kSodaTestResourcesRelativePath[] =
FILE_PATH_LITERAL("third_party/soda/resources/");
constexpr base::FilePath::CharType kSodaInstallationRelativePath[] =
FILE_PATH_LITERAL("SODA");
constexpr base::FilePath::CharType kSodaLanguagePacksRelativePath[] =
FILE_PATH_LITERAL("SODALanguagePacks");
constexpr base::FilePath::CharType kSodaLanguagePackDirectoryRelativePath[] =
FILE_PATH_LITERAL("SODAModels");
const base::FilePath GetSodaDirectory() {
base::FilePath components_dir;
base::PathService::Get(component_updater::DIR_COMPONENT_USER,
&components_dir);
return components_dir.empty()
? base::FilePath()
: components_dir.Append(kSodaInstallationRelativePath);
}
const base::FilePath GetSodaLanguagePacksDirectory() {
base::FilePath components_dir;
base::PathService::Get(component_updater::DIR_COMPONENT_USER,
&components_dir);
return components_dir.empty()
? base::FilePath()
: components_dir.Append(kSodaLanguagePacksRelativePath);
}
const base::FilePath GetSodaTestResourcesDirectory() {
base::FilePath test_data_root;
base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &test_data_root);
DCHECK(!test_data_root.empty());
return test_data_root.empty()
? base::FilePath()
: test_data_root.Append(kSodaTestResourcesRelativePath);
}
const base::FilePath GetLatestSodaLanguagePackDirectory(
const std::string& language) {
base::FileEnumerator enumerator(
GetSodaLanguagePacksDirectory().AppendASCII(language), false,
base::FileEnumerator::DIRECTORIES);
// Use the lexographical order of the directory names to determine the latest
// version. This mirrors the logic in the component updater.
base::FilePath latest_version_dir;
for (base::FilePath version_dir = enumerator.Next(); !version_dir.empty();
version_dir = enumerator.Next()) {
latest_version_dir =
latest_version_dir < version_dir ? version_dir : latest_version_dir;
}
return latest_version_dir.Append(kSodaLanguagePackDirectoryRelativePath);
}
const base::FilePath GetLatestSodaDirectory() {
base::FileEnumerator enumerator(GetSodaDirectory(), false,
base::FileEnumerator::DIRECTORIES);
base::FilePath latest_version_dir;
for (base::FilePath version_dir = enumerator.Next(); !version_dir.empty();
version_dir = enumerator.Next()) {
latest_version_dir =
latest_version_dir < version_dir ? version_dir : latest_version_dir;
}
return latest_version_dir;
}
const base::FilePath GetSodaBinaryPath() {
base::FilePath soda_dir = GetLatestSodaDirectory();
return soda_dir.empty() ? base::FilePath()
: soda_dir.Append(kSodaBinaryRelativePath);
}
const base::FilePath GetSodaTestBinaryPath() {
base::FilePath test_dir = GetSodaTestResourcesDirectory();
return test_dir.empty() ? base::FilePath()
: test_dir.Append(kSodaTestBinaryRelativePath);
}
std::optional<SodaLanguagePackComponentConfig> GetLanguageComponentConfig(
LanguageCode language_code) {
for (const SodaLanguagePackComponentConfig& config :
kLanguageComponentConfigs) {
if (config.language_code == language_code) {
return config;
}
}
return std::nullopt;
}
std::optional<SodaLanguagePackComponentConfig> GetLanguageComponentConfig(
const std::string& language_name) {
auto locale = MaybeMapToChineseLocale(language_name);
for (const SodaLanguagePackComponentConfig& config :
kLanguageComponentConfigs) {
if (base::ToLowerASCII(config.language_name) ==
base::ToLowerASCII(locale)) {
return config;
}
}
return std::nullopt;
}
std::optional<SodaLanguagePackComponentConfig>
GetLanguageComponentConfigMatchingLanguageSubtag(
const std::string& language_name) {
// Use full locale to get Chinese variant config.
auto locale = MaybeMapToChineseLocale(language_name);
if (locale.substr(0, 3) == kChineseLocaleNoCountry) {
return GetLanguageComponentConfig(locale);
}
for (const SodaLanguagePackComponentConfig& config :
kLanguageComponentConfigs) {
if (l10n_util::GetLanguage(base::ToLowerASCII(config.language_name)) ==
l10n_util::GetLanguage(base::ToLowerASCII(language_name))) {
return config;
}
}
return std::nullopt;
}
LanguageCode GetLanguageCodeByComponentId(const std::string& component_id) {
for (const SodaLanguagePackComponentConfig& config :
kLanguageComponentConfigs) {
if (crx_file::id_util::GenerateIdFromHash(config.public_key_sha) ==
component_id) {
return config.language_code;
}
}
return LanguageCode::kNone;
}
std::string GetLanguageName(LanguageCode language_code) {
std::string language_name;
if (language_code != LanguageCode::kNone) {
std::optional<SodaLanguagePackComponentConfig> language_config =
GetLanguageComponentConfig(language_code);
if (language_config.has_value()) {
language_name = language_config.value().language_name;
}
}
return language_name;
}
LanguageCode GetLanguageCode(const std::string& language_name) {
std::optional<SodaLanguagePackComponentConfig> language_config =
GetLanguageComponentConfig(language_name);
if (language_config.has_value()) {
return language_config.value().language_code;
}
return LanguageCode::kNone;
}
const std::u16string GetLanguageDisplayName(const std::string& language_name,
const std::string& display_locale) {
if (language_name.substr(0, 3) == kChineseLocaleNoCountry) {
return l10n_util::GetDisplayNameForLocale(language_name.substr(0, 8),
display_locale, true);
} else {
return l10n_util::GetDisplayNameForLocaleWithoutCountry(
language_name, display_locale, true);
}
}
const std::string GetInstallationSuccessTimeMetricForLanguagePack(
const LanguageCode& language_code) {
auto config = GetLanguageComponentConfig(language_code);
DCHECK(config && config->language_name);
return GetInstallationSuccessTimeMetricForLanguage(config->language_name);
}
const std::string GetInstallationSuccessTimeMetricForLanguage(
const std::string& language) {
return base::StrCat(
{"SodaInstaller.Language.", language, ".InstallationSuccessTime"});
}
const std::string GetInstallationFailureTimeMetricForLanguagePack(
const LanguageCode& language_code) {
auto config = GetLanguageComponentConfig(language_code);
DCHECK(config && config->language_name);
return GetInstallationFailureTimeMetricForLanguage(config->language_name);
}
const std::string GetInstallationFailureTimeMetricForLanguage(
const std::string& language) {
return base::StrCat(
{"SodaInstaller.Language.", language, ".InstallationFailureTime"});
}
const std::string GetInstallationResultMetricForLanguagePack(
const LanguageCode& language_code) {
auto config = GetLanguageComponentConfig(language_code);
DCHECK(config && config->language_name);
return speech::GetInstallationResultMetricForLanguage(config->language_name);
}
const std::string GetInstallationResultMetricForLanguage(
const std::string& language) {
return base::StrCat(
{"SodaInstaller.Language.", language, ".InstallationResult"});
}
const std::string GetDefaultLiveCaptionLanguage(
const std::string& application_locale,
PrefService* profile_prefs) {
std::optional<SodaLanguagePackComponentConfig> application_locale_config =
GetLanguageComponentConfigMatchingLanguageSubtag(application_locale);
if (application_locale_config.has_value() &&
application_locale_config.value().language_code != LanguageCode::kNone) {
return application_locale_config.value().language_name;
}
std::string accept_languages_pref =
profile_prefs->GetString(language::prefs::kAcceptLanguages);
for (std::string language :
base::SplitString(accept_languages_pref, ",", base::TRIM_WHITESPACE,
base::SPLIT_WANT_NONEMPTY)) {
std::optional<SodaLanguagePackComponentConfig> config =
GetLanguageComponentConfigMatchingLanguageSubtag(language);
if (config.has_value() &&
config.value().language_code != LanguageCode::kNone) {
return config.value().language_name;
}
}
return kUsEnglishLocale;
}
} // namespace speech
|