Bugfix FXIOS-15303 [Translations Phase 2] Translation button doesn't appear when the primary device language isn't supported but a fallback language is (#32861)

* Fix translation button not shown when primary language lacks a model but a preferred fallback does

When the translationLanguagePicker flag is enabled, shouldOfferTranslation
now checks each preferred language in order and returns true on the first
available model pair, instead of only checking the primary device language.
The middleware builds the language list from the flag: a single device
language when the flag is OFF (no behavior change), or the full ordered
preferred list from PreferredTranslationLanguagesManager when ON.

* Fix SwiftLint line length violation in TranslationsMiddleware

* Fix SwiftLint closure body length violation in TranslationsMiddleware

* Inject PreferredTranslationLanguagesManager and LocaleProvider into TranslationsMiddleware

Author: razvanlitianu

firefox-ios/Client/Frontend/Translations/Service/TranslationsService.swift

@@ -29,21 +29,21 @@ final class TranslationsService: TranslationsServiceProtocol {
         self.logger = logger
     }
 
-    /// Determines whether translation should be offered to the user based on
-    /// the detected page language and the device locale.
-    func shouldOfferTranslation(for windowUUID: WindowUUID) async throws -> Bool {
-        // Throwing here to capture this case in telemetry. It shouldn't happen in practice.
-        guard let deviceLanguage = deviceLanguageCode() else {
-            throw TranslationsServiceError.deviceLanguageUnavailable
-        }
+    /// Determines whether translation should be offered by checking any of the given
+    /// preferred target languages against the detected page language.
+    /// Returns `true` if at least one preferred language has an available model pair.
+    /// NOTE: `fetchModels` inspects Remote Settings metadata and returns JSON data
+    /// describing the pipeline, it does not fetch large model attachments.
+    func shouldOfferTranslation(for windowUUID: WindowUUID, using preferredLanguages: [String]) async throws -> Bool {
+        guard !preferredLanguages.isEmpty else { return false }
         let pageLanguage = try await detectPageLanguage(for: windowUUID)
-        // Do not offer translations if device language is the same as detected page language.
-        guard pageLanguage != deviceLanguage else { return false }
-        // Only offer translation if we have a model pair (direct or via pivot).
-        // NOTE: `fetchModels` inspects Remote Settings metadata and returns JSON data
-        // describing the pipeline, it does not fetch large model attachments.
-        guard await modelsFetcher.fetchModels(from: pageLanguage, to: deviceLanguage) != nil else { return false }
-        return true
+        for language in preferredLanguages {
+            guard language != pageLanguage else { continue }
+            if await modelsFetcher.fetchModels(from: pageLanguage, to: language) != nil {
+                return true
+            }
+        }
+        return false
     }
 
     /// Initiates translation of the current page to the specified target language.

firefox-ios/Client/Frontend/Translations/Service/TranslationsServiceProtocol.swift

@@ -7,9 +7,10 @@ import Common
 /// A service responsible for coordinating in-page translations.
 @MainActor
 protocol TranslationsServiceProtocol {
-    /// Determines whether translation should be offered to the user based on
-    /// the detected page language and the device's current locale.
-    func shouldOfferTranslation(for windowUUID: WindowUUID) async throws -> Bool
+    /// Determines whether translation should be offered by checking any of the given
+    /// preferred target languages against the detected page language.
+    /// Returns `true` if at least one preferred language has an available model pair.
+    func shouldOfferTranslation(for windowUUID: WindowUUID, using preferredLanguages: [String]) async throws -> Bool
     /// Performs translation and returns immediately.
     /// TODO(FXIOS-14213): We should implement a lifecycle for the service similar to `SummarizerServiceLifecycle`.
     /// For now `onLanguageIdentified` is used to notify caller when language detection is done.

firefox-ios/Client/Frontend/Translations/TranslationsMiddleware.swift

@@ -14,6 +14,8 @@ final class TranslationsMiddleware: FeatureFlaggable {
     private let windowManager: WindowManager
     private let translationsService: TranslationsServiceProtocol
     private let translationsTelemetry: TranslationsTelemetryProtocol
+    private let manager: PreferredTranslationLanguagesManager
+    private let localeProvider: LocaleProvider
 
     /// Multiple windows can be open simultaneously, so we track IDs in a map.
     /// On iPhone, only a single window exists, so this will contain at most one entry.
@@ -33,13 +35,17 @@ final class TranslationsMiddleware: FeatureFlaggable {
          logger: Logger = DefaultLogger.shared,
          windowManager: WindowManager = AppContainer.shared.resolve(),
          translationsService: TranslationsServiceProtocol = TranslationsService(),
-         translationsTelemetry: TranslationsTelemetryProtocol = TranslationsTelemetry()
+         translationsTelemetry: TranslationsTelemetryProtocol = TranslationsTelemetry(),
+         manager: PreferredTranslationLanguagesManager? = nil,
+         localeProvider: LocaleProvider = SystemLocaleProvider()
     ) {
         self.profile = profile
         self.logger = logger
         self.windowManager = windowManager
         self.translationsService = translationsService
         self.translationsTelemetry = translationsTelemetry
+        self.manager = manager ?? PreferredTranslationLanguagesManager(prefs: profile.prefs)
+        self.localeProvider = localeProvider
     }
 
     lazy var translationsProvider: Middleware<AppState> = { state, action in
@@ -208,14 +214,30 @@ final class TranslationsMiddleware: FeatureFlaggable {
         return true
     }
 
+    /// Returns the list of target languages to check for translation eligibility.
+    /// When the language picker flag is ON, returns the user's full preferred list.
+    /// When OFF, returns only the primary device language (preserving legacy behavior).
+    private func targetLanguagesForEligibilityCheck() async -> [String] {
+        if featureFlags.isFeatureEnabled(.translationLanguagePicker, checking: .buildOnly) {
+            let supported = await translationsService.fetchSupportedTargetLanguages()
+            return manager.preferredLanguages(supportedTargetLanguages: supported)
+        }
+        return [localeProvider.current.languageCode].compactMap { $0 }
+    }
+
     /// Checks whether the current page in the active tab is eligible for translation,
     /// and if so, dispatches a toolbar action to update the translation state.
     private func checkTranslationsAreEligible(for action: ToolbarAction) {
         Task {
             guard action.translationConfiguration?.isTranslationFeatureEnabled == true else { return }
 
             do {
-                guard try await translationsService.shouldOfferTranslation(for: action.windowUUID) else { return }
+                let preferredLanguages = await targetLanguagesForEligibilityCheck()
+                let isEligible = try await translationsService.shouldOfferTranslation(
+                    for: action.windowUUID,
+                    using: preferredLanguages
+                )
+                guard isEligible else { return }
 
                 // Auto-translate handled the page load — skip the manual offer.
                 if await self.tryAutoTranslate(for: action) { return }

firefox-ios/firefox-ios-tests/Tests/ClientTests/TranslationsTests/MockTranslationModelsFetcher.swift

@@ -11,13 +11,14 @@ final class MockTranslationModelsFetcher: TranslationModelsFetcherProtocol, @unc
     var modelsResult: Data?
     var modelBufferResult: Data?
     var supportedTargetLanguages: [String] = []
+    var fetchModelsHandler: ((String, String) -> Data?)?
 
     func fetchTranslatorWASM() -> Data? {
         return translatorWASMResult
     }
 
     func fetchModels(from sourceLang: String, to targetLang: String) -> Data? {
-        return modelsResult
+        return fetchModelsHandler?(sourceLang, targetLang) ?? modelsResult
     }
 
     func fetchModelBuffer(recordId: String) -> Data? {

firefox-ios/firefox-ios-tests/Tests/ClientTests/TranslationsTests/MockTranslationsService.swift

@@ -28,7 +28,7 @@ final class MockTranslationsService: TranslationsServiceProtocol {
     }
 
     // MARK: - TranslationsServiceProtocol
-    func shouldOfferTranslation(for windowUUID: WindowUUID) async throws -> Bool {
+    func shouldOfferTranslation(for windowUUID: WindowUUID, using preferredLanguages: [String]) async throws -> Bool {
         return try shouldOfferTranslationResult.get()
     }
 

firefox-ios/firefox-ios-tests/Tests/ClientTests/TranslationsTests/TranslationsMiddlewareTests.swift

@@ -125,6 +125,34 @@ final class TranslationsMiddlewareIntegrationTests: XCTestCase, StoreTestUtility
         XCTAssertEqual(mockTranslationsTelemetry.pageLanguageIdentificationFailedCalledCount, 0)
     }
 
+    func test_urlDidChangeAction_withLanguagePickerEnabled_andEligiblePage_doesDispatchAction() throws {
+        setTranslationsFeatureEnabled(enabled: true, languagePickerEnabled: true)
+        let mockTranslationService = MockTranslationsService(
+            shouldOfferTranslationResult: .success(true)
+        )
+        let subject = createSubject(translationsService: mockTranslationService)
+        let action = ToolbarAction(
+            url: URL(string: "https://www.example.com"),
+            translationConfiguration: TranslationConfiguration(prefs: mockProfile.prefs),
+            windowUUID: .XCTestDefaultUUID,
+            actionType: ToolbarActionType.urlDidChange
+        )
+
+        let expectation = XCTestExpectation(description: "expect receivedTranslationLanguage action to be fired")
+        mockStore.dispatchCalled = { expectation.fulfill() }
+
+        subject.translationsProvider(mockStore.state, action)
+
+        wait(for: [expectation], timeout: 1.0)
+
+        let actionCalled = try XCTUnwrap(mockStore.dispatchedActions.first as? ToolbarAction)
+        let actionType = try XCTUnwrap(actionCalled.actionType as? ToolbarActionType)
+
+        XCTAssertEqual(actionCalled.translationConfiguration?.state, .inactive)
+        XCTAssertEqual(actionType, ToolbarActionType.receivedTranslationLanguage)
+        XCTAssertEqual(mockStore.dispatchedActions.count, 1)
+    }
+
     func test_urlDidChangeAction_withError_doesNotDispatchActionAndLogsError() throws {
         setTranslationsFeatureEnabled(enabled: true)
         enum TestError: Error { case example }
@@ -837,14 +865,18 @@ final class TranslationsMiddlewareIntegrationTests: XCTestCase, StoreTestUtility
     }
 
     private func createSubject(
-        translationsService: TranslationsServiceProtocol = MockTranslationsService()
+        translationsService: TranslationsServiceProtocol = MockTranslationsService(),
+        manager: PreferredTranslationLanguagesManager? = nil,
+        localeProvider: LocaleProvider = MockLocaleProvider()
     ) -> TranslationsMiddleware {
         return TranslationsMiddleware(
             profile: mockProfile,
             logger: mockLogger,
             windowManager: mockWindowManager,
             translationsService: translationsService,
-            translationsTelemetry: mockTranslationsTelemetry
+            translationsTelemetry: mockTranslationsTelemetry,
+            manager: manager,
+            localeProvider: localeProvider
         )
     }
 

firefox-ios/firefox-ios-tests/Tests/ClientTests/TranslationsTests/TranslationsServiceTests.swift

@@ -57,7 +57,7 @@ final class TranslationsServiceTests: XCTestCase {
 
         setupWebViewForTabManager()
 
-        let result = try await subject.shouldOfferTranslation(for: .XCTestDefaultUUID)
+        let result = try await subject.shouldOfferTranslation(for: .XCTestDefaultUUID, using: [deviceLanguage])
         XCTAssertTrue(
             result,
             "Expected shouldOfferTranslation to be true when languages differ and models are available."
@@ -76,13 +76,64 @@ final class TranslationsServiceTests: XCTestCase {
 
         setupWebViewForTabManager()
 
-        let result = try await subject.shouldOfferTranslation(for: .XCTestDefaultUUID)
+        let result = try await subject.shouldOfferTranslation(for: .XCTestDefaultUUID, using: [deviceLanguage])
         XCTAssertFalse(
             result,
             "Expected shouldOfferTranslation to be false when no models are available."
         )
     }
 
+    func test_shouldOfferTranslation_returnsFalse_whenPreferredLanguagesIsEmpty() async throws {
+        let subject = createSubject(
+            detectedLanguage: "de",
+            languageDetectorError: nil,
+            modelsAvailable: true
+        )
+
+        setupWebViewForTabManager()
+
+        let result = try await subject.shouldOfferTranslation(for: .XCTestDefaultUUID, using: [])
+        XCTAssertFalse(
+            result,
+            "Expected shouldOfferTranslation to be false when preferred languages list is empty."
+        )
+    }
+
+    func test_shouldOfferTranslation_returnsFalse_whenAllPreferredLanguagesMatchPageLanguage() async throws {
+        let subject = createSubject(
+            detectedLanguage: "de",
+            languageDetectorError: nil,
+            modelsAvailable: true
+        )
+
+        setupWebViewForTabManager()
+
+        let result = try await subject.shouldOfferTranslation(for: .XCTestDefaultUUID, using: ["de"])
+        XCTAssertFalse(
+            result,
+            "Expected shouldOfferTranslation to be false when the only preferred language matches the page language."
+        )
+    }
+
+    func test_shouldOfferTranslation_returnsTrue_whenFallbackPreferredLanguageHasModel() async throws {
+        let subject = createSubject(
+            detectedLanguage: "de",
+            languageDetectorError: nil,
+            modelsAvailable: false
+        )
+        mockModelsFetcher.fetchModelsHandler = { _, targetLang in
+            return targetLang == "en" ? Data() : nil
+        }
+
+        setupWebViewForTabManager()
+
+        let result = try await subject.shouldOfferTranslation(for: .XCTestDefaultUUID, using: ["fr", "en"])
+        XCTAssertTrue(
+            result,
+            "Expected shouldOfferTranslation to be true when a fallback preferred language has an available model."
+        )
+    }
+
     func test_shouldOfferTranslation_propagatesLanguageDetectorError() async {
         enum TestError: Error, Equatable { case example }