@christhuong/expo-mlkit-translation 0.1.0

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Fri Jul 03 22:07:48 ICT 2026
+gradle.version=8.9

package/android/build.gradle

@@ -0,0 +1,22 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  namespace "expo.modules.mlkittranslation"
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    versionCode 1
+    versionName "1.0"
+  }
+}
+
+dependencies {
+  implementation "com.google.mlkit:translate:17.0.3"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/expo/modules/mlkittranslation/ExpoMlkitTranslationModule.kt

@@ -0,0 +1,144 @@
+package expo.modules.mlkittranslation
+
+import android.util.LruCache
+import com.google.mlkit.common.model.DownloadConditions
+import com.google.mlkit.common.model.RemoteModelManager
+import com.google.mlkit.nl.translate.TranslateLanguage
+import com.google.mlkit.nl.translate.TranslateRemoteModel
+import com.google.mlkit.nl.translate.Translation
+import com.google.mlkit.nl.translate.Translator
+import com.google.mlkit.nl.translate.TranslatorOptions
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * Expo module wrapping Google ML Kit Translation.
+ * Attribution requirements: https://developers.google.com/ml-kit/language/translation/trans-attribution
+ */
+class ExpoMlkitTranslationModule : Module() {
+  private val translatorsCache = object : LruCache<String, Translator>(20) {
+    override fun entryRemoved(evicted: Boolean, key: String, oldValue: Translator, newValue: Translator?) {
+      if (evicted) {
+        oldValue.close()
+      }
+    }
+  }
+
+  private fun getTranslator(source: String, target: String): Translator? {
+    val sourceLang = TranslateLanguage.fromLanguageTag(source) ?: return null
+    val targetLang = TranslateLanguage.fromLanguageTag(target) ?: return null
+    val key = "${sourceLang}_${targetLang}"
+    
+    translatorsCache.get(key)?.let { return it }
+
+    val options = TranslatorOptions.Builder()
+      .setSourceLanguage(sourceLang)
+      .setTargetLanguage(targetLang)
+      .build()
+    
+    val translator = Translation.getClient(options)
+    translatorsCache.put(key, translator)
+    return translator
+  }
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoMlkitTranslation")
+
+    AsyncFunction("translate") { text: String, sourceLanguage: String, targetLanguage: String, promise: Promise ->
+      val translator = getTranslator(sourceLanguage, targetLanguage)
+      if (translator == null) {
+        promise.reject("ERR_LANGUAGE", "Invalid language provided", null)
+        return@AsyncFunction
+      }
+
+      val conditions = DownloadConditions.Builder()
+        .build()
+
+      translator.downloadModelIfNeeded(conditions)
+        .addOnSuccessListener {
+          translator.translate(text)
+            .addOnSuccessListener { translatedText ->
+              promise.resolve(translatedText)
+            }
+            .addOnFailureListener { e ->
+              promise.reject("ERR_TRANSLATE", "Failed to translate text", e)
+            }
+        }
+        .addOnFailureListener { e ->
+          promise.reject("ERR_DOWNLOAD", "Failed to download model", e)
+        }
+    }
+
+    AsyncFunction("downloadModel") { languageTag: String, promise: Promise ->
+      val lang = TranslateLanguage.fromLanguageTag(languageTag)
+      if (lang == null) {
+        promise.reject("ERR_LANGUAGE", "Invalid language: $languageTag", null)
+        return@AsyncFunction
+      }
+
+      val modelManager = RemoteModelManager.getInstance()
+      val model = TranslateRemoteModel.Builder(lang).build()
+      val conditions = DownloadConditions.Builder()
+        .build()
+
+      modelManager.download(model, conditions)
+        .addOnSuccessListener {
+          promise.resolve(null)
+        }
+        .addOnFailureListener { e ->
+          promise.reject("ERR_DOWNLOAD", "Failed to download model", e)
+        }
+    }
+
+    AsyncFunction("isModelDownloaded") { languageTag: String, promise: Promise ->
+      val lang = TranslateLanguage.fromLanguageTag(languageTag)
+      if (lang == null) {
+        promise.resolve(false)
+        return@AsyncFunction
+      }
+
+      val modelManager = RemoteModelManager.getInstance()
+      val model = TranslateRemoteModel.Builder(lang).build()
+
+      modelManager.isModelDownloaded(model)
+        .addOnSuccessListener { isDownloaded ->
+          promise.resolve(isDownloaded)
+        }
+        .addOnFailureListener { _ ->
+          promise.resolve(false)
+        }
+    }
+
+    AsyncFunction("deleteModel") { languageTag: String, promise: Promise ->
+      val lang = TranslateLanguage.fromLanguageTag(languageTag)
+      if (lang == null) {
+        promise.reject("ERR_LANGUAGE", "Invalid language: $languageTag", null)
+        return@AsyncFunction
+      }
+
+      val modelManager = RemoteModelManager.getInstance()
+      val model = TranslateRemoteModel.Builder(lang).build()
+
+      modelManager.deleteDownloadedModel(model)
+        .addOnSuccessListener {
+          promise.resolve(null)
+        }
+        .addOnFailureListener { e ->
+          promise.reject("ERR_DELETE", "Failed to delete model", e)
+        }
+    }
+
+    AsyncFunction("getDownloadedModelTags") { promise: Promise ->
+      val modelManager = RemoteModelManager.getInstance()
+      modelManager.getDownloadedModels(TranslateRemoteModel::class.java)
+        .addOnSuccessListener { models ->
+          val tags = models.map { it.language }
+          promise.resolve(tags)
+        }
+        .addOnFailureListener { e ->
+          promise.reject("ERR_MODELS", "Failed to get downloaded models", e)
+        }
+    }
+  }
+}

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export declare function translate(text: string, sourceLanguage: string, targetLanguage: string): Promise<string>;
+export declare function downloadModel(languageTag: string): Promise<void>;
+export declare function isModelDownloaded(languageTag: string): Promise<boolean>;
+export declare function deleteModel(languageTag: string): Promise<void>;
+export declare function getDownloadedModelTags(): Promise<string[]>;

