| // Copyright 2015 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| /** |
| * @fileoverview 'settings-languages' handles Chrome's language and input |
| * method settings. The 'languages' property, which reflects the current |
| * language settings, must not be changed directly. Instead, changes to |
| * language settings should be made using the LanguageHelper APIs provided by |
| * this class via languageHelper. |
| */ |
| |
| // TODO(b/263828712): Upstream and downstream changes from browser settings, and |
| // consider merging the two. |
| |
| import '/shared/settings/prefs/prefs.js'; |
| |
| import {PrefsMixin} from '/shared/settings/prefs/prefs_mixin.js'; |
| import {CrSettingsPrefs} from '/shared/settings/prefs/prefs_types.js'; |
| import {assert} from 'chrome://resources/js/assert.js'; |
| import {loadTimeData} from 'chrome://resources/js/load_time_data.js'; |
| import {PromiseResolver} from 'chrome://resources/js/promise_resolver.js'; |
| import {PolymerElement} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js'; |
| |
| import {castExists} from '../assert_extras.js'; |
| |
| import type {LanguagesBrowserProxy} from './languages_browser_proxy.js'; |
| import {LanguagesBrowserProxyImpl} from './languages_browser_proxy.js'; |
| import type {LanguageHelper, LanguagesModel, LanguageState, SpellCheckLanguageState} from './languages_types.js'; |
| |
| const MoveType = chrome.languageSettingsPrivate.MoveType; |
| |
| // Translate server treats some language codes the same. |
| // See also: components/translate/core/common/translate_util.cc. |
| const kLanguageCodeToTranslateCode = { |
| 'nb': 'no', |
| 'fil': 'tl', |
| 'zh-HK': 'zh-TW', |
| 'zh-MO': 'zh-TW', |
| 'zh-SG': 'zh-CN', |
| } as const; |
| |
| // Some ISO 639 language codes have been renamed, e.g. "he" to "iw", but |
| // Translate still uses the old versions. TODO(michaelpg): Chrome does too. |
| // Follow up with Translate owners to understand the right thing to do. |
| const kTranslateLanguageSynonyms = { |
| he: 'iw', |
| jv: 'jw', |
| } as const; |
| |
| // The fake language name used for ARC IMEs. The value must be in sync with the |
| // one in ui/base/ime/ash/extension_ime_util.h. |
| const kArcImeLanguage = '_arc_ime_language_'; |
| |
| // The IME ID for the Accessibility Common extension used by Dictation. |
| export const ACCESSIBILITY_COMMON_IME_ID = |
| '_ext_ime_egfdjlfmgnehecnclamagfafdccgfndpdictation'; |
| |
| interface ModelArgs { |
| // Unused. |
| supportedLanguages: chrome.languageSettingsPrivate.Language[]; |
| translateTarget: string; |
| alwaysTranslateCodes: string[]; |
| neverTranslateCodes: string[]; |
| startingUILanguage: string; |
| // TODO(b/263824661): Remove undefined from these definitions if we do not |
| // share this file with Chrome browser. |
| /** Always defined on CrOS. */ |
| supportedInputMethods: (chrome.languageSettingsPrivate.InputMethod[]| |
| undefined); |
| /** Always defined on CrOS. */ |
| currentInputMethodId: (string|undefined); |
| } |
| |
| /** |
| * Singleton element that generates the languages model on start-up and |
| * updates it whenever Chrome's pref store and other settings change. |
| */ |
| const SettingsLanguagesElementBase = PrefsMixin(PolymerElement); |
| |
| export class SettingsLanguagesElement extends SettingsLanguagesElementBase |
| implements LanguageHelper { |
| static get is() { |
| return 'settings-languages' as const; |
| } |
| |
| static get properties() { |
| return { |
| languages: { |
| type: Object, |
| notify: true, |
| // TODO(b/238031866): Remove readOnly here and set `this.languages` with |
| // an assignment instead of a `this._setProperty`. See |
| // https://crrev.com/c/3176181/comment/63b644b9_ee7ad7df/ for more |
| // details. |
| readOnly: true, |
| }, |
| |
| /** |
| * This element, as a LanguageHelper instance for API usage. |
| */ |
| languageHelper: { |
| type: Object, |
| notify: true, |
| readOnly: true, |
| value(this: SettingsLanguagesElement): LanguageHelper { |
| return this; |
| }, |
| }, |
| |
| /** |
| * PromiseResolver to be resolved when the singleton has been initialized. |
| */ |
| resolver_: { |
| type: Object, |
| value() { |
| return new PromiseResolver(); |
| }, |
| }, |
| |
| /** |
| * Hash map of supported languages by language codes for fast lookup. |
| */ |
| supportedLanguageMap_: { |
| type: Object, |
| value() { |
| return new Map(); |
| }, |
| }, |
| |
| /** |
| * Hash set of enabled language codes for membership testing. |
| */ |
| enabledLanguageSet_: { |
| type: Object, |
| value() { |
| return new Set(); |
| }, |
| }, |
| |
| /** |
| * Hash map of supported input methods by ID for fast lookup. |
| */ |
| supportedInputMethodMap_: { |
| type: Object, |
| value() { |
| return new Map(); |
| }, |
| }, |
| |
| /** |
| * Hash map of input methods supported for each language. |
| */ |
| languageInputMethods_: { |
| type: Object, |
| value() { |
| return new Map(); |
| }, |
| }, |
| |
| /** |
| * Hash set of enabled input methods id for mebership testings |
| */ |
| enabledInputMethodSet_: { |
| type: Object, |
| value() { |
| return new Set(); |
| }, |
| }, |
| |
| /** Prospective UI language when the page was loaded. */ |
| originalProspectiveUILanguage_: String, |
| }; |
| } |
| |
| static get observers() { |
| return [ |
| // All observers wait for the model to be populated by including the |
| // |languages| property. |
| 'alwaysTranslateLanguagesPrefChanged_(' + |
| 'prefs.translate_allowlists.value.*, languages)', |
| 'neverTranslateLanguagesPrefChanged_(' + |
| 'prefs.translate_blocked_languages.value.*, languages)', |
| 'prospectiveUiLanguageChanged_(prefs.intl.app_locale.value, languages)', |
| 'preferredLanguagesPrefChanged_(' + |
| 'prefs.intl.accept_languages.value, languages)', |
| 'preferredLanguagesPrefChanged_(' + |
| 'prefs.intl.forced_languages.value.*, languages)', |
| 'spellCheckDictionariesPrefChanged_(' + |
| 'prefs.spellcheck.dictionaries.value.*, ' + |
| 'prefs.spellcheck.forced_dictionaries.value.*, ' + |
| 'prefs.spellcheck.blocked_dictionaries.value.*, languages)', |
| 'translateLanguagesPrefChanged_(' + |
| 'prefs.translate_blocked_languages.value.*, languages)', |
| 'translateTargetPrefChanged_(' + |
| 'prefs.translate_recent_target.value, languages)', |
| 'updateRemovableLanguages_(' + |
| 'prefs.intl.app_locale.value, languages.enabled)', |
| 'updateRemovableLanguages_(' + |
| 'prefs.translate_blocked_languages.value.*)', |
| // Observe Chrome OS prefs (ignored for non-Chrome OS). |
| 'updateRemovableLanguages_(' + |
| 'prefs.settings.language.preload_engines.value, ' + |
| 'prefs.settings.language.enabled_extension_imes.value, ' + |
| 'languages)', |
| ]; |
| } |
| |
| // Public API: Bidirectional data flow. |
| // override prefs: any; // From PrefsMixin. |
| |
| // Public API: Upwards data flow. |
| languages?: LanguagesModel; |
| languageHelper: LanguageHelper; |
| |
| // API proxies. |
| private browserProxy_: LanguagesBrowserProxy = |
| LanguagesBrowserProxyImpl.getInstance(); |
| private languageSettingsPrivate_: typeof chrome.languageSettingsPrivate = |
| this.browserProxy_.getLanguageSettingsPrivate(); |
| private inputMethodPrivate_: typeof chrome.inputMethodPrivate = |
| this.browserProxy_.getInputMethodPrivate(); |
| |
| // Internal state. |
| private resolver_: PromiseResolver<undefined>; |
| private supportedLanguageMap_: |
| Map<string, chrome.languageSettingsPrivate.Language>; |
| private enabledLanguageSet_: Set<string>; |
| private supportedInputMethodMap_: |
| Map<string, chrome.languageSettingsPrivate.InputMethod>; |
| private languageInputMethods_: |
| Map<string, chrome.languageSettingsPrivate.InputMethod[]>; |
| private enabledInputMethodSet_: Set<string>; |
| private originalProspectiveUILanguage_?: string; |
| |
| // Bound methods. |
| // Instances of SettingsLanguagesElement below should be replaced with |
| // (typeof this) due to possible subclasses of SettingsLanguagesElement |
| // replacing these methods with a Liskov substitution principle-compatible |
| // method. However, that type is too complicated for TypeScript to check (it |
| // results in incorrect type errors), and we don't expect there to be any |
| // subclasses. |
| private boundOnSpellcheckDictionariesChanged_: OmitThisParameter< |
| SettingsLanguagesElement['onSpellcheckDictionariesChanged_']>|null = null; |
| private boundOnInputMethodAdded_: |
| OmitThisParameter<SettingsLanguagesElement['onInputMethodAdded_']>|null = |
| null; |
| private boundOnInputMethodRemoved_: |
| OmitThisParameter<SettingsLanguagesElement['onInputMethodRemoved_']>| |
| null = null; |
| private boundOnInputMethodChanged_: |
| OmitThisParameter<SettingsLanguagesElement['onInputMethodChanged_']>| |
| null = null; |
| private boundOnLanguagePackStatusChanged_: OmitThisParameter< |
| SettingsLanguagesElement['onLanguagePackStatusChanged_']>|null = null; |
| |
| // loadTimeData flags. |
| // We do not expect this to change over the lifetime of this element, so this |
| // is not included in `properties()` above. |
| private languagePacksInSettingsEnabled_ = |
| loadTimeData.getBoolean('languagePacksInSettingsEnabled'); |
| |
| override connectedCallback(): void { |
| super.connectedCallback(); |
| |
| const promises = []; |
| |
| /** |
| * An object passed into createModel to keep track of platform-specific |
| * arguments, populated by the "promises" array. |
| */ |
| const args: ModelArgs = { |
| supportedLanguages: [], |
| translateTarget: '', |
| alwaysTranslateCodes: [], |
| neverTranslateCodes: [], |
| startingUILanguage: '', |
| |
| supportedInputMethods: [], |
| currentInputMethodId: '', |
| }; |
| |
| // Wait until prefs are initialized before creating the model, so we can |
| // include information about enabled languages. |
| promises.push(CrSettingsPrefs.initialized); |
| |
| // Get the language list. |
| promises.push(this.languageSettingsPrivate_.getLanguageList().then( |
| result => args.supportedLanguages = result)); |
| |
| // Get the translate target language. |
| promises.push( |
| this.languageSettingsPrivate_.getTranslateTargetLanguage().then( |
| result => args.translateTarget = result)); |
| |
| promises.push(this.languageSettingsPrivate_.getInputMethodLists().then( |
| lists => args.supportedInputMethods = |
| lists.componentExtensionImes.concat( |
| lists.thirdPartyExtensionImes))); |
| |
| promises.push(this.inputMethodPrivate_.getCurrentInputMethod().then( |
| result => args.currentInputMethodId = result)); |
| |
| // Get the list of language-codes to always translate. |
| promises.push( |
| this.languageSettingsPrivate_.getAlwaysTranslateLanguages().then( |
| result => args.alwaysTranslateCodes = result)); |
| |
| // Get the list of language-codes to never translate. |
| promises.push( |
| this.languageSettingsPrivate_.getNeverTranslateLanguages().then( |
| result => args.neverTranslateCodes = result)); |
| |
| // Fetch the starting UI language, which affects which actions should be |
| // enabled. |
| promises.push(this.browserProxy_.getProspectiveUiLanguage().then( |
| prospectiveUILanguage => { |
| this.originalProspectiveUILanguage_ = |
| prospectiveUILanguage || window.navigator.language; |
| })); |
| |
| Promise.all(promises).then(() => { |
| if (!this.isConnected) { |
| // Return early if this element was detached from the DOM before |
| // this async callback executes (can happen during testing). |
| return; |
| } |
| |
| this.createModel_(args); |
| |
| this.boundOnSpellcheckDictionariesChanged_ = |
| this.onSpellcheckDictionariesChanged_.bind(this); |
| this.languageSettingsPrivate_.onSpellcheckDictionariesChanged.addListener( |
| this.boundOnSpellcheckDictionariesChanged_); |
| this.languageSettingsPrivate_.getSpellcheckDictionaryStatuses().then( |
| this.boundOnSpellcheckDictionariesChanged_); |
| |
| if (this.languagePacksInSettingsEnabled_) { |
| // Get the initial state of language pack statuses. |
| // Do so in the next microtask to prevent `connectedCallback()` from |
| // failing and stalling tests. |
| Promise.resolve().then(() => this.fetchMissingLanguagePackStatuses_()); |
| this.boundOnLanguagePackStatusChanged_ = |
| this.onLanguagePackStatusChanged_.bind(this); |
| this.inputMethodPrivate_.onLanguagePackStatusChanged.addListener( |
| this.boundOnLanguagePackStatusChanged_); |
| } |
| |
| this.resolver_.resolve(undefined); |
| }); |
| |
| this.boundOnInputMethodChanged_ = this.onInputMethodChanged_.bind(this); |
| this.inputMethodPrivate_.onChanged.addListener( |
| this.boundOnInputMethodChanged_); |
| this.boundOnInputMethodAdded_ = this.onInputMethodAdded_.bind(this); |
| this.languageSettingsPrivate_.onInputMethodAdded.addListener( |
| this.boundOnInputMethodAdded_); |
| this.boundOnInputMethodRemoved_ = this.onInputMethodRemoved_.bind(this); |
| this.languageSettingsPrivate_.onInputMethodRemoved.addListener( |
| this.boundOnInputMethodRemoved_); |
| } |
| |
| override disconnectedCallback(): void { |
| super.disconnectedCallback(); |
| |
| // Safety: All bound methods here were set in `connectedCallback`, |
| // which is guaranteed to be run before `disconnectedCallback`. |
| this.inputMethodPrivate_.onChanged.removeListener( |
| castExists(this.boundOnInputMethodChanged_)); |
| this.boundOnInputMethodChanged_ = null; |
| this.languageSettingsPrivate_.onInputMethodAdded.removeListener( |
| castExists(this.boundOnInputMethodAdded_)); |
| this.boundOnInputMethodAdded_ = null; |
| this.languageSettingsPrivate_.onInputMethodRemoved.removeListener( |
| castExists(this.boundOnInputMethodRemoved_)); |
| this.boundOnInputMethodRemoved_ = null; |
| |
| if (this.boundOnSpellcheckDictionariesChanged_) { |
| this.languageSettingsPrivate_.onSpellcheckDictionariesChanged |
| .removeListener(this.boundOnSpellcheckDictionariesChanged_); |
| this.boundOnSpellcheckDictionariesChanged_ = null; |
| } |
| if (this.boundOnLanguagePackStatusChanged_) { |
| this.inputMethodPrivate_.onLanguagePackStatusChanged.removeListener( |
| this.boundOnLanguagePackStatusChanged_); |
| this.boundOnLanguagePackStatusChanged_ = null; |
| } |
| } |
| |
| /** |
| * Updates the prospective UI language based on the new pref value. |
| */ |
| private prospectiveUiLanguageChanged_(prospectiveUILanguage: string): void { |
| this.set( |
| 'languages.prospectiveUILanguage', |
| prospectiveUILanguage || this.originalProspectiveUILanguage_); |
| } |
| |
| /** |
| * Updates the list of enabled languages from the preferred languages pref. |
| */ |
| private preferredLanguagesPrefChanged_(): void { |
| if (this.prefs === undefined || this.languages === undefined) { |
| return; |
| } |
| |
| const enabledLanguageStates = this.getEnabledLanguageStates_( |
| this.languages.translateTarget, this.languages.prospectiveUILanguage); |
| |
| // Recreate the enabled language set before updating languages.enabled. |
| this.enabledLanguageSet_.clear(); |
| for (const enabledLanguageState of enabledLanguageStates) { |
| this.enabledLanguageSet_.add(enabledLanguageState.language.code); |
| } |
| |
| this.set('languages.enabled', enabledLanguageStates); |
| |
| if (this.boundOnSpellcheckDictionariesChanged_) { |
| this.languageSettingsPrivate_.getSpellcheckDictionaryStatuses().then( |
| this.boundOnSpellcheckDictionariesChanged_); |
| } |
| |
| // Update translate target language. |
| this.languageSettingsPrivate_.getTranslateTargetLanguage().then(result => { |
| this.set('languages.translateTarget', result); |
| }); |
| } |
| |
| /** |
| * Updates the spellCheckEnabled state of each enabled language. |
| */ |
| private spellCheckDictionariesPrefChanged_(): void { |
| if (this.prefs === undefined || this.languages === undefined) { |
| return; |
| } |
| |
| const spellCheckSet = this.makeSetFromArray_( |
| this.getPref<string[]>('spellcheck.dictionaries').value); |
| const spellCheckForcedSet = this.makeSetFromArray_( |
| this.getPref<string[]>('spellcheck.forced_dictionaries').value); |
| const spellCheckBlockedSet = this.makeSetFromArray_( |
| this.getPref<string[]>('spellcheck.blocked_dictionaries').value); |
| |
| for (const [i, languageState] of this.languages.enabled.entries()) { |
| const isUser = spellCheckSet.has(languageState.language.code); |
| const isForced = spellCheckForcedSet.has(languageState.language.code); |
| const isBlocked = spellCheckBlockedSet.has(languageState.language.code); |
| this.set( |
| `languages.enabled.${i}.spellCheckEnabled`, |
| (isUser && !isBlocked) || isForced); |
| this.set(`languages.enabled.${i}.isManaged`, isForced || isBlocked); |
| } |
| |
| const {on: spellCheckOnLanguages, off: spellCheckOffLanguages} = |
| this.getSpellCheckLanguages_(this.languages.supported); |
| this.set('languages.spellCheckOnLanguages', spellCheckOnLanguages); |
| this.set('languages.spellCheckOffLanguages', spellCheckOffLanguages); |
| } |
| |
| /** |
| * Returns two arrays of SpellCheckLanguageStates for spell check languages: |
| * one for spell check on, one for spell check off. |
| * @param supportedLanguages The list of supported languages, normally |
| * this.languages.supported. |
| */ |
| private getSpellCheckLanguages_( |
| supportedLanguages: chrome.languageSettingsPrivate.Language[]): |
| {on: SpellCheckLanguageState[], off: SpellCheckLanguageState[]} { |
| // The spell check preferences are prioritised in this order: |
| // forced_dictionaries, blocked_dictionaries, dictionaries. |
| |
| // The set of all language codes seen thus far. |
| const seenCodes = new Set<string>(); |
| |
| /** |
| * Gets the list of language codes indicated by the preference name, and |
| * de-duplicates it with all other language codes. |
| */ |
| const getPrefAndDedupe = (prefName: string): string[] => { |
| const result = |
| this.getPref<string[]>(prefName).value.filter(x => !seenCodes.has(x)); |
| result.forEach(code => seenCodes.add(code)); |
| return result; |
| }; |
| |
| const forcedCodes = getPrefAndDedupe('spellcheck.forced_dictionaries'); |
| const forcedCodesSet = new Set(forcedCodes); |
| const blockedCodes = getPrefAndDedupe('spellcheck.blocked_dictionaries'); |
| const blockedCodesSet = new Set(blockedCodes); |
| const enabledCodes = getPrefAndDedupe('spellcheck.dictionaries'); |
| |
| const on: SpellCheckLanguageState[] = []; |
| // We want to add newly enabled languages to the end of the "on" list, so we |
| // should explicitly move the forced languages to the front of the list. |
| for (const code of [...forcedCodes, ...enabledCodes]) { |
| const language = this.supportedLanguageMap_.get(code); |
| // language could be undefined if code is not in supportedLanguageMap_. |
| // This should be rare, but could happen if supportedLanguageMap_ is |
| // missing languages or the prefs are manually modified. We want to fail |
| // gracefully if this happens - throwing an error here would cause |
| // language settings to not load. |
| if (language) { |
| on.push({ |
| language, |
| isManaged: forcedCodesSet.has(code), |
| spellCheckEnabled: true, |
| downloadDictionaryStatus: null, |
| downloadDictionaryFailureCount: 0, |
| }); |
| } |
| } |
| |
| // Because the list of "spell check supported" languages is only exposed |
| // through "supported languages", we need to filter that list along with |
| // whether we've seen the language before. |
| // We don't want to split this list in "forced" / "not-forced" like the |
| // spell check on list above, as we don't want to explicitly surface / hide |
| // blocked languages to the user. |
| const off: SpellCheckLanguageState[] = []; |
| |
| for (const language of supportedLanguages) { |
| // If spell check is off for this language, it must either not be in any |
| // spell check pref, or be in the blocked dictionaries pref. |
| if (language.supportsSpellcheck && |
| (!seenCodes.has(language.code) || |
| blockedCodesSet.has(language.code))) { |
| off.push({ |
| language, |
| isManaged: blockedCodesSet.has(language.code), |
| spellCheckEnabled: false, |
| downloadDictionaryStatus: null, |
| downloadDictionaryFailureCount: 0, |
| }); |
| } |
| } |
| |
| return { |
| on, |
| off, |
| }; |
| } |
| |
| /** |
| * Updates the list of always translate languages from translate prefs. |
| */ |
| private alwaysTranslateLanguagesPrefChanged_(): void { |
| if (this.prefs === undefined || this.languages === undefined) { |
| return; |
| } |
| const alwaysTranslateCodes = Object.keys( |
| this.getPref<Record<string, string>>('translate_allowlists').value); |
| const alwaysTranslateLanguages = |
| // This `getLanguage` assertion is potentially unsafe and could fail. |
| // TODO(b/265554088): Prove that this assertion is safe, or rewrite this |
| // to avoid this assertion. |
| alwaysTranslateCodes.map(code => this.getLanguage(code)!); |
| this.set('languages.alwaysTranslate', alwaysTranslateLanguages); |
| } |
| |
| /** |
| * Updates the list of never translate languages from translate prefs. |
| */ |
| private neverTranslateLanguagesPrefChanged_(): void { |
| if (this.prefs === undefined || this.languages === undefined) { |
| return; |
| } |
| const neverTranslateCodes = |
| this.getPref<string[]>('translate_blocked_languages').value; |
| const neverTranslateLanguages = |
| // This `getLanguage` assertion is potentially unsafe and could fail. |
| // TODO(b/265554088): Prove that this assertion is safe, or rewrite this |
| // to avoid this assertion. |
| neverTranslateCodes.map(code => this.getLanguage(code)!); |
| this.set('languages.neverTranslate', neverTranslateLanguages); |
| } |
| |
| private translateLanguagesPrefChanged_(): void { |
| if (this.prefs === undefined || this.languages === undefined) { |
| return; |
| } |
| |
| const translateBlockedPref = |
| this.getPref<string[]>('translate_blocked_languages'); |
| const translateBlockedSet = |
| this.makeSetFromArray_(translateBlockedPref.value); |
| |
| for (const [i, languageState] of this.languages.enabled.entries()) { |
| const language = languageState.language; |
| const translateEnabled = this.isTranslateEnabled_( |
| language.code, !!language.supportsTranslate, translateBlockedSet, |
| this.languages.translateTarget, this.languages.prospectiveUILanguage); |
| this.set( |
| 'languages.enabled.' + i + '.translateEnabled', translateEnabled); |
| } |
| } |
| |
| private translateTargetPrefChanged_(): void { |
| if (this.prefs === undefined || this.languages === undefined) { |
| return; |
| } |
| this.set( |
| 'languages.translateTarget', |
| this.getPref('translate_recent_target').value); |
| } |
| |
| /** |
| * Constructs the languages model. |
| * @param args used to populate the model above. |
| */ |
| private createModel_(args: ModelArgs): void { |
| // Populate the hash map of supported languages. |
| for (const language of args.supportedLanguages) { |
| language.supportsUI = !!language.supportsUI; |
| language.supportsTranslate = !!language.supportsTranslate; |
| language.supportsSpellcheck = !!language.supportsSpellcheck; |
| language.isProhibitedLanguage = !!language.isProhibitedLanguage; |
| this.supportedLanguageMap_.set(language.code, language); |
| } |
| |
| // The below getPref call should always be defined, so the |
| // `this.originalProspectiveUILanguage_` part of this expression is |
| // redundant. |
| // TODO(b/238031866): Investigate why we have two ways of getting the |
| // prospective UI language, and simplify this expression if necessary. |
| const prospectiveUILanguage = |
| this.getPref<string>('intl.app_locale').value || |
| // Safety: This method is only called after all the promises |
| // in `connectedCallback()` have resolved, which includes a promise |
| // which sets `this.originalProspectiveUILanguage_`. |
| // TODO(b/238031866): Move this variable to `ModelArgs` to avoid this |
| // assertion. |
| this.originalProspectiveUILanguage_!; |
| |
| // Create a list of enabled languages from the supported languages. |
| const enabledLanguageStates = this.getEnabledLanguageStates_( |
| args.translateTarget, prospectiveUILanguage); |
| // Populate the hash set of enabled languages. |
| for (const enabledLanguageState of enabledLanguageStates) { |
| this.enabledLanguageSet_.add(enabledLanguageState.language.code); |
| } |
| |
| const {on: spellCheckOnLanguages, off: spellCheckOffLanguages} = |
| this.getSpellCheckLanguages_(args.supportedLanguages); |
| |
| const alwaysTranslateLanguages = |
| // This `getLanguage` assertion is potentially unsafe and could fail. |
| // TODO(b/265554088): Prove that this assertion is safe, or rewrite this |
| // to avoid this assertion. |
| args.alwaysTranslateCodes.map(code => this.getLanguage(code)!); |
| |
| const neverTranslateLangauges = |
| // This `getLanguage` assertion is potentially unsafe and could fail. |
| // TODO(b/265554088): Prove that this assertion is safe, or rewrite this |
| // to avoid this assertion. |
| args.neverTranslateCodes.map(code => this.getLanguage(code)!); |
| |
| // TODO(b/238031866): Remove the use of Partial here. |
| const model: Partial<LanguagesModel> = { |
| supported: args.supportedLanguages, |
| enabled: enabledLanguageStates, |
| translateTarget: args.translateTarget, |
| alwaysTranslate: alwaysTranslateLanguages, |
| neverTranslate: neverTranslateLangauges, |
| spellCheckOnLanguages, |
| spellCheckOffLanguages, |
| }; |
| |
| model.prospectiveUILanguage = prospectiveUILanguage; |
| |
| if (args.supportedInputMethods) { |
| this.createInputMethodModel_(args.supportedInputMethods); |
| } |
| model.inputMethods = { |
| // Safety: `ModelArgs.supportedInputMethods` is always defined on CrOS. |
| supported: args.supportedInputMethods!, |
| enabled: this.getEnabledInputMethods_(), |
| // Safety: `ModelArgs.currentInputMethodId` is always defined on CrOS. |
| currentId: args.currentInputMethodId!, |
| imeLanguagePackStatus: {}, |
| }; |
| |
| // Initialize the Polymer languages model. |
| // Safety: All properties of `LanguagesModel` were set above. |
| this._setProperty('languages', model as LanguagesModel); |
| } |
| |
| /** |
| * Returns a list of LanguageStates for each enabled language in the supported |
| * languages list. |
| * This must be called after `whenReady()` is resolved. |
| * @param translateTarget Language code of the default translate |
| * target language. |
| * @param prospectiveUILanguage Prospective UI display |
| * language. Only defined on Windows and Chrome OS. |
| */ |
| private getEnabledLanguageStates_( |
| translateTarget: string, |
| prospectiveUILanguage: (string|undefined)): LanguageState[] { |
| // Safety: Enforced in documentation. |
| assert(CrSettingsPrefs.isInitialized); |
| |
| const pref = this.getPref<string>('intl.accept_languages'); |
| const enabledLanguageCodes = pref.value.split(','); |
| const languagesForcedPref = this.getPref<string[]>('intl.forced_languages'); |
| const spellCheckPref = this.getPref<string[]>('spellcheck.dictionaries'); |
| const spellCheckForcedPref = |
| this.getPref<string[]>('spellcheck.forced_dictionaries'); |
| const spellCheckBlockedPref = |
| this.getPref<string[]>('spellcheck.blocked_dictionaries'); |
| const languageForcedSet = this.makeSetFromArray_(languagesForcedPref.value); |
| const spellCheckSet = this.makeSetFromArray_( |
| (spellCheckPref.value.concat(spellCheckForcedPref.value))); |
| const spellCheckForcedSet = |
| this.makeSetFromArray_(spellCheckForcedPref.value); |
| const spellCheckBlockedSet = |
| this.makeSetFromArray_(spellCheckBlockedPref.value); |
| |
| const translateBlockedPref = |
| this.getPref<string[]>('translate_blocked_languages'); |
| const translateBlockedSet = |
| this.makeSetFromArray_(translateBlockedPref.value); |
| |
| const enabledLanguageStates: LanguageState[] = []; |
| |
| for (const code of enabledLanguageCodes) { |
| const language = this.supportedLanguageMap_.get(code); |
| // Skip unsupported languages. |
| if (!language) { |
| continue; |
| } |
| // TODO(b/238031866): Remove the use of Partial here. |
| const languageState: Partial<LanguageState> = {}; |
| languageState.language = language; |
| languageState.spellCheckEnabled = |
| spellCheckSet.has(code) && !spellCheckBlockedSet.has(code) || |
| spellCheckForcedSet.has(code); |
| languageState.translateEnabled = this.isTranslateEnabled_( |
| code, !!language.supportsTranslate, translateBlockedSet, |
| translateTarget, prospectiveUILanguage); |
| languageState.isManaged = |
| spellCheckForcedSet.has(code) || spellCheckBlockedSet.has(code); |
| languageState.isForced = languageForcedSet.has(code); |
| languageState.downloadDictionaryFailureCount = 0; |
| // This cast is very unsafe as `downloadDictionaryStatus` and `removable` |
| // have not been set. |
| // TODO(b/265554105): Investigate and remove this cast if possible. |
| enabledLanguageStates.push(languageState as LanguageState); |
| } |
| return enabledLanguageStates; |
| } |
| |
| /** |
| * True iff we translate pages that are in the given language. |
| * @param code Language code. |
| * @param supportsTranslate If translation supports the given language. |
| * @param translateBlockedSet Set of languages for which translation is |
| * blocked. |
| * @param translateTarget Language code of the default translate target |
| * language. |
| * @param prospectiveUILanguage Prospective UI display language. Only defined |
| * on Windows and Chrome OS. |
| */ |
| private isTranslateEnabled_( |
| code: string, supportsTranslate: boolean, |
| translateBlockedSet: Set<string>, translateTarget: string, |
| prospectiveUILanguage: (string|undefined)): boolean { |
| const translateCode = this.convertLanguageCodeForTranslate(code); |
| return supportsTranslate && !translateBlockedSet.has(translateCode) && |
| translateCode !== translateTarget && |
| (!prospectiveUILanguage || code !== prospectiveUILanguage); |
| } |
| |
| /** |
| * Updates the dictionary download status for spell check languages in order |
| * to track the number of times a spell check dictionary download has failed. |
| */ |
| private onSpellcheckDictionariesChanged_( |
| statuses: chrome.languageSettingsPrivate.SpellcheckDictionaryStatus[]): |
| void { |
| const statusMap = new Map< |
| string, chrome.languageSettingsPrivate.SpellcheckDictionaryStatus>(); |
| statuses.forEach(status => { |
| statusMap.set(status.languageCode, status); |
| }); |
| |
| const collectionNames = |
| ['enabled', 'spellCheckOnLanguages', 'spellCheckOffLanguages'] as const; |
| for (const collectionName of collectionNames) { |
| // This assertion of `this.languages` is potentially unsafe and could |
| // fail. |
| // TODO(b/265553377): Prove that this assertion is safe, or rewrite this |
| // to avoid this assertion. |
| this.languages![collectionName].forEach((languageState, index) => { |
| const status = statusMap.get(languageState.language.code); |
| if (!status) { |
| return; |
| } |
| |
| const previousStatus = languageState.downloadDictionaryStatus; |
| const keyPrefix = `languages.${collectionName}.${index}`; |
| this.set(`${keyPrefix}.downloadDictionaryStatus`, status); |
| |
| const failureCountKey = `${keyPrefix}.downloadDictionaryFailureCount`; |
| if (status.downloadFailed && |
| !(previousStatus && previousStatus.downloadFailed)) { |
| const failureCount = languageState.downloadDictionaryFailureCount + 1; |
| this.set(failureCountKey, failureCount); |
| } else if ( |
| status.isReady && !(previousStatus && previousStatus.isReady)) { |
| this.set(failureCountKey, 0); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Updates the |removable| property of the enabled language states based |
| * on what other languages and input methods are enabled. |
| */ |
| private updateRemovableLanguages_(): void { |
| if (this.prefs === undefined || this.languages === undefined) { |
| return; |
| } |
| |
| // TODO(michaelpg): Enabled input methods can affect which languages are |
| // removable, so run updateEnabledInputMethods_ first (if it has been |
| // scheduled). |
| this.updateEnabledInputMethods_(); |
| |
| for (const [i, languageState] of this.languages.enabled.entries()) { |
| this.set( |
| 'languages.enabled.' + i + '.removable', |
| this.canDisableLanguage(languageState)); |
| } |
| } |
| |
| /** |
| * Creates a Set from the elements of the array. |
| */ |
| private makeSetFromArray_<T>(list: T[]): Set<T> { |
| // TODO(b/238031866): Inline these calls. |
| return new Set(list); |
| } |
| |
| // LanguageHelper implementation. |
| // TODO(michaelpg): replace duplicate docs with @override once b/24294625 |
| // is fixed. |
| whenReady(): Promise<void> { |
| return this.resolver_.promise; |
| } |
| |
| /** |
| * Sets the prospective UI language to the chosen language. This won't affect |
| * the actual UI language until a restart. |
| */ |
| setProspectiveUiLanguage(languageCode: string): void { |
| this.browserProxy_.setProspectiveUiLanguage(languageCode); |
| } |
| |
| /** |
| * True if the prospective UI language was changed from its starting value. |
| */ |
| // TODO(b/263824661): Remove this unused method if we do not share this file |
| // with browser settings. |
| requiresRestart(): boolean { |
| return this.originalProspectiveUILanguage_ !== |
| // This assertion of `this.languages` is potentially unsafe and could |
| // fail. |
| // TODO(b/265553377): Prove that this assertion is safe, or rewrite this |
| // to avoid this assertion. |
| this.languages!.prospectiveUILanguage; |
| } |
| |
| /** |
| * @return The language code for ARC IMEs. |
| */ |
| getArcImeLanguageCode(): string { |
| return kArcImeLanguage; |
| } |
| |
| /** |
| * @return True if the language is for ARC IMEs. |
| */ |
| isLanguageCodeForArcIme(languageCode: string): boolean { |
| return languageCode === kArcImeLanguage; |
| } |
| |
| /** |
| * @return True if the language can be translated by Chrome. |
| */ |
| isLanguageTranslatable(language: chrome.languageSettingsPrivate.Language): |
| boolean { |
| if (language.code === 'zh-CN' || language.code === 'zh-TW') { |
| // In Translate, general Chinese is not used, and the sub code is |
| // necessary as a language code for the Translate server. |
| return true; |
| } |
| if (language.code === this.getLanguageCodeWithoutRegion(language.code) && |
| language.supportsTranslate) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * @return True if the language is enabled. |
| */ |
| isLanguageEnabled(languageCode: string): boolean { |
| return this.enabledLanguageSet_.has(languageCode); |
| } |
| |
| /** |
| * Enables the language, making it available for spell check and input. |
| */ |
| enableLanguage(languageCode: string): void { |
| if (!CrSettingsPrefs.isInitialized) { |
| return; |
| } |
| |
| this.languageSettingsPrivate_.enableLanguage(languageCode); |
| } |
| |
| /** |
| * Disables the language. |
| */ |
| disableLanguage(languageCode: string): void { |
| if (!CrSettingsPrefs.isInitialized) { |
| return; |
| } |
| |
| // Chrome Browser removes the web language from spell check, as web |
| // languages and spell check languages are coupled. |
| // On ChromeOS, we decouple web languages and spell check languages, so |
| // we intentionally omit this behaviour. |
| |
| // Remove the language from preferred languages. |
| this.languageSettingsPrivate_.disableLanguage(languageCode); |
| } |
| |
| isOnlyTranslateBlockedLanguage(languageState: LanguageState): boolean { |
| return !languageState.translateEnabled && |
| // This assertion of `this.languages` is potentially unsafe and could |
| // fail. |
| // TODO(b/265553377): Prove that this assertion is safe, or rewrite this |
| // to avoid this assertion. |
| this.languages!.enabled.filter(lang => !lang.translateEnabled) |
| .length === 1; |
| } |
| |
| canDisableLanguage(languageState: LanguageState): boolean { |
| // Cannot disable the only enabled language. |
| // This assertion of `this.languages` is potentially unsafe and could fail. |
| // TODO(b/265553377): Prove that this assertion is safe, or rewrite this to |
| // avoid this assertion. |
| if (this.languages!.enabled.length === 1) { |
| return false; |
| } |
| |
| // Cannot disable the last translate blocked language. |
| if (this.isOnlyTranslateBlockedLanguage(languageState)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * @return true if the given language can be enabled |
| */ |
| canEnableLanguage(language: chrome.languageSettingsPrivate.Language): |
| boolean { |
| return !( |
| this.isLanguageEnabled(language.code) || |
| language.isProhibitedLanguage || |
| this.isLanguageCodeForArcIme(language.code) /* internal use only */); |
| } |
| |
| /** |
| * Sets whether a given language should always be automatically translated. |
| */ |
| setLanguageAlwaysTranslateState( |
| languageCode: string, alwaysTranslate: boolean): void { |
| this.languageSettingsPrivate_.setLanguageAlwaysTranslateState( |
| languageCode, alwaysTranslate); |
| } |
| |
| /** |
| * Moves the language in the list of enabled languages either up (toward the |
| * front of the list) or down (toward the back). |
| * @param upDirection True if we need to move up, false if we |
| * need to move down |
| */ |
| moveLanguage(languageCode: string, upDirection: boolean): void { |
| if (!CrSettingsPrefs.isInitialized) { |
| return; |
| } |
| |
| if (upDirection) { |
| this.languageSettingsPrivate_.moveLanguage(languageCode, MoveType.UP); |
| } else { |
| this.languageSettingsPrivate_.moveLanguage(languageCode, MoveType.DOWN); |
| } |
| } |
| |
| /** |
| * Moves the language directly to the front of the list of enabled languages. |
| */ |
| moveLanguageToFront(languageCode: string): void { |
| if (!CrSettingsPrefs.isInitialized) { |
| return; |
| } |
| |
| this.languageSettingsPrivate_.moveLanguage(languageCode, MoveType.TOP); |
| } |
| |
| /** |
| * Enables translate for the given language by removing the translate |
| * language from the blocked languages preference. |
| */ |
| enableTranslateLanguage(languageCode: string): void { |
| this.languageSettingsPrivate_.setEnableTranslationForLanguage( |
| languageCode, true); |
| } |
| |
| /** |
| * Disables translate for the given language by adding the translate |
| * language to the blocked languages preference. |
| */ |
| disableTranslateLanguage(languageCode: string): void { |
| this.languageSettingsPrivate_.setEnableTranslationForLanguage( |
| languageCode, false); |
| } |
| |
| /** |
| * Sets the translate target language and adds it to the content languages if |
| * not already there. |
| */ |
| setTranslateTargetLanguage(languageCode: string): void { |
| this.languageSettingsPrivate_.setTranslateTargetLanguage(languageCode); |
| } |
| |
| /** |
| * Enables or disables spell check for the given language. |
| */ |
| toggleSpellCheck(languageCode: string, enable: boolean): void { |
| if (!this.languages) { |
| return; |
| } |
| |
| if (enable) { |
| this.appendPrefListItem('spellcheck.dictionaries', languageCode); |
| } else { |
| this.deletePrefListItem('spellcheck.dictionaries', languageCode); |
| } |
| } |
| |
| /** |
| * Converts the language code for translate. There are some differences |
| * between the language set the Translate server uses and that for |
| * Accept-Language. |
| * @return The converted language code. |
| */ |
| convertLanguageCodeForTranslate(languageCode: string): string { |
| if (languageCode in kLanguageCodeToTranslateCode) { |
| // Work around https://github.com/microsoft/TypeScript/issues/21732. |
| // As of writing, it is marked as fixed by |
| // https://github.com/microsoft/TypeScript/pull/50666, but that PR does |
| // not address this specific issue of narrowing a `string` down to keys of |
| // an object. |
| type LanguageCode = keyof typeof kLanguageCodeToTranslateCode; |
| // Safety: We checked that languageCode is a key above. |
| return kLanguageCodeToTranslateCode[languageCode as LanguageCode]; |
| } |
| |
| const main = languageCode.split('-')[0]; |
| if (main === undefined) { |
| // The only time a split could return 0 items is if the string is empty. |
| throw new Error('languageCode cannot be empty'); |
| } |
| if (main === 'zh') { |
| // In Translate, general Chinese is not used, and the sub code is |
| // necessary as a language code for the Translate server. |
| return languageCode; |
| } |
| if (main in kTranslateLanguageSynonyms) { |
| type TranslateSynonymKey = keyof typeof kTranslateLanguageSynonyms; |
| // Safety: We checked that languageCode is a key above. |
| return kTranslateLanguageSynonyms[main as TranslateSynonymKey]; |
| } |
| |
| return main; |
| } |
| |
| /** |
| * Given a language code, returns just the base language. E.g., converts |
| * 'en-GB' to 'en'. |
| */ |
| getLanguageCodeWithoutRegion(languageCode: string): string { |
| // The Norwegian languages fall under the 'no' macrolanguage. |
| if (languageCode === 'nb' || languageCode === 'nn') { |
| return 'no'; |
| } |
| |
| // The installer still uses the old language code "iw", instead of "he", |
| // for Hebrew. It needs to be converted to "he", otherwise it will not be |
| // found in supportedLanguageMap_. |
| // |
| // Note that this value is saved in the user's local state. Even |
| // if the installer is changed to use "he", because the installer does not |
| // overwrite this value, the conversion is still needed for old users. |
| if (languageCode === 'iw') { |
| return 'he'; |
| } |
| |
| // Match the characters before the hyphen. |
| // This assertion is unsafe if `languageCode` is an empty string, or starts |
| // with a hyphen. |
| // TODO(b/265554105): Gracefully handle this case. |
| const result = languageCode.match(/^([^-]+)-?/)!; |
| // Safety: The regex above has one non-optional capturing group. |
| assert(result.length === 2); |
| return result[1]!; |
| } |
| |
| getLanguage(languageCode: string): chrome.languageSettingsPrivate.Language |
| |undefined { |
| // If a languageCode is not found, try language without location. |
| return this.supportedLanguageMap_.get(languageCode) || |
| this.supportedLanguageMap_.get( |
| this.getLanguageCodeWithoutRegion(languageCode)); |
| } |
| |
| /** |
| * Retries downloading the dictionary for |languageCode|. |
| */ |
| retryDownloadDictionary(languageCode: string): void { |
| this.languageSettingsPrivate_.retryDownloadDictionary(languageCode); |
| } |
| |
| /** |
| * Constructs the input method part of the languages model. |
| */ |
| private createInputMethodModel_( |
| supportedInputMethods: chrome.languageSettingsPrivate.InputMethod[]): |
| void { |
| // Populate the hash map of supported input methods. |
| this.supportedInputMethodMap_.clear(); |
| this.languageInputMethods_.clear(); |
| for (const inputMethod of supportedInputMethods) { |
| inputMethod.enabled = !!inputMethod.enabled; |
| inputMethod.isProhibitedByPolicy = !!inputMethod.isProhibitedByPolicy; |
| // Add the input method to the map of IDs. |
| this.supportedInputMethodMap_.set(inputMethod.id, inputMethod); |
| // Add the input method to the list of input methods for each language |
| // it supports. |
| for (const languageCode of inputMethod.languageCodes) { |
| if (!this.supportedLanguageMap_.has(languageCode)) { |
| continue; |
| } |
| const inputMethods = this.languageInputMethods_.get(languageCode); |
| if (inputMethods === undefined) { |
| this.languageInputMethods_.set(languageCode, [inputMethod]); |
| } else { |
| inputMethods.push(inputMethod); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns a list of enabled input methods. |
| * |
| * This must be called after `whenReady()` is resolved. |
| */ |
| private getEnabledInputMethods_(): |
| chrome.languageSettingsPrivate.InputMethod[] { |
| // Safety: Enforced in documentation. |
| assert(CrSettingsPrefs.isInitialized); |
| |
| let enabledInputMethodIds = |
| this.getPref<string>('settings.language.preload_engines') |
| .value.split(','); |
| enabledInputMethodIds = enabledInputMethodIds.concat( |
| this.getPref<string>('settings.language.enabled_extension_imes') |
| .value.split(',')); |
| this.enabledInputMethodSet_ = new Set(enabledInputMethodIds); |
| |
| // Return only supported input methods. Don't include the Dictation |
| // (Accessibility Common) input method. |
| return enabledInputMethodIds |
| .map(id => this.supportedInputMethodMap_.get(id)) |
| .filter( |
| <T>(inputMethod: T): inputMethod is NonNullable<T> => !!inputMethod) |
| .filter(inputMethod => inputMethod.id !== ACCESSIBILITY_COMMON_IME_ID); |
| } |
| |
| private async updateSupportedInputMethods_(): Promise<void> { |
| const lists = await this.languageSettingsPrivate_.getInputMethodLists(); |
| const supportedInputMethods = |
| lists.componentExtensionImes.concat(lists.thirdPartyExtensionImes); |
| this.createInputMethodModel_(supportedInputMethods); |
| // The two lines below are potentially unsafe and could fail, as they assume |
| // that `this.languages` is defined. |
| // TODO(b/265553377): Prove that this assertion is safe, or rewrite this to |
| // avoid this assertion. |
| this.set('languages.inputMethods.supported', supportedInputMethods); |
| this.updateEnabledInputMethods_(); |
| } |
| |
| private updateEnabledInputMethods_(): void { |
| const enabledInputMethods = this.getEnabledInputMethods_(); |
| const enabledInputMethodSet = this.makeSetFromArray_(enabledInputMethods); |
| |
| // This assertion of `this.languages` is potentially unsafe and could fail. |
| // TODO(b/265553377): Prove that this assertion is safe, or rewrite this to |
| // avoid this assertion. |
| // Safety: `LanguagesModel.inputMethods` is always defined on CrOS. |
| for (const [i, inputMethod] of this.languages!.inputMethods!.supported |
| .entries()) { |
| this.set( |
| 'languages.inputMethods.supported.' + i + '.enabled', |
| enabledInputMethodSet.has(inputMethod)); |
| } |
| this.set('languages.inputMethods.enabled', enabledInputMethods); |
| if (this.languagePacksInSettingsEnabled_) { |
| this.fetchMissingLanguagePackStatuses_(); |
| } |
| } |
| |
| addInputMethod(id: string): void { |
| if (!this.supportedInputMethodMap_.has(id)) { |
| return; |
| } |
| this.languageSettingsPrivate_.addInputMethod(id); |
| } |
| |
| removeInputMethod(id: string): void { |
| if (!this.supportedInputMethodMap_.has(id)) { |
| return; |
| } |
| this.languageSettingsPrivate_.removeInputMethod(id); |
| } |
| |
| setCurrentInputMethod(id: string): void { |
| this.inputMethodPrivate_.setCurrentInputMethod(id); |
| } |
| |
| getCurrentInputMethod(): Promise<string> { |
| return this.inputMethodPrivate_.getCurrentInputMethod(); |
| } |
| |
| getInputMethodsForLanguage(languageCode: string): |
| chrome.languageSettingsPrivate.InputMethod[] { |
| return this.languageInputMethods_.get(languageCode) || []; |
| } |
| |
| /** |
| * Returns the input methods that support any of the given languages. |
| */ |
| getInputMethodsForLanguages(languageCodes: string[]): |
| chrome.languageSettingsPrivate.InputMethod[] { |
| // Input methods that have already been listed for this language. |
| const usedInputMethods = new Set<string>(); |
| const combinedInputMethods: chrome.languageSettingsPrivate.InputMethod[] = |
| []; |
| for (const languageCode of languageCodes) { |
| const inputMethods = this.getInputMethodsForLanguage(languageCode); |
| // Get the language's unused input methods and mark them as used. |
| const newInputMethods = inputMethods.filter( |
| inputMethod => !usedInputMethods.has(inputMethod.id)); |
| newInputMethods.forEach( |
| inputMethod => usedInputMethods.add(inputMethod.id)); |
| combinedInputMethods.push(...newInputMethods); |
| } |
| return combinedInputMethods; |
| } |
| |
| /** |
| * @return list of enabled language code. |
| */ |
| getEnabledLanguageCodes(): Set<string> { |
| return this.enabledLanguageSet_; |
| } |
| |
| /** |
| * @param id the input method id |
| * @return True if the input method is enabled |
| */ |
| isInputMethodEnabled(id: string): boolean { |
| return this.enabledInputMethodSet_.has(id); |
| } |
| |
| isComponentIme(inputMethod: chrome.languageSettingsPrivate.InputMethod): |
| boolean { |
| return inputMethod.id.startsWith('_comp_'); |
| } |
| |
| /** @param id Input method ID. */ |
| openInputMethodOptions(id: string): void { |
| this.inputMethodPrivate_.openOptionsPage(id); |
| } |
| |
| /** @param id New current input method ID. */ |
| private onInputMethodChanged_(id: string): void { |
| this.set('languages.inputMethods.currentId', id); |
| } |
| |
| /** @param _id Added input method ID. */ |
| private onInputMethodAdded_(_id: string): void { |
| this.updateSupportedInputMethods_(); |
| } |
| |
| /** @param id Removed input method ID. */ |
| private onInputMethodRemoved_(_id: string): void { |
| this.updateSupportedInputMethods_(); |
| } |
| |
| /** |
| * @param id Input method ID. |
| */ |
| getInputMethodDisplayName(id: string): string { |
| const inputMethod = this.supportedInputMethodMap_.get(id); |
| if (inputMethod === undefined) { |
| return ''; |
| } |
| return inputMethod.displayName; |
| } |
| |
| private setLanguagePackStatus_( |
| id: string, status: chrome.inputMethodPrivate.LanguagePackStatus): void { |
| this.set( |
| ['languages', 'inputMethods', 'imeLanguagePackStatus', id], status); |
| } |
| |
| /** |
| * Fetch the language pack status of enabled input methods which we do not |
| * have a status for. |
| */ |
| private fetchMissingLanguagePackStatuses_(): void { |
| if (!this.languages) { |
| return; |
| } |
| // Safety: `LanguagesModel.inputMethods` is always defined on CrOS. |
| for (const inputMethod of this.languages.inputMethods!.enabled) { |
| if (this.languages.inputMethods!.imeLanguagePackStatus[inputMethod.id] === |
| undefined) { |
| // Explicitly set this input method status to unknown to prevent future |
| // calls of this method from fetching this again. |
| this.languages.inputMethods!.imeLanguagePackStatus[inputMethod.id] = |
| chrome.inputMethodPrivate.LanguagePackStatus.UNKNOWN; |
| |
| void this.inputMethodPrivate_.getLanguagePackStatus(inputMethod.id) |
| .then((status) => { |
| this.setLanguagePackStatus_(inputMethod.id, status); |
| }); |
| } |
| } |
| } |
| |
| private onLanguagePackStatusChanged_( |
| change: chrome.inputMethodPrivate.LanguagePackStatusChange): void { |
| for (const engineId of change.engineIds) { |
| this.setLanguagePackStatus_(engineId, change.status); |
| } |
| } |
| |
| getImeLanguagePackStatus(id: string): |
| chrome.inputMethodPrivate.LanguagePackStatus { |
| // Safety: `LanguagesModel.inputMethods` is always defined on CrOS. |
| return this.languages?.inputMethods!.imeLanguagePackStatus[id] ?? |
| chrome.inputMethodPrivate.LanguagePackStatus.UNKNOWN; |
| } |
| } |
| |
| customElements.define(SettingsLanguagesElement.is, SettingsLanguagesElement); |
| |
| declare global { |
| interface HTMLElementTagNameMap { |
| [SettingsLanguagesElement.is]: SettingsLanguagesElement; |
| } |
| } |
