@wenlongche/nativescript-speech-recognition 2.0.0

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./speech-recognition.ios";
+
+export * from "./speech-recognition.common";

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@wenlongche/nativescript-speech-recognition",
+  "version": "2.0.0",
+  "description": "Fork of nativescript-speech-recognition - Speech to text plugin, leveraging iOS and Android's built-in recognition engines.",
+  "main": "speech-recognition",
+  "typings": "index.d.ts",
+  "nativescript": {
+    "platforms": {
+      "android": "3.0.0",
+      "ios": "3.0.0"
+    }
+  },
+  "scripts": {
+    "tsc": "tsc -skipLibCheck",
+    "build": "npm i && npm run tsc",
+    "postclone": "npm i && cd ../demo && npm i && cd ../src && npm run plugin.link",
+    "test.android": "npm i && npm run tsc && npm run tslint && cd ../demo && tns build android && tns test android --justlaunch",
+    "test.ios": "npm i && npm run tsc && npm run tslint && cd ../demo && tns build ios && tns test ios --justlaunch",
+    "tslint": "cd .. && tslint \"**/*.ts\" --config tslint.json --exclude \"**/node_modules/**\"",
+    "plugin.link": "npm link && cd ../demo && npm link @wenlongche/nativescript-speech-recognition && cd ../src",
+    "plugin.tscwatch": "npm run tsc -- -w",
+    "demo.ios": "npm run build && cd ../demo && tns run ios",
+    "demo.android": "npm run build && cd ../demo && tns run android",
+    "demo.android.clean": "npm run build && cd ../demo && tns plugin remove nativescript-speech-recognition && tns plugin add ../src && tns run android",
+    "demo.reset": "cd ../demo && rimraf platforms",
+    "plugin.prepare": "npm run tsc && cd ../demo && tns plugin remove nativescript-speech-recognition && tns plugin add ../src",
+    "clean": "cd ../demo && rimraf hooks node_modules platforms && cd ../src && rimraf node_modules && npm run plugin.link",
+    "ci.tslint": "npm i && tslint '**/*.ts' --config '../tslint.json' --exclude '**/node_modules/**'",
+    "changelog": "conventional-changelog -i ../CHANGELOG.md -s -r 0",
+    "changelog:add": "git add ../CHANGELOG.md && git commit -m 'updated CHANGELOG.md'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wenlongche/nativescript-speech-recognition.git"
+  },
+  "keywords": [
+    "NativeScript",
+    "JavaScript",
+    "iOS",
+    "Siri",
+    "Speech to text",
+    "Speech",
+    "Recognition",
+    "Voice"
+  ],
+  "author": {
+    "name": "Wenlong Che",
+    "email": "wenlong.che@gmail.com"
+  },
+  "contributors": [
+    {
+      "name": "Eddy Verbruggen",
+      "email": "eddyverbruggen@gmail.com",
+      "url": "https://github.com/EddyVerbruggen"
+    },
+    {
+      "name": "Brad Martin",
+      "email": "bradwaynemartin@gmail.com",
+      "url": "https://github.com/bradmartin"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/wenlongche/nativescript-speech-recognition/issues"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/wenlongche/nativescript-speech-recognition",
+  "readmeFilename": "README.md",
+  "devDependencies": {
+    "@nativescript/core": "~7.0.5",
+    "@nativescript/types": "~7.0.4",
+    "conventional-changelog-cli": "^1.3.2",
+    "rimraf": "^3.0.2",
+    "tslint": "~6.1.3",
+    "typescript": "~3.9.7"
+  }
+}

package/platforms/ios/Info.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>NSSpeechRecognitionUsageDescription</key>
+    <string> </string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string> </string>
+  </dict>
+</plist>

package/speech-recognition.android.d.ts

@@ -0,0 +1,15 @@
+import { SpeechRecognitionApi, SpeechRecognitionOptions } from "./speech-recognition.common";
+export declare class SpeechRecognition implements SpeechRecognitionApi {
+    private onPermissionGranted;
+    private onPermissionRejected;
+    private recognizer;
+    private listeningIntent;
+    private accumulatedText;
+    constructor();
+    available(): Promise<boolean>;
+    requestPermission(): Promise<boolean>;
+    startListening(options: SpeechRecognitionOptions): Promise<boolean>;
+    stopListening(): Promise<any>;
+    private wasPermissionGranted;
+    private _requestPermission;
+}

package/speech-recognition.android.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechRecognition = void 0;
+var core_1 = require("@nativescript/core");
+var AppPackageName = useAndroidX() ? global.androidx.core.app : android.support.v4.app;
+var ContentPackageName = useAndroidX() ? global.androidx.core.content : android.support.v4.content;
+function useAndroidX() {
+    return global.androidx && global.androidx.appcompat;
+}
+var SpeechRecognition = (function () {
+    function SpeechRecognition() {
+        var _this = this;
+        this.recognizer = null;
+        this.listeningIntent = null;
+        this.accumulatedText = "";
+        var self = this;
+        core_1.Application.android.on(core_1.AndroidApplication.activityRequestPermissionsEvent, function (args) {
+            for (var i = 0; i < args.permissions.length; i++) {
+                if (args.grantResults[i] === android.content.pm.PackageManager.PERMISSION_DENIED) {
+                    if (self.onPermissionRejected) {
+                        self.onPermissionRejected("Please allow access to the Microphone and try again.");
+                    }
+                    else {
+                        console.log("Please allow access to the Microphone and try again. (tip: pass in a reject to receive this message in your app)");
+                    }
+                    return;
+                }
+            }
+            if (self.onPermissionGranted) {
+                self.onPermissionGranted();
+            }
+        });
+        core_1.Application.on(core_1.Application.suspendEvent, function (args) {
+            if (_this.recognizer !== null) {
+                _this.stopListening();
+            }
+        });
+    }
+    SpeechRecognition.prototype.available = function () {
+        return new Promise(function (resolve, reject) {
+            resolve(android.speech.SpeechRecognizer.isRecognitionAvailable(core_1.Utils.android.getApplicationContext()));
+        });
+    };
+    SpeechRecognition.prototype.requestPermission = function () {
+        var _this = this;
+        console.log(">> requestPermission");
+        return new Promise(function (resolve, reject) {
+            _this._requestPermission(function () { return resolve(true); }, function () { return resolve(false); });
+        });
+    };
+    SpeechRecognition.prototype.startListening = function (options) {
+        var _this = this;
+        console.log(">> startListening");
+        return new Promise(function (resolve, reject) {
+            var onPermissionGranted = function () {
+                var self = _this;
+                function sendBackResults(results, partial) {
+                    var transcripts = results.getStringArrayList(android.speech.SpeechRecognizer.RESULTS_RECOGNITION);
+                    var transcript = null;
+                    if (!transcripts.isEmpty()) {
+                        transcript = transcripts.get(0);
+                    }
+                    if (options.listenContinuously) {
+                        if (!partial && transcript) {
+                            if (self.accumulatedText.length > 0) {
+                                self.accumulatedText += " " + transcript;
+                            }
+                            else {
+                                self.accumulatedText = transcript;
+                            }
+                            transcript = self.accumulatedText;
+                        }
+                        else if (partial && transcript) {
+                            transcript = self.accumulatedText.length > 0
+                                ? self.accumulatedText + " " + transcript
+                                : transcript;
+                        }
+                    }
+                    if (transcript) {
+                        options.onResult({
+                            text: transcript,
+                            finished: !partial
+                        });
+                    }
+                }
+                var loopHandler = new android.os.Handler(android.os.Looper.getMainLooper());
+                loopHandler.post(new java.lang.Runnable({
+                    run: function () {
+                        _this.recognizer = android.speech.SpeechRecognizer.createSpeechRecognizer(core_1.Utils.android.getApplicationContext());
+                        _this.recognizer.setRecognitionListener(new android.speech.RecognitionListener({
+                            onReadyForSpeech: function (params) {
+                                resolve(true);
+                            },
+                            onBeginningOfSpeech: function () {
+                            },
+                            onRmsChanged: function (rmsdB) {
+                            },
+                            onBufferReceived: function (buffer) {
+                            },
+                            onEndOfSpeech: function () {
+                            },
+                            onError: function (error) {
+                                console.log("Error: " + error);
+                                if (options.listenContinuously && self.recognizer && self.listeningIntent &&
+                                    (error === android.speech.SpeechRecognizer.ERROR_SPEECH_TIMEOUT ||
+                                        error === android.speech.SpeechRecognizer.ERROR_NO_MATCH)) {
+                                    self.recognizer.cancel();
+                                    self.recognizer.startListening(self.listeningIntent);
+                                }
+                                else {
+                                    options.onError && options.onError(error);
+                                    reject(error);
+                                }
+                            },
+                            onResults: function (results) {
+                                sendBackResults(results, false);
+                                if (options.listenContinuously && self.recognizer && self.listeningIntent) {
+                                    self.recognizer.startListening(self.listeningIntent);
+                                }
+                            },
+                            onPartialResults: function (partialResults) {
+                                if (options.returnPartialResults) {
+                                    sendBackResults(partialResults, true);
+                                }
+                            },
+                            onEvent: function (eventType, params) {
+                            }
+                        }));
+                    }
+                }));
+                var intent = new android.content.Intent(android.speech.RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
+                intent.putExtra(android.speech.RecognizerIntent.EXTRA_LANGUAGE_MODEL, android.speech.RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
+                intent.putExtra(android.speech.RecognizerIntent.EXTRA_CALLING_PACKAGE, "voice.recognition.test");
+                if (options.locale) {
+                    intent.putExtra(android.speech.RecognizerIntent.EXTRA_LANGUAGE, options.locale);
+                }
+                if (options.returnPartialResults) {
+                    intent.putExtra(android.speech.RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
+                }
+                intent.putExtra(android.speech.RecognizerIntent.EXTRA_MAX_RESULTS, 100);
+                if (options.listenContinuously) {
+                    _this.listeningIntent = intent;
+                    _this.accumulatedText = "";
+                }
+                loopHandler.post(new java.lang.Runnable({
+                    run: function () {
+                        _this.recognizer.startListening(intent);
+                    }
+                }));
+            };
+            if (!_this.wasPermissionGranted()) {
+                _this._requestPermission(onPermissionGranted, reject);
+                return;
+            }
+            onPermissionGranted();
+        });
+    };
+    SpeechRecognition.prototype.stopListening = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (_this.recognizer === null) {
+                reject("Not running");
+                return;
+            }
+            var loopHandler = new android.os.Handler(android.os.Looper.getMainLooper());
+            loopHandler.post(new java.lang.Runnable({
+                run: function () {
+                    _this.recognizer.stopListening();
+                    _this.recognizer.cancel();
+                    _this.recognizer.destroy();
+                    _this.recognizer = null;
+                    _this.listeningIntent = null;
+                    _this.accumulatedText = "";
+                    resolve();
+                }
+            }));
+        });
+    };
+    SpeechRecognition.prototype.wasPermissionGranted = function () {
+        var hasPermission = android.os.Build.VERSION.SDK_INT < 23;
+        if (!hasPermission) {
+            hasPermission = android.content.pm.PackageManager.PERMISSION_GRANTED ===
+                ContentPackageName.ContextCompat.checkSelfPermission(core_1.Utils.android.getApplicationContext(), android.Manifest.permission.RECORD_AUDIO);
+        }
+        return hasPermission;
+    };
+    SpeechRecognition.prototype._requestPermission = function (onPermissionGranted, reject) {
+        this.onPermissionGranted = onPermissionGranted;
+        this.onPermissionRejected = reject;
+        AppPackageName.ActivityCompat.requestPermissions(core_1.Application.android.foregroundActivity || core_1.Application.android.startActivity, [android.Manifest.permission.RECORD_AUDIO], 444);
+    };
+    return SpeechRecognition;
+}());
+exports.SpeechRecognition = SpeechRecognition;
+//# sourceMappingURL=speech-recognition.android.js.map

package/speech-recognition.common.d.ts

@@ -0,0 +1,17 @@
+export interface SpeechRecognitionTranscription {
+    text: string;
+    finished: boolean;
+}
+export interface SpeechRecognitionOptions {
+    locale?: string;
+    returnPartialResults?: boolean;
+    listenContinuously?: boolean;
+    onResult: (transcription: SpeechRecognitionTranscription) => void;
+    onError?: (error: string | number) => void;
+}
+export interface SpeechRecognitionApi {
+    available(): Promise<boolean>;
+    requestPermission(): Promise<boolean>;
+    startListening(options: SpeechRecognitionOptions): Promise<boolean>;
+    stopListening(): Promise<any>;
+}

package/speech-recognition.common.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=speech-recognition.common.js.map

package/speech-recognition.ios.d.ts

@@ -0,0 +1,14 @@
+import { SpeechRecognitionApi, SpeechRecognitionOptions } from "./speech-recognition.common";
+export declare class SpeechRecognition implements SpeechRecognitionApi {
+    private recognitionRequest;
+    private audioEngine;
+    private speechRecognizer;
+    private recognitionTask;
+    private inputNode;
+    private audioSession;
+    constructor();
+    available(): Promise<boolean>;
+    requestPermission(): Promise<boolean>;
+    startListening(options: SpeechRecognitionOptions): Promise<boolean>;
+    stopListening(): Promise<any>;
+}

package/speech-recognition.ios.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechRecognition = void 0;
+var core_1 = require("@nativescript/core");
+var SpeechRecognition = (function () {
+    function SpeechRecognition() {
+        this.recognitionRequest = null;
+        this.audioEngine = null;
+        this.speechRecognizer = null;
+        this.recognitionTask = null;
+        this.inputNode = null;
+        this.audioSession = null;
+        this.audioEngine = AVAudioEngine.new();
+    }
+    SpeechRecognition.prototype.available = function () {
+        return new Promise(function (resolve, reject) {
+            resolve(parseInt(core_1.Device.osVersion) >= 10);
+        });
+    };
+    SpeechRecognition.prototype.requestPermission = function () {
+        return new Promise(function (resolve, reject) {
+            SFSpeechRecognizer.requestAuthorization(function (status) {
+                if (status !== 3) {
+                    resolve(false);
+                    return;
+                }
+                AVAudioSession.sharedInstance().requestRecordPermission(function (granted) {
+                    resolve(granted);
+                });
+            });
+        });
+    };
+    SpeechRecognition.prototype.startListening = function (options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var locale = NSLocale.alloc().initWithLocaleIdentifier(options.locale ? options.locale : core_1.Device.language);
+            _this.speechRecognizer = SFSpeechRecognizer.alloc().initWithLocale(locale);
+            if (_this.recognitionTask !== null) {
+                _this.recognitionTask.cancel();
+                _this.recognitionTask = null;
+            }
+            SFSpeechRecognizer.requestAuthorization(function (status) {
+                if (status !== 3) {
+                    options.onError && options.onError("Not authorized");
+                    reject("Not authorized");
+                    return;
+                }
+                _this.audioSession = AVAudioSession.sharedInstance();
+                _this.audioSession.setCategoryError(AVAudioSessionCategoryRecord);
+                _this.audioSession.setModeError(AVAudioSessionModeMeasurement);
+                _this.audioSession.setActiveWithOptionsError(true, 1);
+                _this.recognitionRequest = SFSpeechAudioBufferRecognitionRequest.new();
+                if (!_this.recognitionRequest) {
+                    options.onError && options.onError("Unable to create an SFSpeechAudioBufferRecognitionRequest object");
+                    reject("Unable to create an SFSpeechAudioBufferRecognitionRequest object");
+                    return;
+                }
+                _this.inputNode = _this.audioEngine.inputNode;
+                if (!_this.inputNode) {
+                    options.onError && options.onError("Audio engine has no input node");
+                    reject("Audio engine has no input node");
+                    return;
+                }
+                _this.recognitionRequest.shouldReportPartialResults = options.returnPartialResults;
+                _this.recognitionTask = _this.speechRecognizer.recognitionTaskWithRequestResultHandler(_this.recognitionRequest, function (result, error) {
+                    if (result !== null) {
+                        options.onResult({
+                            finished: result.final,
+                            text: result.bestTranscription.formattedString
+                        });
+                    }
+                    if (error !== null || (result !== null && result.final)) {
+                        _this.audioEngine.stop();
+                        _this.inputNode.removeTapOnBus(0);
+                        _this.audioSession.setCategoryError(AVAudioSessionCategoryPlayback);
+                        _this.audioSession.setModeError(AVAudioSessionModeDefault);
+                        _this.recognitionRequest = null;
+                        _this.recognitionTask = null;
+                    }
+                    if (error !== null) {
+                        console.log("error in handler: " + error.localizedDescription);
+                        options.onError && options.onError(error.localizedDescription);
+                    }
+                });
+                var that = _this;
+                var recordingFormat = _this.inputNode.outputFormatForBus(0);
+                _this.inputNode.installTapOnBusBufferSizeFormatBlock(0, 1024, recordingFormat, function (buffer, when) {
+                    that.recognitionRequest.appendAudioPCMBuffer(buffer);
+                });
+                _this.audioEngine.prepare();
+                resolve(_this.audioEngine.startAndReturnError());
+            });
+        });
+    };
+    SpeechRecognition.prototype.stopListening = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (!_this.audioEngine.running) {
+                reject("Not running");
+                return;
+            }
+            _this.audioEngine.stop();
+            _this.recognitionRequest.endAudio();
+            _this.audioSession.setCategoryError(AVAudioSessionCategoryPlayback);
+            _this.audioSession.setModeError(AVAudioSessionModeDefault);
+            _this.speechRecognizer = null;
+            _this.recognitionTask = null;
+            resolve();
+        });
+    };
+    return SpeechRecognition;
+}());
+exports.SpeechRecognition = SpeechRecognition;
+//# sourceMappingURL=speech-recognition.ios.js.map