@glassly/bluetooth-sdk 0.3.1-dev.496 → 0.3.1-dev.497

package/ios/Source/translation/OfflineTranslator.swift

@@ -0,0 +1,224 @@
+import Foundation
+
+#if canImport(Translation) && canImport(UIKit)
+    import SwiftUI
+    import Translation
+    import UIKit
+#endif
+
+enum OfflineTranslationError: LocalizedError {
+    case unavailable
+    case notInstalled(String)
+    case noPresenter
+    case failed(String)
+
+    /// Leading token is the stable code the JS side matches on.
+    var errorDescription: String? {
+        switch self {
+        case .unavailable: "unavailable: on-device translation requires iOS 26"
+        case let .notInstalled(pair): "not_installed: \(pair) is not downloaded"
+        case .noPresenter: "no_presenter: no visible window to present the download prompt"
+        case let .failed(message): "failed: \(message)"
+        }
+    }
+}
+
+/// On-device text translation backed by Apple's Translation framework.
+/// Sessions are created without UI (`TranslationSession(installedSource:target:)`,
+/// iOS 26), so a pair must be installed before it can translate; installing
+/// goes through the system download prompt in `download`.
+enum OfflineTranslator {
+    static var isSupported: Bool {
+        #if canImport(Translation) && canImport(UIKit)
+            if #available(iOS 26.0, *) {
+                return true
+            }
+        #endif
+        return false
+    }
+
+    /// Every language the system can translate `source` into, with its install state.
+    static func languages(source: String) async -> [[String: String]] {
+        #if canImport(Translation) && canImport(UIKit)
+            if #available(iOS 26.0, *) {
+                let availability = makeAvailability()
+                let from = Locale.Language(identifier: source)
+                var rows: [[String: String]] = []
+                for language in await availability.supportedLanguages {
+                    let code = language.minimalIdentifier
+                    let status = await availability.status(from: from, to: language)
+                    if status == .unsupported {
+                        continue
+                    }
+                    rows.append([
+                        "code": code,
+                        "name": Locale.current.localizedString(forIdentifier: code) ?? code,
+                        "status": statusName(status),
+                    ])
+                }
+                return rows.sorted { ($0["name"] ?? "") < ($1["name"] ?? "") }
+            }
+        #endif
+        return []
+    }
+
+    static func status(source: String, target: String) async -> String {
+        #if canImport(Translation) && canImport(UIKit)
+            if #available(iOS 26.0, *) {
+                let status = await makeAvailability().status(
+                    from: Locale.Language(identifier: source),
+                    to: Locale.Language(identifier: target)
+                )
+                return statusName(status)
+            }
+        #endif
+        return "unavailable"
+    }
+
+    /// Shows the system prompt that downloads the pair, then reports its status.
+    static func download(source: String, target: String) async throws -> String {
+        #if canImport(Translation) && canImport(UIKit)
+            if #available(iOS 26.0, *) {
+                try await presentDownload(
+                    source: Locale.Language(identifier: source),
+                    target: Locale.Language(identifier: target)
+                )
+                await SessionStore.shared.drop(source: source, target: target)
+                return await status(source: source, target: target)
+            }
+        #endif
+        throw OfflineTranslationError.unavailable
+    }
+
+    static func translate(text: String, source: String, target: String) async throws -> String {
+        #if canImport(Translation) && canImport(UIKit)
+            if #available(iOS 26.0, *) {
+                return try await SessionStore.shared.translate(text: text, source: source, target: target)
+            }
+        #endif
+        throw OfflineTranslationError.unavailable
+    }
+}
+
+#if canImport(Translation) && canImport(UIKit)
+    @available(iOS 26.0, *)
+    private extension OfflineTranslator {
+        static func makeAvailability() -> LanguageAvailability {
+            // Low latency keeps the downloadable language-pack flow, which is
+            // what works with no network.
+            if #available(iOS 26.4, *) {
+                return LanguageAvailability(preferredStrategy: .lowLatency)
+            }
+            return LanguageAvailability()
+        }
+
+        static func statusName(_ status: LanguageAvailability.Status) -> String {
+            switch status {
+            case .installed: return "installed"
+            case .supported: return "supported"
+            case .unsupported: return "unsupported"
+            @unknown default: return "unsupported"
+            }
+        }
+
+        @MainActor
+        static func presentDownload(source: Locale.Language, target: Locale.Language) async throws {
+            guard let presenter = topViewController() else { throw OfflineTranslationError.noPresenter }
+            let configuration: TranslationSession.Configuration = if #available(iOS 26.4, *) {
+                .init(source: source, target: target, preferredStrategy: .lowLatency)
+            } else {
+                .init(source: source, target: target)
+            }
+
+            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+                var host: UIViewController?
+                var finished = false
+                let view = DownloadHost(configuration: configuration) { result in
+                    if finished {
+                        return
+                    }
+                    finished = true
+                    host?.willMove(toParent: nil)
+                    host?.view.removeFromSuperview()
+                    host?.removeFromParent()
+                    continuation.resume(with: result)
+                }
+                let controller = UIHostingController(rootView: view)
+                controller.view.backgroundColor = .clear
+                controller.view.isUserInteractionEnabled = false
+                controller.view.frame = CGRect(x: 0, y: 0, width: 1, height: 1)
+                presenter.addChild(controller)
+                presenter.view.addSubview(controller.view)
+                controller.didMove(toParent: presenter)
+                host = controller
+            }
+        }
+
+        @MainActor
+        static func topViewController() -> UIViewController? {
+            let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+            let scene = scenes.first { $0.activationState == .foregroundActive } ?? scenes.first
+            let window = scene?.windows.first { $0.isKeyWindow } ?? scene?.windows.first
+            var top = window?.rootViewController
+            while let presented = top?.presentedViewController {
+                top = presented
+            }
+            return top
+        }
+    }
+
+    /// Invisible host: `.translationTask` is the only API that hands out a
+    /// session allowed to request downloads.
+    @available(iOS 26.0, *)
+    private struct DownloadHost: View {
+        let configuration: TranslationSession.Configuration
+        let onFinish: @MainActor (Result<Void, Error>) -> Void
+
+        var body: some View {
+            Color.clear.translationTask(configuration) { @MainActor session in
+                do {
+                    try await session.prepareTranslation()
+                    onFinish(.success(()))
+                } catch {
+                    onFinish(.failure(OfflineTranslationError.failed(error.localizedDescription)))
+                }
+            }
+        }
+    }
+
+    @available(iOS 26.0, *)
+    private actor SessionStore {
+        static let shared = SessionStore()
+
+        private var sessions: [String: TranslationSession] = [:]
+
+        func drop(source: String, target: String) {
+            sessions.removeValue(forKey: "\(source)>\(target)")?.cancel()
+        }
+
+        func translate(text: String, source: String, target: String) async throws -> String {
+            let key = "\(source)>\(target)"
+            let session = sessions[key] ?? makeSession(source: source, target: target)
+            sessions[key] = session
+            do {
+                return try await session.translate(text).targetText
+            } catch {
+                // A failed session may be cancelled or stale; rebuild on the next call.
+                sessions.removeValue(forKey: key)
+                if TranslationError.notInstalled ~= error {
+                    throw OfflineTranslationError.notInstalled(key)
+                }
+                throw OfflineTranslationError.failed(error.localizedDescription)
+            }
+        }
+
+        private func makeSession(source: String, target: String) -> TranslationSession {
+            let from = Locale.Language(identifier: source)
+            let to = Locale.Language(identifier: target)
+            if #available(iOS 26.4, *) {
+                return TranslationSession(installedSource: from, target: to, preferredStrategy: .lowLatency)
+            }
+            return TranslationSession(installedSource: from, target: to)
+        }
+    }
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassly/bluetooth-sdk",
-  "version": "0.3.1-dev.496",
+  "version": "0.3.1-dev.497",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/BluetoothSdk.types.ts

