@capacitor-mlkit/genai-rewriting 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'
+    mlkitGenaiRewritingVersion = project.hasProperty('mlkitGenaiRewritingVersion') ? rootProject.ext.mlkitGenaiRewritingVersion : '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.genairewriting"
+    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-rewriting:$mlkitGenaiRewritingVersion"
+    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/genairewriting/GenAiRewriting.java

@@ -0,0 +1,159 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting;
+
+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.rewriting.Rewriter;
+import com.google.mlkit.genai.rewriting.RewriterOptions;
+import com.google.mlkit.genai.rewriting.Rewriting;
+import com.google.mlkit.genai.rewriting.RewritingRequest;
+import com.google.mlkit.genai.rewriting.RewritingResult;
+import com.google.mlkit.genai.rewriting.RewritingSuggestion;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.events.DownloadProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.events.InferenceProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.options.FeatureOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.options.RewriteOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.results.CheckFeatureStatusResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.results.RewriteResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.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 GenAiRewriting {
+
+    @NonNull
+    private final Executor executor = Executors.newSingleThreadExecutor();
+
+    @NonNull
+    private final GenAiRewritingPlugin plugin;
+
+    @Nullable
+    private Rewriter rewriter;
+
+    @Nullable
+    private FeatureOptions rewriterOptions;
+
+    public GenAiRewriting(@NonNull GenAiRewritingPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void checkFeatureStatus(@NonNull FeatureOptions options, @NonNull NonEmptyResultCallback<CheckFeatureStatusResult> callback) {
+        Rewriter rewriter = getRewriter(options);
+        ListenableFuture<Integer> future = rewriter.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) {
+        Rewriter rewriter = getRewriter(options);
+        ListenableFuture<Integer> future = rewriter.checkFeatureStatus();
+        future.addListener(
+            () -> {
+                try {
+                    int featureStatus = future.get();
+                    if (featureStatus == FeatureStatus.AVAILABLE) {
+                        callback.success();
+                        return;
+                    }
+                    rewriter.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() {
+        closeRewriter();
+    }
+
+    public void rewrite(@NonNull RewriteOptions options, @NonNull NonEmptyResultCallback<RewriteResult> callback) {
+        Rewriter rewriter = getRewriter(options);
+        RewritingRequest request = RewritingRequest.builder(options.getText()).build();
+        ListenableFuture<RewritingResult> future = rewriter.runInference(request, additionalText ->
+            plugin.notifyInferenceProgressListeners(new InferenceProgressEvent(additionalText))
+        );
+        future.addListener(
+            () -> {
+                try {
+                    RewritingResult result = future.get();
+                    List<String> results = new ArrayList<>();
+                    for (RewritingSuggestion suggestion : result.getResults()) {
+                        results.add(suggestion.getText());
+                    }
+                    callback.success(new RewriteResult(results));
+                } catch (Exception exception) {
+                    callback.error(unwrapException(exception));
+                }
+            },
+            executor
+        );
+    }
+
+    private void closeRewriter() {
+        if (rewriter != null) {
+            rewriter.close();
+            rewriter = null;
+            rewriterOptions = null;
+        }
+    }
+
+    @NonNull
+    private Rewriter getRewriter(@NonNull FeatureOptions options) {
+        if (rewriter == null || !options.matches(rewriterOptions)) {
+            closeRewriter();
+            RewriterOptions sdkOptions = RewriterOptions.builder(plugin.getContext())
+                .setLanguage(options.getLanguage())
+                .setOutputType(options.getOutputType())
+                .build();
+            rewriter = Rewriting.getClient(sdkOptions);
+            rewriterOptions = options;
+        }
+        return rewriter;
+    }
+
+    @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/genairewriting/GenAiRewritingPlugin.java

@@ -0,0 +1,145 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting;
+
+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.genairewriting.classes.events.DownloadProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.events.InferenceProgressEvent;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.options.FeatureOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.options.RewriteOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.results.CheckFeatureStatusResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.results.RewriteResult;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.interfaces.Result;
+
+@CapacitorPlugin(name = "GenAiRewriting")
+public class GenAiRewritingPlugin extends Plugin {
+
+    public static final String TAG = "GenAiRewriting";
+
+    public static final String EVENT_DOWNLOAD_PROGRESS = "downloadProgress";
+    public static final String EVENT_INFERENCE_PROGRESS = "inferenceProgress";
+
+    public static final String ERROR_LANGUAGE_INVALID = "language is invalid.";
+    public static final String ERROR_OUTPUT_TYPE_INVALID = "outputType 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 GenAiRewriting 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 GenAiRewriting(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 rewrite(PluginCall call) {
+        try {
+            RewriteOptions options = new RewriteOptions(call);
+            NonEmptyResultCallback<RewriteResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull RewriteResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.rewrite(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/genairewriting/classes/events/DownloadProgressEvent.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.events;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.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/genairewriting/classes/events/InferenceProgressEvent.java

@@ -0,0 +1,23 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.events;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.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/genairewriting/classes/options/FeatureOptions.java

@@ -0,0 +1,72 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.PluginCall;
+import com.google.mlkit.genai.rewriting.RewriterOptions;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.GenAiRewritingPlugin;
+
+public class FeatureOptions {
+
+    private final int language;
+    private final int outputType;
+
+    public FeatureOptions(@NonNull PluginCall call) throws Exception {
+        this.language = FeatureOptions.getLanguageFromCall(call);
+        this.outputType = FeatureOptions.getOutputTypeFromCall(call);
+    }
+
+    public int getLanguage() {
+        return language;
+    }
+
+    public int getOutputType() {
+        return outputType;
+    }
+
+    public boolean matches(@Nullable FeatureOptions other) {
+        return other != null && language == other.language && outputType == other.outputType;
+    }
+
+    private static int getLanguageFromCall(@NonNull PluginCall call) throws Exception {
+        String language = call.getString("language", "ENGLISH");
+        switch (language) {
+            case "ENGLISH":
+                return RewriterOptions.Language.ENGLISH;
+            case "FRENCH":
+                return RewriterOptions.Language.FRENCH;
+            case "GERMAN":
+                return RewriterOptions.Language.GERMAN;
+            case "ITALIAN":
+                return RewriterOptions.Language.ITALIAN;
+            case "JAPANESE":
+                return RewriterOptions.Language.JAPANESE;
+            case "KOREAN":
+                return RewriterOptions.Language.KOREAN;
+            case "SPANISH":
+                return RewriterOptions.Language.SPANISH;
+            default:
+                throw new Exception(GenAiRewritingPlugin.ERROR_LANGUAGE_INVALID);
+        }
+    }
+
+    private static int getOutputTypeFromCall(@NonNull PluginCall call) throws Exception {
+        String outputType = call.getString("outputType", "ELABORATE");
+        switch (outputType) {
+            case "ELABORATE":
+                return RewriterOptions.OutputType.ELABORATE;
+            case "EMOJIFY":
+                return RewriterOptions.OutputType.EMOJIFY;
+            case "SHORTEN":
+                return RewriterOptions.OutputType.SHORTEN;
+            case "FRIENDLY":
+                return RewriterOptions.OutputType.FRIENDLY;
+            case "PROFESSIONAL":
+                return RewriterOptions.OutputType.PROFESSIONAL;
+            case "REPHRASE":
+                return RewriterOptions.OutputType.REPHRASE;
+            default:
+                throw new Exception(GenAiRewritingPlugin.ERROR_OUTPUT_TYPE_INVALID);
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/mlkit/genairewriting/classes/options/RewriteOptions.java

@@ -0,0 +1,30 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.GenAiRewritingPlugin;
+
+public class RewriteOptions extends FeatureOptions {
+
+    @NonNull
+    private final String text;
+
+    public RewriteOptions(@NonNull PluginCall call) throws Exception {
+        super(call);
+        this.text = RewriteOptions.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(GenAiRewritingPlugin.ERROR_TEXT_MISSING);
+        }
+        return text;
+    }
+}

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

@@ -0,0 +1,37 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import com.google.mlkit.genai.common.FeatureStatus;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.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/genairewriting/classes/results/RewriteResult.java

@@ -0,0 +1,29 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.mlkit.genairewriting.interfaces.Result;
+import java.util.List;
+
+public class RewriteResult implements Result {
+
+    @NonNull
+    private final List<String> results;
+
+    public RewriteResult(@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/genairewriting/interfaces/Callback.java

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

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

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

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

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.mlkit.genairewriting.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/genairewriting/interfaces/Result.java

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