package/build/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = translate;
+exports.downloadModel = downloadModel;
+exports.isModelDownloaded = isModelDownloaded;
+exports.deleteModel = deleteModel;
+exports.getDownloadedModelTags = getDownloadedModelTags;
+const expo_modules_core_1 = require("expo-modules-core");
+let _module = null;
+try {
+    _module = (0, expo_modules_core_1.requireNativeModule)('ExpoMlkitTranslation');
+}
+catch (error) {
+    if (__DEV__) {
+        console.warn('[ExpoMlkitTranslation] Native module not available. ' +
+            'Translation will not work. ' +
+            'Run expo prebuild and rebuild the app.');
+    }
+}
+async function translate(text, sourceLanguage, targetLanguage) {
+    if (!_module) {
+        throw new Error('[ExpoMlkitTranslation] Native module not available');
+    }
+    return _module.translate(text, sourceLanguage, targetLanguage);
+}
+async function downloadModel(languageTag) {
+    if (!_module) {
+        throw new Error('[ExpoMlkitTranslation] Native module not available');
+    }
+    return _module.downloadModel(languageTag);
+}
+async function isModelDownloaded(languageTag) {
+    if (!_module) {
+        return false;
+    }
+    return _module.isModelDownloaded(languageTag);
+}
+async function deleteModel(languageTag) {
+    if (!_module) {
+        throw new Error('[ExpoMlkitTranslation] Native module not available');
+    }
+    return _module.deleteModel(languageTag);
+}
+async function getDownloadedModelTags() {
+    if (!_module) {
+        return [];
+    }
+    return _module.getDownloadedModelTags();
+}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["ExpoMlkitTranslationModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.mlkittranslation.ExpoMlkitTranslationModule"]
+  }
+}

package/ios/ExpoMlkitTranslation.podspec

@@ -0,0 +1,22 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoMlkitTranslation'
+  s.version        = package['version']
+  s.summary        = 'Expo module wrapping Google ML Kit Translation'
+  s.description    = 'Translates text between languages using ML Kit Translation'
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = 'https://github.com/thuongstudio'
+  s.platforms      = { :ios => '15.5' }
+  s.swift_version  = '5.9'
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'GoogleMLKit/Translate', '8.0.0'
+
+  s.source_files = '**/*.{h,m,swift}'
+end

