@capacitor-mlkit/genai-proofreading 8.1.0

package/android/build.gradle

@@ -0,0 +1,60 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+    mlkitGenaiProofreadingVersion = project.hasProperty('mlkitGenaiProofreadingVersion') ? rootProject.ext.mlkitGenaiProofreadingVersion : '1.0.0-beta1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 26
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "com.google.mlkit:genai-proofreading:$mlkitGenaiProofreadingVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

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/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/GenAiProofreading.java

@@ -0,0 +1,159 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.mlkit.genai.common.DownloadCallback;
+import com.google.mlkit.genai.common.FeatureStatus;
+import com.google.mlkit.genai.common.GenAiException;
+import com.google.mlkit.genai.proofreading.Proofreader;
+import com.google.mlkit.genai.proofreading.ProofreaderOptions;
+import com.google.mlkit.genai.proofreading.Proofreading;
+import com.google.mlkit.genai.proofreading.ProofreadingRequest;
+import com.google.mlkit.genai.proofreading.ProofreadingResult;
+import com.google.mlkit.genai.proofreading.ProofreadingSuggestion;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.events.DownloadProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.events.InferenceProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.options.FeatureOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.options.ProofreadOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.results.CheckFeatureStatusResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.results.ProofreadResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.NonEmptyResultCallback;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+public class GenAiProofreading {
+
+    @NonNull
+    private final Executor executor = Executors.newSingleThreadExecutor();
+
+    @NonNull
+    private final GenAiProofreadingPlugin plugin;
+
+    @Nullable
+    private Proofreader proofreader;
+
+    @Nullable
+    private FeatureOptions proofreaderOptions;
+
+    public GenAiProofreading(@NonNull GenAiProofreadingPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void checkFeatureStatus(@NonNull FeatureOptions options, @NonNull NonEmptyResultCallback<CheckFeatureStatusResult> callback) {
+        Proofreader proofreader = getProofreader(options);
+        ListenableFuture<Integer> future = proofreader.checkFeatureStatus();
+        future.addListener(
+            () -> {
+                try {
+                    int featureStatus = future.get();
+                    callback.success(new CheckFeatureStatusResult(featureStatus));
+                } catch (Exception exception) {
+                    callback.error(unwrapException(exception));
+                }
+            },
+            executor
+        );
+    }
+
+    public void downloadFeature(@NonNull FeatureOptions options, @NonNull EmptyCallback callback) {
+        Proofreader proofreader = getProofreader(options);
+        ListenableFuture<Integer> future = proofreader.checkFeatureStatus();
+        future.addListener(
+            () -> {
+                try {
+                    int featureStatus = future.get();
+                    if (featureStatus == FeatureStatus.AVAILABLE) {
+                        callback.success();
+                        return;
+                    }
+                    proofreader.downloadFeature(
+                        new DownloadCallback() {
+                            @Override
+                            public void onDownloadStarted(long bytesToDownload) {}
+
+                            @Override
+                            public void onDownloadProgress(long totalBytesDownloaded) {
+                                plugin.notifyDownloadProgressListeners(new DownloadProgressEvent(totalBytesDownloaded));
+                            }
+
+                            @Override
+                            public void onDownloadCompleted() {
+                                callback.success();
+                            }
+
+                            @Override
+                            public void onDownloadFailed(@NonNull GenAiException exception) {
+                                callback.error(exception);
+                            }
+                        }
+                    );
+                } catch (Exception exception) {
+                    callback.error(unwrapException(exception));
+                }
+            },
+            executor
+        );
+    }
+
+    public void handleOnDestroy() {
+        closeProofreader();
+    }
+
+    public void proofread(@NonNull ProofreadOptions options, @NonNull NonEmptyResultCallback<ProofreadResult> callback) {
+        Proofreader proofreader = getProofreader(options);
+        ProofreadingRequest request = ProofreadingRequest.builder(options.getText()).build();
+        ListenableFuture<ProofreadingResult> future = proofreader.runInference(request, additionalText ->
+            plugin.notifyInferenceProgressListeners(new InferenceProgressEvent(additionalText))
+        );
+        future.addListener(
+            () -> {
+                try {
+                    ProofreadingResult result = future.get();
+                    List<String> results = new ArrayList<>();
+                    for (ProofreadingSuggestion suggestion : result.getResults()) {
+                        results.add(suggestion.getText());
+                    }
+                    callback.success(new ProofreadResult(results));
+                } catch (Exception exception) {
+                    callback.error(unwrapException(exception));
+                }
+            },
+            executor
+        );
+    }
+
+    private void closeProofreader() {
+        if (proofreader != null) {
+            proofreader.close();
+            proofreader = null;
+            proofreaderOptions = null;
+        }
+    }
+
+    @NonNull
+    private Proofreader getProofreader(@NonNull FeatureOptions options) {
+        if (proofreader == null || !options.matches(proofreaderOptions)) {
+            closeProofreader();
+            ProofreaderOptions sdkOptions = ProofreaderOptions.builder(plugin.getContext())
+                .setInputType(options.getInputType())
+                .setLanguage(options.getLanguage())
+                .build();
+            proofreader = Proofreading.getClient(sdkOptions);
+            proofreaderOptions = options;
+        }
+        return proofreader;
+    }
+
+    @NonNull
+    private static Exception unwrapException(@NonNull Exception exception) {
+        if (exception instanceof ExecutionException && exception.getCause() instanceof Exception) {
+            return (Exception) exception.getCause();
+        }
+        return exception;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/GenAiProofreadingPlugin.java

@@ -0,0 +1,145 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.Logger;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.events.DownloadProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.events.InferenceProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.options.FeatureOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.options.ProofreadOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.results.CheckFeatureStatusResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.results.ProofreadResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.Result;
+
+@CapacitorPlugin(name = "GenAiProofreading")
+public class GenAiProofreadingPlugin extends Plugin {
+
+    public static final String TAG = "GenAiProofreading";
+
+    public static final String EVENT_DOWNLOAD_PROGRESS = "downloadProgress";
+    public static final String EVENT_INFERENCE_PROGRESS = "inferenceProgress";
+
+    public static final String ERROR_INPUT_TYPE_INVALID = "inputType is invalid.";
+    public static final String ERROR_LANGUAGE_INVALID = "language is invalid.";
+    public static final String ERROR_TEXT_MISSING = "text must be provided.";
+    public static final String ERROR_UNKNOWN_ERROR = "An unknown error occurred.";
+
+    @Nullable
+    private GenAiProofreading implementation;
+
+    @PluginMethod
+    public void checkFeatureStatus(PluginCall call) {
+        try {
+            FeatureOptions options = new FeatureOptions(call);
+            NonEmptyResultCallback<CheckFeatureStatusResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull CheckFeatureStatusResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.checkFeatureStatus(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void downloadFeature(PluginCall call) {
+        try {
+            FeatureOptions options = new FeatureOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.downloadFeature(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @Override
+    public void load() {
+        implementation = new GenAiProofreading(this);
+    }
+
+    public void notifyDownloadProgressListeners(@NonNull DownloadProgressEvent event) {
+        notifyListeners(EVENT_DOWNLOAD_PROGRESS, event.toJSObject());
+    }
+
+    public void notifyInferenceProgressListeners(@NonNull InferenceProgressEvent event) {
+        notifyListeners(EVENT_INFERENCE_PROGRESS, event.toJSObject());
+    }
+
+    @PluginMethod
+    public void proofread(PluginCall call) {
+        try {
+            ProofreadOptions options = new ProofreadOptions(call);
+            NonEmptyResultCallback<ProofreadResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull ProofreadResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.proofread(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        if (implementation != null) {
+            implementation.handleOnDestroy();
+        }
+    }
+
+    private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
+        String message = exception.getMessage();
+        if (message == null) {
+            message = ERROR_UNKNOWN_ERROR;
+        }
+        Logger.error(TAG, message, exception);
+        call.reject(message);
+    }
+
+    private void resolveCall(@NonNull PluginCall call) {
+        call.resolve();
+    }
+
+    private void resolveCall(@NonNull PluginCall call, @Nullable Result result) {
+        if (result == null) {
+            call.resolve();
+        } else {
+            call.resolve(result.toJSObject());
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/classes/events/DownloadProgressEvent.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.events;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.Result;
+
+public class DownloadProgressEvent implements Result {
+
+    private final long totalBytesDownloaded;
+
+    public DownloadProgressEvent(long totalBytesDownloaded) {
+        this.totalBytesDownloaded = totalBytesDownloaded;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("totalBytesDownloaded", totalBytesDownloaded);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/classes/events/InferenceProgressEvent.java

@@ -0,0 +1,23 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.events;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.Result;
+
+public class InferenceProgressEvent implements Result {
+
+    @NonNull
+    private final String text;
+
+    public InferenceProgressEvent(@NonNull String text) {
+        this.text = text;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("text", text);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/classes/options/FeatureOptions.java

@@ -0,0 +1,64 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.PluginCall;
+import com.google.mlkit.genai.proofreading.ProofreaderOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.GenAiProofreadingPlugin;
+
+public class FeatureOptions {
+
+    private final int inputType;
+    private final int language;
+
+    public FeatureOptions(@NonNull PluginCall call) throws Exception {
+        this.inputType = FeatureOptions.getInputTypeFromCall(call);
+        this.language = FeatureOptions.getLanguageFromCall(call);
+    }
+
+    public int getInputType() {
+        return inputType;
+    }
+
+    public int getLanguage() {
+        return language;
+    }
+
+    public boolean matches(@Nullable FeatureOptions other) {
+        return other != null && inputType == other.inputType && language == other.language;
+    }
+
+    private static int getInputTypeFromCall(@NonNull PluginCall call) throws Exception {
+        String inputType = call.getString("inputType", "KEYBOARD");
+        switch (inputType) {
+            case "KEYBOARD":
+                return ProofreaderOptions.InputType.KEYBOARD;
+            case "VOICE":
+                return ProofreaderOptions.InputType.VOICE;
+            default:
+                throw new Exception(GenAiProofreadingPlugin.ERROR_INPUT_TYPE_INVALID);
+        }
+    }
+
+    private static int getLanguageFromCall(@NonNull PluginCall call) throws Exception {
+        String language = call.getString("language", "ENGLISH");
+        switch (language) {
+            case "ENGLISH":
+                return ProofreaderOptions.Language.ENGLISH;
+            case "FRENCH":
+                return ProofreaderOptions.Language.FRENCH;
+            case "GERMAN":
+                return ProofreaderOptions.Language.GERMAN;
+            case "ITALIAN":
+                return ProofreaderOptions.Language.ITALIAN;
+            case "JAPANESE":
+                return ProofreaderOptions.Language.JAPANESE;
+            case "KOREAN":
+                return ProofreaderOptions.Language.KOREAN;
+            case "SPANISH":
+                return ProofreaderOptions.Language.SPANISH;
+            default:
+                throw new Exception(GenAiProofreadingPlugin.ERROR_LANGUAGE_INVALID);
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/classes/options/ProofreadOptions.java

@@ -0,0 +1,30 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.GenAiProofreadingPlugin;
+
+public class ProofreadOptions extends FeatureOptions {
+
+    @NonNull
+    private final String text;
+
+    public ProofreadOptions(@NonNull PluginCall call) throws Exception {
+        super(call);
+        this.text = ProofreadOptions.getTextFromCall(call);
+    }
+
+    @NonNull
+    public String getText() {
+        return text;
+    }
+
+    @NonNull
+    private static String getTextFromCall(@NonNull PluginCall call) throws Exception {
+        String text = call.getString("text");
+        if (text == null) {
+            throw new Exception(GenAiProofreadingPlugin.ERROR_TEXT_MISSING);
+        }
+        return text;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/classes/results/CheckFeatureStatusResult.java

@@ -0,0 +1,37 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import com.google.mlkit.genai.common.FeatureStatus;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.Result;
+
+public class CheckFeatureStatusResult implements Result {
+
+    private final int featureStatus;
+
+    public CheckFeatureStatusResult(int featureStatus) {
+        this.featureStatus = featureStatus;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("featureStatus", convertFeatureStatusToString(featureStatus));
+        return result;
+    }
+
+    @NonNull
+    private static String convertFeatureStatusToString(int featureStatus) {
+        switch (featureStatus) {
+            case FeatureStatus.AVAILABLE:
+                return "AVAILABLE";
+            case FeatureStatus.DOWNLOADABLE:
+                return "DOWNLOADABLE";
+            case FeatureStatus.DOWNLOADING:
+                return "DOWNLOADING";
+            default:
+                return "UNAVAILABLE";
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/classes/results/ProofreadResult.java

@@ -0,0 +1,29 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces.Result;
+import java.util.List;
+
+public class ProofreadResult implements Result {
+
+    @NonNull
+    private final List<String> results;
+
+    public ProofreadResult(@NonNull List<String> results) {
+        this.results = results;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSArray resultsArray = new JSArray();
+        for (String result : results) {
+            resultsArray.put(result);
+        }
+        JSObject result = new JSObject();
+        result.put("results", resultsArray);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/interfaces/Callback.java

@@ -0,0 +1,5 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces;
+
+public interface Callback {
+    void error(Exception exception);
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/interfaces/EmptyCallback.java

@@ -0,0 +1,5 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces;
+
+public interface EmptyCallback extends Callback {
+    void success();
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/interfaces/NonEmptyResultCallback.java

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces;
+
+import androidx.annotation.NonNull;
+
+public interface NonEmptyResultCallback<T extends Result> extends Callback {
+    void success(@NonNull T result);
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genaiproofreading/interfaces/Result.java

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genaiproofreading.interfaces;
+
+import com.getcapacitor.JSObject;
+
+public interface Result {
+    JSObject toJSObject();
+}