@@ -257,6 +257,10 @@ export type GlassesMediaVolumeSetResult = {
   statusCode: number
 }
 
+export type OfflineTranslationStatus = "installed" | "supported" | "unsupported" | "unavailable"
+
+export type OfflineTranslationLanguage = {code: string; name: string; status: OfflineTranslationStatus}
+
 export type LocalTranscriptionEvent = {
   text: string
   isFinal?: boolean
@@ -1562,6 +1566,12 @@ export interface BluetoothSdkPublicModule {
   extractTarBz2(sourcePath: string, destinationPath: string): Promise<boolean>
   restartTranscriber(): Promise<void>
 
+  // Offline translation (iOS 26+; rejects elsewhere)
+  getOfflineTranslationLanguages(source: string): Promise<OfflineTranslationLanguage[]>
+  getOfflineTranslationStatus(source: string, target: string): Promise<OfflineTranslationStatus>
+  downloadOfflineTranslation(source: string, target: string): Promise<OfflineTranslationStatus>
+  translateOffline(text: string, source: string, target: string): Promise<string>
+
   // TTS Commands (TODO: MOVE TO CRUST)
   setTtsModelDetails(path: string, languageCode: string): Promise<void>
   getTtsModelPath(): Promise<string>

package/src/_private/BluetoothSdkModule.ts

@@ -2,6 +2,8 @@ import {NativeModule, requireNativeModule} from "expo"
 
 import {CAMERA_FOV_DEFAULT, CAMERA_FOV_MAX, CAMERA_FOV_MIN} from "../BluetoothSdk.types"
 import type {
+  OfflineTranslationLanguage,
+  OfflineTranslationStatus,
   BluetoothSettingsUpdate,
   BluetoothSdkModuleEvents,
   BluetoothStatus,
@@ -280,6 +282,12 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
   validateSttModel(path: string): Promise<boolean>
   extractTarBz2(sourcePath: string, destinationPath: string): Promise<boolean>
 
+  // Offline translation (iOS 26+; rejects elsewhere)
+  getOfflineTranslationLanguages(source: string): Promise<OfflineTranslationLanguage[]>
+  getOfflineTranslationStatus(source: string, target: string): Promise<OfflineTranslationStatus>
+  downloadOfflineTranslation(source: string, target: string): Promise<OfflineTranslationStatus>
+  translateOffline(text: string, source: string, target: string): Promise<string>
+
   // Speaker Identification (on-device; see SpeakerIdEngine)
   setSpeakerIdEnabled(enabled: boolean): Promise<void>
   setSpeakerIdModelPath(path: string): Promise<void>

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "0.3.1",
-  "releaseIdentity": "0.3.1-dev.496",
-  "releaseSetId": "glassly-0.3.1-dev.496",
-  "sourceCommit": "77c2bb7e91ed12c414e1eaa54c786a324f232c66",
+  "releaseIdentity": "0.3.1-dev.497",
+  "releaseSetId": "glassly-0.3.1-dev.497",
+  "sourceCommit": "e8375fec1441ab00893f2bc1e7c29530e35fb419",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })

package/src/index.ts

@@ -192,6 +192,10 @@ export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
   validateSttModel: bindPublicMethod("validateSttModel"),
   extractTarBz2: bindPublicMethod("extractTarBz2"),
   restartTranscriber: bindPublicMethod("restartTranscriber"),
+  getOfflineTranslationLanguages: bindPublicMethod("getOfflineTranslationLanguages"),
+  getOfflineTranslationStatus: bindPublicMethod("getOfflineTranslationStatus"),
+  downloadOfflineTranslation: bindPublicMethod("downloadOfflineTranslation"),
+  translateOffline: bindPublicMethod("translateOffline"),
   setTtsModelDetails: bindPublicMethod("setTtsModelDetails"),
   getTtsModelPath: bindPublicMethod("getTtsModelPath"),
   getTtsModelLanguage: bindPublicMethod("getTtsModelLanguage"),