npm - @codingame/monaco-vscode-speech-service-override - Versions diffs - 3.2.2 → 4.0.0 - Mend

@codingame/monaco-vscode-speech-service-override 3.2.2 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/package.json +2 -2
package/vscode/src/vs/workbench/contrib/speech/browser/speechService.js +109 -33

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-speech-service-override",
-  "version": "3.2.2",
+  "version": "4.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@3.2.2"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.0.0"
   }
 }

package/vscode/src/vs/workbench/contrib/speech/browser/speechService.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
@@ -7,24 +8,63 @@ import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
 import { DeferredPromise } from 'vscode/vscode/vs/base/common/async';
-import { HasSpeechProvider, SpeechToTextInProgress, SpeechToTextStatus, KeywordRecognitionStatus } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
+import { HasSpeechProvider, SpeechToTextInProgress, speechLanguageConfigToLanguage, SPEECH_LANGUAGE_CONFIG, SpeechToTextStatus, KeywordRecognitionStatus } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { AccessibilitySignal, IAccessibilitySignalService } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+const speechProvidersExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'speechProviders',
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/speech/browser/speechService',
+            'vscode.extension.contributes.speechProvider',
+            'Contributes a Speech Provider'
+        )),
+        type: 'array',
+        items: {
+            additionalProperties: false,
+            type: 'object',
+            defaultSnippets: [{ body: { name: '', description: '' } }],
+            required: ['name'],
+            properties: {
+                name: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/speech/browser/speechService',
+                        'speechProviderName',
+                        "Unique name for this Speech Provider."
+                    )),
+                    type: 'string'
+                },
+                description: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/speech/browser/speechService',
+                        'speechProviderDescription',
+                        "A description of this Speech Provider, shown in the UI."
+                    )),
+                    type: 'string'
+                }
+            }
+        }
+    }
+});
 let SpeechService = class SpeechService extends Disposable {
-    get hasSpeechProvider() { return this.providers.size > 0; }
-    constructor(logService, contextKeyService, hostService, telemetryService, configurationService) {
+    get hasSpeechProvider() { return this.providerDescriptors.size > 0 || this.providers.size > 0; }
+    constructor(logService, contextKeyService, hostService, telemetryService, configurationService, accessibilitySignalService, extensionService) {
         super();
         this.logService = logService;
         this.contextKeyService = contextKeyService;
         this.hostService = hostService;
         this.telemetryService = telemetryService;
         this.configurationService = configurationService;
-        this._onDidRegisterSpeechProvider = this._register(( new Emitter()));
-        this.onDidRegisterSpeechProvider = this._onDidRegisterSpeechProvider.event;
-        this._onDidUnregisterSpeechProvider = this._register(( new Emitter()));
-        this.onDidUnregisterSpeechProvider = this._onDidUnregisterSpeechProvider.event;
+        this.accessibilitySignalService = accessibilitySignalService;
+        this.extensionService = extensionService;
+        this._onDidChangeHasSpeechProvider = this._register(( new Emitter()));
+        this.onDidChangeHasSpeechProvider = this._onDidChangeHasSpeechProvider.event;
         this.providers = ( new Map());
+        this.providerDescriptors = ( new Map());
         this.hasSpeechProviderContext = HasSpeechProvider.bindTo(this.contextKeyService);
         this._onDidStartSpeechToTextSession = this._register(( new Emitter()));
         this.onDidStartSpeechToTextSession = this._onDidStartSpeechToTextSession.event;
@@ -37,45 +77,68 @@ let SpeechService = class SpeechService extends Disposable {
         this._onDidEndKeywordRecognition = this._register(( new Emitter()));
         this.onDidEndKeywordRecognition = this._onDidEndKeywordRecognition.event;
         this._activeKeywordRecognitionSession = undefined;
+        this.handleAndRegisterSpeechExtensions();
+    }
+    handleAndRegisterSpeechExtensions() {
+        speechProvidersExtensionPoint.setHandler((extensions, delta) => {
+            const oldHasSpeechProvider = this.hasSpeechProvider;
+            for (const extension of delta.removed) {
+                for (const descriptor of extension.value) {
+                    this.providerDescriptors.delete(descriptor.name);
+                }
+            }
+            for (const extension of delta.added) {
+                for (const descriptor of extension.value) {
+                    this.providerDescriptors.set(descriptor.name, descriptor);
+                }
+            }
+            if (oldHasSpeechProvider !== this.hasSpeechProvider) {
+                this.handleHasSpeechProviderChange();
+            }
+        });
     }
     registerSpeechProvider(identifier, provider) {
         if (( this.providers.has(identifier))) {
             throw new Error(`Speech provider with identifier ${identifier} is already registered.`);
         }
+        const oldHasSpeechProvider = this.hasSpeechProvider;
         this.providers.set(identifier, provider);
-        this.hasSpeechProviderContext.set(true);
-        this._onDidRegisterSpeechProvider.fire(provider);
+        if (oldHasSpeechProvider !== this.hasSpeechProvider) {
+            this.handleHasSpeechProviderChange();
+        }
         return toDisposable(() => {
+            const oldHasSpeechProvider = this.hasSpeechProvider;
             this.providers.delete(identifier);
-            this._onDidUnregisterSpeechProvider.fire(provider);
-            if (this.providers.size === 0) {
-                this.hasSpeechProviderContext.set(false);
+            if (oldHasSpeechProvider !== this.hasSpeechProvider) {
+                this.handleHasSpeechProviderChange();
             }
         });
     }
+    handleHasSpeechProviderChange() {
+        this.hasSpeechProviderContext.set(this.hasSpeechProvider);
+        this._onDidChangeHasSpeechProvider.fire();
+    }
     get hasActiveSpeechToTextSession() { return !!this._activeSpeechToTextSession; }
-    createSpeechToTextSession(token, context = 'speech') {
-        const provider = firstOrDefault(Array.from(( this.providers.values())));
-        if (!provider) {
-            throw new Error(`No Speech provider is registered.`);
-        }
-        else if (this.providers.size > 1) {
-            this.logService.warn(`Multiple speech providers registered. Picking first one: ${provider.metadata.displayName}`);
-        }
-        const language = this.configurationService.getValue('accessibility.voice.speechLanguage');
+    async createSpeechToTextSession(token, context = 'speech') {
+        const provider = await this.getProvider();
+        const language = speechLanguageConfigToLanguage(this.configurationService.getValue(SPEECH_LANGUAGE_CONFIG));
         const session = this._activeSpeechToTextSession = provider.createSpeechToTextSession(token, typeof language === 'string' ? { language } : undefined);
         const sessionStart = Date.now();
         let sessionRecognized = false;
+        let sessionContentLength = 0;
         const disposables = ( new DisposableStore());
         const onSessionStoppedOrCanceled = () => {
             if (session === this._activeSpeechToTextSession) {
                 this._activeSpeechToTextSession = undefined;
                 this.speechToTextInProgress.reset();
+                this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStopped, { allowManyInParallel: true });
                 this._onDidEndSpeechToTextSession.fire();
                 this.telemetryService.publicLog2('speechToTextSession', {
                     context,
-                    duration: Date.now() - sessionStart,
-                    recognized: sessionRecognized
+                    sessionDuration: Date.now() - sessionStart,
+                    sessionRecognized,
+                    sessionContentLength,
+                    sessionLanguage: language
                 });
             }
             disposables.dispose();
@@ -90,12 +153,17 @@ let SpeechService = class SpeechService extends Disposable {
                     if (session === this._activeSpeechToTextSession) {
                         this.speechToTextInProgress.set(true);
                         this._onDidStartSpeechToTextSession.fire();
+                        this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStarted);
                     }
                     break;
                 case SpeechToTextStatus.Recognizing:
-                case SpeechToTextStatus.Recognized:
                     sessionRecognized = true;
                     break;
+                case SpeechToTextStatus.Recognized:
+                    if (typeof e.text === 'string') {
+                        sessionContentLength += e.text.length;
+                    }
+                    break;
                 case SpeechToTextStatus.Stopped:
                     onSessionStoppedOrCanceled();
                     break;
@@ -103,9 +171,21 @@ let SpeechService = class SpeechService extends Disposable {
         }));
         return session;
     }
+    async getProvider() {
+        await this.extensionService.activateByEvent('onSpeech');
+        const provider = firstOrDefault(Array.from(( this.providers.values())));
+        if (!provider) {
+            throw new Error(`No Speech provider is registered.`);
+        }
+        else if (this.providers.size > 1) {
+            this.logService.warn(`Multiple speech providers registered. Picking first one: ${provider.metadata.displayName}`);
+        }
+        return provider;
+    }
     get hasActiveKeywordRecognition() { return !!this._activeKeywordRecognitionSession; }
     async recognizeKeyword(token) {
         const result = ( new DeferredPromise());
+        await this.extensionService.activateByEvent('onSpeech');
         const disposables = ( new DisposableStore());
         disposables.add(token.onCancellationRequested(() => {
             disposables.dispose();
@@ -147,18 +227,12 @@ let SpeechService = class SpeechService extends Disposable {
             disposables.dispose();
         }
         this.telemetryService.publicLog2('keywordRecognition', {
-            recognized: status === KeywordRecognitionStatus.Recognized
+            keywordRecognized: status === KeywordRecognitionStatus.Recognized
         });
         return status;
     }
     async doRecognizeKeyword(token) {
-        const provider = firstOrDefault(Array.from(( this.providers.values())));
-        if (!provider) {
-            throw new Error(`No Speech provider is registered.`);
-        }
-        else if (this.providers.size > 1) {
-            this.logService.warn(`Multiple speech providers registered. Picking first one: ${provider.metadata.displayName}`);
-        }
+        const provider = await this.getProvider();
         const session = this._activeKeywordRecognitionSession = provider.createKeywordRecognitionSession(token);
         this._onDidStartKeywordRecognition.fire();
         const disposables = ( new DisposableStore());
@@ -191,7 +265,9 @@ SpeechService = ( __decorate([
     ( __param(1, IContextKeyService)),
     ( __param(2, IHostService)),
     ( __param(3, ITelemetryService)),
-    ( __param(4, IConfigurationService))
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IAccessibilitySignalService)),
+    ( __param(6, IExtensionService))
 ], SpeechService));
 export { SpeechService };