package/ios/ExpoMlkitTranslationModule.swift

@@ -0,0 +1,109 @@
+import ExpoModulesCore
+import MLKitCommon
+import MLKitTranslate
+
+/**
+ * Expo module wrapping Google ML Kit Translation.
+ * Attribution requirements: https://developers.google.com/ml-kit/language/translation/trans-attribution
+ */
+public class ExpoMlkitTranslationModule: Module {
+  private let translatorsCache: NSCache<NSString, Translator> = {
+    let cache = NSCache<NSString, Translator>()
+    cache.countLimit = 20 // Limit to 20 active translators to manage memory
+    return cache
+  }()
+  private let queue = DispatchQueue(label: "com.vocatrace.translation.queue")
+
+  private func getTranslator(source: String, target: String) -> Translator {
+    let key = "\(source)_\(target)" as NSString
+    if let cached = translatorsCache.object(forKey: key) {
+      return cached
+    }
+    let options = TranslatorOptions(sourceLanguage: TranslateLanguage(rawValue: source),
+                                    targetLanguage: TranslateLanguage(rawValue: target))
+    let translator = Translator.translator(options: options)
+    translatorsCache.setObject(translator, forKey: key)
+    return translator
+  }
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoMlkitTranslation")
+
+    AsyncFunction("translate") { (text: String, sourceLanguage: String, targetLanguage: String, promise: Promise) in
+      let translator = self.getTranslator(source: sourceLanguage, target: targetLanguage)
+      
+      self.queue.async {
+        let conditions = ModelDownloadConditions(
+            allowsCellularAccess: true,
+            allowsBackgroundDownloading: true
+        )
+
+        translator.downloadModelIfNeeded(with: conditions) { error in
+          self.queue.async {
+            if let error = error {
+              promise.reject("ERR_DOWNLOAD", error.localizedDescription)
+              return
+            }
+
+            translator.translate(text) { translatedText, error in
+              self.queue.async {
+                if let error = error {
+                  promise.reject("ERR_TRANSLATE", error.localizedDescription)
+                  return
+                }
+                if let translatedText = translatedText {
+                  promise.resolve(translatedText)
+                } else {
+                  promise.reject("ERR_TRANSLATE", "Translation returned null")
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    AsyncFunction("downloadModel") { (languageTag: String, promise: Promise) in
+      let translator = self.getTranslator(source: languageTag, target: "en")
+      
+      let conditions = ModelDownloadConditions(
+          allowsCellularAccess: true,
+          allowsBackgroundDownloading: true
+      )
+
+      translator.downloadModelIfNeeded(with: conditions) { error in
+        if let error = error {
+          promise.reject("ERR_DOWNLOAD", error.localizedDescription)
+        } else {
+          promise.resolve()
+        }
+      }
+    }
+
+    AsyncFunction("isModelDownloaded") { (languageTag: String, promise: Promise) in
+      let model = TranslateRemoteModel.translateRemoteModel(language: TranslateLanguage(rawValue: languageTag))
+      let modelManager = ModelManager.modelManager()
+      let isDownloaded = modelManager.isModelDownloaded(model)
+      promise.resolve(isDownloaded)
+    }
+
+    AsyncFunction("deleteModel") { (languageTag: String, promise: Promise) in
+      let model = TranslateRemoteModel.translateRemoteModel(language: TranslateLanguage(rawValue: languageTag))
+      let modelManager = ModelManager.modelManager()
+      modelManager.deleteDownloadedModel(model) { error in
+        if let error = error {
+          promise.reject("ERR_DELETE", "Failed to delete model: \(error.localizedDescription)")
+        } else {
+          promise.resolve()
+        }
+      }
+    }
+
+    AsyncFunction("getDownloadedModelTags") { (promise: Promise) in
+      let modelManager = ModelManager.modelManager()
+      let models = modelManager.downloadedTranslateModels
+      let tags = models.compactMap { $0.language.rawValue }
+      promise.resolve(Array(tags))
+    }
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@christhuong/expo-mlkit-translation",
+  "version": "0.1.0",
+  "description": "ML Kit translation native module",
+  "author": "Thuong Studio",
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build",
+    "android",
+    "ios",
+    "app.plugin.js",
+    "expo-module.config.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf build"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  }
+}