@capacitor-community/text-to-speech 0.2.3 → 1.1.2

package/android/src/main/java/com/getcapacitor/community/tts/TextToSpeech.java

@@ -1,9 +1,5 @@
 package com.getcapacitor.community.tts;
 
-import static com.getcapacitor.community.tts.Constant.ERROR_TTS_NOT_INITIALIZED;
-import static com.getcapacitor.community.tts.Constant.ERROR_UNSUPPORTED_LOCALE;
-import static com.getcapacitor.community.tts.Constant.ERROR_UTTERANCE;
-
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
@@ -15,220 +11,142 @@ import android.speech.tts.Voice;
 import android.util.Log;
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
-import com.getcapacitor.NativePlugin;
-import com.getcapacitor.Plugin;
-import com.getcapacitor.PluginCall;
-import com.getcapacitor.PluginMethod;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Set;
 
-@NativePlugin
-public class TextToSpeech extends Plugin implements android.speech.tts.TextToSpeech.OnInitListener {
+public class TextToSpeech implements android.speech.tts.TextToSpeech.OnInitListener {
 
-    public static final String TAG = "TextToSpeech";
+    public static final String LOG_TAG = "TextToSpeech";
 
-    private boolean ttsInitialized = false;
+    private Context context;
     private android.speech.tts.TextToSpeech tts = null;
-    private Context context = null;
-    private ArrayList<Locale> supportedLocales = new ArrayList<>();
+    private int initializationStatus;
+    private JSObject[] supportedVoices = null;
 
-    @Override
-    public void onInit(int status) {
+    TextToSpeech(Context context) {
+        this.context = context;
         try {
-            if (status != android.speech.tts.TextToSpeech.SUCCESS) {
-                tts = null;
-                ttsInitialized = false;
-            } else {
-                if (Build.VERSION.SDK_INT >= 21) {
-                    Bundle ttsParams = new Bundle();
-                    ttsParams.putSerializable(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, "");
-                    tts.setLanguage(new Locale("en", "US"));
-                    tts.speak("", android.speech.tts.TextToSpeech.QUEUE_FLUSH, ttsParams, "");
-                } else {
-                    HashMap<String, String> ttsParams = new HashMap<>();
-                    ttsParams.put(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, "");
-                    tts.setLanguage(new Locale("en", "US"));
-                    tts.speak("", android.speech.tts.TextToSpeech.QUEUE_FLUSH, ttsParams);
-                }
-                Set<Locale> availableLanguages = tts.getAvailableLanguages();
-                if (availableLanguages != null) {
-                    this.supportedLocales.addAll(availableLanguages);
-                }
-                ttsInitialized = true;
-            }
+            tts = new android.speech.tts.TextToSpeech(context, this);
         } catch (Exception ex) {
-            Log.d(TAG, "Caught exception while listening to OnInitListener.OnInit(): " + ex.getLocalizedMessage());
-
-            ttsInitialized = false;
+            Log.d(LOG_TAG, ex.getLocalizedMessage());
         }
     }
 
     @Override
-    public void load() {
-        super.load();
-
-        try {
-            context = getContext();
-            tts = new android.speech.tts.TextToSpeech(context, this);
-        } catch (Exception ex) {
-            Log.d(TAG, "Caught exception on TextToSpeech load(): " + ex.getLocalizedMessage());
-        }
+    public void onInit(int status) {
+        this.initializationStatus = status;
     }
 
-    @PluginMethod
-    public void speak(final PluginCall call) {
-        try {
-            String text = call.getString("text", "");
-            String locale = call.getString("locale", "en-US");
-            float speechRate = call.getFloat("speechRate", 1.0f);
-            float pitchRate = call.getFloat("pitchRate", 1.0f);
-            double volume = call.getDouble("volume", 1.0);
-
-            if (!supportedLocales.contains(Locale.forLanguageTag((locale)))) {
-                call.error(ERROR_UNSUPPORTED_LOCALE);
-                return;
-            }
-
-            if (tts == null || !ttsInitialized) {
-                call.error(ERROR_TTS_NOT_INITIALIZED);
-                return;
-            }
+    public void speak(
+        String text,
+        String lang,
+        float rate,
+        float pitch,
+        float volume,
+        String callbackId,
+        SpeakResultCallback resultCallback
+    ) {
+        tts.stop();
+        tts.setOnUtteranceProgressListener(
+            new UtteranceProgressListener() {
+                @Override
+                public void onStart(String utteranceId) {}
+
+                @Override
+                public void onDone(String utteranceId) {
+                    resultCallback.onDone();
+                }
 
-            tts.stop();
-
-            tts.setOnUtteranceProgressListener(
-                new UtteranceProgressListener() {
-                    @Override
-                    public void onStart(String utteranceId) {}
-
-                    @Override
-                    public void onDone(String utteranceId) {
-                        if (!utteranceId.equals("")) {
-                            call.success();
-                        }
-                    }
-
-                    @Override
-                    public void onError(String utteranceId) {
-                        if (!utteranceId.equals("")) {
-                            call.error(ERROR_UTTERANCE);
-                        }
-                    }
+                @Override
+                public void onError(String utteranceId) {
+                    resultCallback.onError();
                 }
-            );
-
-            if (Build.VERSION.SDK_INT >= 21) {
-                Bundle ttsParams = new Bundle();
-                ttsParams.putSerializable(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, call.getCallbackId());
-                ttsParams.putSerializable(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_VOLUME, volume);
-
-                tts.setLanguage(new Locale(locale));
-                tts.setSpeechRate(speechRate);
-                tts.setPitch(pitchRate);
-                tts.speak(text, android.speech.tts.TextToSpeech.QUEUE_FLUSH, ttsParams, call.getCallbackId());
-            } else {
-                HashMap<String, String> ttsParams = new HashMap<>();
-                ttsParams.put(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, call.getCallbackId());
-                ttsParams.put(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_VOLUME, Double.toString(volume));
-
-                tts.setLanguage(new Locale(locale));
-                tts.setPitch(pitchRate);
-                tts.speak(text, android.speech.tts.TextToSpeech.QUEUE_FLUSH, ttsParams);
             }
-        } catch (Exception ex) {
-            Log.d(TAG, "Exception caught while handling speak(): " + ex.getLocalizedMessage());
-            call.error(ex.getLocalizedMessage());
-        }
-    }
+        );
 
-    @PluginMethod
-    public void stop(PluginCall call) {
-        try {
-            tts.stop();
-            call.success();
-        } catch (Exception ex) {
-            Log.d(TAG, "Exception caught while handling stop(): " + ex.getLocalizedMessage());
-            call.error(ex.getLocalizedMessage());
-        }
-    }
+        Locale locale = Locale.forLanguageTag(lang);
 
-    @PluginMethod
-    public void getSupportedLanguages(PluginCall call) {
-        try {
-            ArrayList<String> languages = new ArrayList<>();
-            for (Locale supportedLocale : this.supportedLocales) {
-                String tag = supportedLocale.toLanguageTag();
-                languages.add(tag);
-            }
-            JSObject ret = new JSObject();
-            ret.put("languages", JSArray.from(languages.toArray()));
-            call.success(ret);
-        } catch (Exception ex) {
-            Log.d(TAG, "Exception caught while handling checkLanguage(): " + ex.getLocalizedMessage());
-            call.error(ex.getLocalizedMessage());
+        if (Build.VERSION.SDK_INT >= 21) {
+            Bundle ttsParams = new Bundle();
+            ttsParams.putSerializable(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, callbackId);
+            ttsParams.putSerializable(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_VOLUME, volume);
+
+            tts.setLanguage(locale);
+            tts.setSpeechRate(rate);
+            tts.setPitch(pitch);
+            tts.speak(text, android.speech.tts.TextToSpeech.QUEUE_FLUSH, ttsParams, callbackId);
+        } else {
+            HashMap<String, String> ttsParams = new HashMap<>();
+            ttsParams.put(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, callbackId);
+            ttsParams.put(android.speech.tts.TextToSpeech.Engine.KEY_PARAM_VOLUME, Float.toString(volume));
+
+            tts.setLanguage(locale);
+            tts.setSpeechRate(rate);
+            tts.setPitch(pitch);
+            tts.speak(text, android.speech.tts.TextToSpeech.QUEUE_FLUSH, ttsParams);
         }
     }
 
-    @PluginMethod
-    public void setPitchRate(final PluginCall call) {
-        float pitchRate = call.getFloat("pitchRate", 1.0f);
-        tts.setPitch(pitchRate);
-
-        call.success();
+    public void stop() {
+        tts.stop();
     }
 
-    @PluginMethod
-    public void setSpeechRate(final PluginCall call) {
-        float speechRate = call.getFloat("speechRate", 1.0f);
-
-        if (Build.VERSION.SDK_INT >= 27) {
-            tts.setSpeechRate((float) speechRate * 0.7f);
-        } else {
-            tts.setSpeechRate((float) speechRate);
+    public JSArray getSupportedLanguages() {
+        ArrayList<String> languages = new ArrayList<>();
+        Set<Locale> supportedLocales = tts.getAvailableLanguages();
+        for (Locale supportedLocale : supportedLocales) {
+            String tag = supportedLocale.toLanguageTag();
+            languages.add(tag);
         }
-
-        call.success();
+        JSArray result = JSArray.from(languages.toArray());
+        return result;
     }
 
-    @PluginMethod
-    public void openInstall(PluginCall call) {
-        try {
-            PackageManager packageManager = context.getPackageManager();
-            Intent installIntent = new Intent();
-            installIntent.setAction(android.speech.tts.TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
+    public JSArray getSupportedVoices() {
+        ArrayList<JSObject> voices = new ArrayList<>();
+        Set<Voice> supportedVoices = tts.getVoices();
+        for (Voice supportedVoice : supportedVoices) {
+            JSObject obj = this.convertVoiceToJSObject(supportedVoice);
+            voices.add(obj);
+        }
+        JSArray result = JSArray.from(voices.toArray());
+        return result;
+    }
 
-            ResolveInfo resolveInfo = packageManager.resolveActivity(installIntent, PackageManager.MATCH_DEFAULT_ONLY);
+    public void openInstall() {
+        PackageManager packageManager = context.getPackageManager();
+        Intent installIntent = new Intent();
+        installIntent.setAction(android.speech.tts.TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
 
-            if (resolveInfo == null) {} else {
-                installIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-                context.startActivity(installIntent);
-            }
+        ResolveInfo resolveInfo = packageManager.resolveActivity(installIntent, PackageManager.MATCH_DEFAULT_ONLY);
 
-            call.success();
-        } catch (Exception ex) {
-            Log.d(TAG, "Caught exception while handling openInstall(): " + ex.getLocalizedMessage());
+        if (resolveInfo != null) {
+            installIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            context.startActivity(installIntent);
+        }
+    }
 
-            call.error(ex.getLocalizedMessage());
+    public boolean isAvailable() {
+        if (tts != null && initializationStatus == android.speech.tts.TextToSpeech.SUCCESS) {
+            return true;
         }
+        return false;
     }
 
-    @PluginMethod
-    public void getSupportedVoices(PluginCall call) {
-        try {
-            ArrayList<JSObject> voices = new ArrayList<>();
-            Set<Voice> supportedVoices = tts.getVoices();
-            for (Voice supportedVoice : supportedVoices) {
-                JSObject obj = this.convertVoiceToJSObject(supportedVoice);
-                voices.add(obj);
-            }
-            JSObject ret = new JSObject();
-            ret.put("voices", JSArray.from(voices.toArray()));
-            call.success(ret);
-        } catch (Exception ex) {
-            call.error(ex.getLocalizedMessage());
+    public boolean isLanguageSupported(String lang) {
+        Locale locale = Locale.forLanguageTag(lang);
+        int result = tts.isLanguageAvailable(locale);
+        return result == tts.LANG_AVAILABLE || result == tts.LANG_COUNTRY_AVAILABLE || result == tts.LANG_COUNTRY_VAR_AVAILABLE;
+    }
+
+    public void onDestroy() {
+        if (tts == null) {
+            return;
         }
+        tts.stop();
+        tts.shutdown();
     }
 
     private JSObject convertVoiceToJSObject(Voice voice) {

package/android/src/main/java/com/getcapacitor/community/tts/TextToSpeechPlugin.java

@@ -0,0 +1,130 @@
+package com.getcapacitor.community.tts;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "TextToSpeech")
+public class TextToSpeechPlugin extends Plugin {
+
+    public static final String LOG_TAG = "TextToSpeechPlugin";
+
+    public static final String ERROR_UTTERANCE = "Failed to read text.";
+    public static final String ERROR_UNSUPPORTED_LANGUAGE = "This language is not supported.";
+
+    private TextToSpeech implementation;
+
+    @Override
+    public void load() {
+        implementation = new TextToSpeech(getContext());
+    }
+
+    @PluginMethod
+    public void speak(PluginCall call) {
+        boolean isAvailable = implementation.isAvailable();
+        if (!isAvailable) {
+            call.unavailable("Not yet initialized or not available on this device.");
+            return;
+        }
+
+        String text = call.getString("text", "");
+        String lang = call.getString("lang", "en-US");
+        float rate = call.getFloat("rate", 1.0f);
+        float pitch = call.getFloat("pitch", 1.0f);
+        float volume = call.getFloat("volume", 1.0f);
+
+        boolean isLanguageSupported = implementation.isLanguageSupported(lang);
+        if (!isLanguageSupported) {
+            call.reject(ERROR_UNSUPPORTED_LANGUAGE);
+            return;
+        }
+
+        SpeakResultCallback resultCallback = new SpeakResultCallback() {
+            @Override
+            public void onDone() {
+                call.resolve();
+            }
+
+            @Override
+            public void onError() {
+                call.reject(ERROR_UTTERANCE);
+            }
+        };
+
+        try {
+            implementation.speak(text, lang, rate, pitch, volume, call.getCallbackId(), resultCallback);
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage());
+        }
+    }
+
+    @PluginMethod
+    public void stop(PluginCall call) {
+        boolean isAvailable = implementation.isAvailable();
+        if (!isAvailable) {
+            call.unavailable("Not yet initialized or not available on this device.");
+            return;
+        }
+        try {
+            implementation.stop();
+            call.resolve();
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getSupportedLanguages(PluginCall call) {
+        try {
+            JSArray languages = implementation.getSupportedLanguages();
+            JSObject ret = new JSObject();
+            ret.put("languages", languages);
+            call.resolve(ret);
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getSupportedVoices(PluginCall call) {
+        try {
+            JSArray voices = implementation.getSupportedVoices();
+            JSObject ret = new JSObject();
+            ret.put("voices", voices);
+            call.resolve(ret);
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage());
+        }
+    }
+
+    @PluginMethod
+    public void isLanguageSupported(PluginCall call) {
+        String lang = call.getString("lang", "");
+        try {
+            boolean isLanguageSupported = implementation.isLanguageSupported(lang);
+            JSObject ret = new JSObject();
+            ret.put("supported", isLanguageSupported);
+            call.resolve(ret);
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage());
+        }
+    }
+
+    @PluginMethod
+    public void openInstall(PluginCall call) {
+        try {
+            implementation.openInstall();
+            call.resolve();
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage());
+        }
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        implementation.onDestroy();
+    }
+}

package/dist/docs.json

@@ -0,0 +1,194 @@
+{
+  "api": {
+    "name": "TextToSpeechPlugin",
+    "slug": "texttospeechplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "speak",
+        "signature": "(options: TTSOptions) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "TTSOptions"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Starts the TTS engine and plays the desired text.",
+        "complexTypes": [
+          "TTSOptions"
+        ],
+        "slug": "speak"
+      },
+      {
+        "name": "stop",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Stops the TTS engine.",
+        "complexTypes": [],
+        "slug": "stop"
+      },
+      {
+        "name": "getSupportedLanguages",
+        "signature": "() => Promise<{ languages: string[]; }>",
+        "parameters": [],
+        "returns": "Promise<{ languages: string[]; }>",
+        "tags": [],
+        "docs": "Returns a list of supported BCP 47 language tags.",
+        "complexTypes": [],
+        "slug": "getsupportedlanguages"
+      },
+      {
+        "name": "getSupportedVoices",
+        "signature": "() => Promise<{ voices: SpeechSynthesisVoice[]; }>",
+        "parameters": [],
+        "returns": "Promise<{ voices: SpeechSynthesisVoice[]; }>",
+        "tags": [],
+        "docs": "Returns a list of supported voices.",
+        "complexTypes": [
+          "SpeechSynthesisVoice"
+        ],
+        "slug": "getsupportedvoices"
+      },
+      {
+        "name": "isLanguageSupported",
+        "signature": "(options: { lang: string; }) => Promise<{ supported: boolean; }>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ lang: string; }"
+          }
+        ],
+        "returns": "Promise<{ supported: boolean; }>",
+        "tags": [],
+        "docs": "Checks if a specific BCP 47 language tag is supported.",
+        "complexTypes": [],
+        "slug": "islanguagesupported"
+      },
+      {
+        "name": "openInstall",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Verifies proper installation and availability of resource files on the system.\n\nOnly available for Android.",
+        "complexTypes": [],
+        "slug": "openinstall"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "TTSOptions",
+      "slug": "ttsoptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "text",
+          "tags": [],
+          "docs": "The text that will be synthesised when the utterance is spoken.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "lang",
+          "tags": [],
+          "docs": "The language of the utterance.\nPossible languages can be queried using `getSupportedLanguages`.\n\nDefault: `en-US`.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "rate",
+          "tags": [],
+          "docs": "The speed at which the utterance will be spoken at.\n\nDefault: `1.0`.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "pitch",
+          "tags": [],
+          "docs": "The pitch at which the utterance will be spoken at.\n\nDefault: `1.0`.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "volume",
+          "tags": [],
+          "docs": "The volume that the utterance will be spoken at.\n\nDefault: `1.0`.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "voice",
+          "tags": [],
+          "docs": "The index of the selected voice that will be used to speak the utterance.\nPossible voices can be queried using `getSupportedVoices`.\n\nOnly available for Web.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "category",
+          "tags": [],
+          "docs": "Select the iOS Audio session category.\nPossible values: `ambient` and `playback`.\nUse `playback` to play audio even when the app is in the background.\n\nOnly available for iOS.\n\nDefault: `ambient`.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        }
+      ]
+    },
+    {
+      "name": "SpeechSynthesisVoice",
+      "slug": "speechsynthesisvoice",
+      "docs": "The SpeechSynthesisVoice interface represents a voice that the system supports.",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "default",
+          "tags": [],
+          "docs": "Specifies whether the voice is the default voice for the current app (`true`) or not (`false`).",
+          "complexTypes": [],
+          "type": "boolean"
+        },
+        {
+          "name": "lang",
+          "tags": [],
+          "docs": "BCP 47 language tag indicating the language of the voice.\nExample: `en-US`.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "localService",
+          "tags": [],
+          "docs": "Specifies whether the voice is supplied by a local (`true`) or remote (`false`) speech synthesizer service.",
+          "complexTypes": [],
+          "type": "boolean"
+        },
+        {
+          "name": "name",
+          "tags": [],
+          "docs": "Human-readable name that represents the voice.\nExample: `Microsoft Zira Desktop - English (United States)`.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "voiceURI",
+          "tags": [],
+          "docs": "Type of URI and location of the speech synthesis service for this voice.\nExample: `urn:moz-tts:sapi:Microsoft Zira Desktop - English (United States)?en-US`.",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}