add hold for speech command to inline chat which is for when a session already started (microsoft#202741)

* - cancel quick voice when loosing focus

* add hold for speech command to inline chat which is for when a session already started

Author: jrieken

src/vs/workbench/contrib/inlineChat/electron-sandbox/inlineChat.contribution.ts

@@ -6,11 +6,12 @@
 import { EditorContributionInstantiation, registerEditorContribution } from 'vs/editor/browser/editorExtensions';
 import { registerAction2 } from 'vs/platform/actions/common/actions';
 import { CancelAction, InlineChatQuickVoice, StartAction, StopAction } from 'vs/workbench/contrib/inlineChat/electron-sandbox/inlineChatQuickVoice';
-import * as StartSessionAction from './inlineChatActions';
+import { StartSessionAction, HoldToSpeak } from './inlineChatActions';
 
 // start and hold for voice
 
-registerAction2(StartSessionAction.StartSessionAction);
+registerAction2(StartSessionAction);
+registerAction2(HoldToSpeak);
 
 // quick voice
 

src/vs/workbench/contrib/inlineChat/electron-sandbox/inlineChatActions.ts

@@ -16,9 +16,10 @@ import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { StartVoiceChatAction, StopListeningAction } from 'vs/workbench/contrib/chat/electron-sandbox/actions/voiceChatActions';
-import { CTX_INLINE_CHAT_HAS_PROVIDER, InlineChatConfigKeys } from 'vs/workbench/contrib/inlineChat/common/inlineChat';
+import { CTX_INLINE_CHAT_HAS_PROVIDER, CTX_INLINE_CHAT_VISIBLE, InlineChatConfigKeys } from 'vs/workbench/contrib/inlineChat/common/inlineChat';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { ISpeechService } from 'vs/workbench/contrib/speech/common/speechService';
+import { HasSpeechProvider, ISpeechService } from 'vs/workbench/contrib/speech/common/speechService';
+import { localize2 } from 'vs/nls';
 
 
 export class StartSessionAction extends EditorAction2 {
@@ -45,31 +46,11 @@ export class StartSessionAction extends EditorAction2 {
 
 		const configService = accessor.get(IConfigurationService);
 		const speechService = accessor.get(ISpeechService);
-		const keybindingService = accessor.get(IKeybindingService);
-		const commandService = accessor.get(ICommandService);
 
 		if (configService.getValue<boolean>(InlineChatConfigKeys.HoldToSpeech) // enabled
 			&& speechService.hasSpeechProvider // possible
 		) {
-
-			const holdMode = keybindingService.enableKeybindingHoldMode(this.desc.id);
-			if (holdMode) { // holding keys
-				let listening = false;
-				const handle = disposableTimeout(() => {
-					// start VOICE input
-					commandService.executeCommand(StartVoiceChatAction.ID);
-					listening = true;
-				}, 250);
-
-				holdMode.finally(() => {
-					if (listening) {
-						commandService.executeCommand(StopListeningAction.ID).finally(() => {
-							InlineChatController.get(editor)?.acceptInput();
-						});
-					}
-					handle.dispose();
-				});
-			}
+			holdForSpeech(accessor, InlineChatController.get(editor), this.desc.id);
 		}
 
 		let options: InlineChatRunOptions | undefined;
@@ -80,3 +61,50 @@ export class StartSessionAction extends EditorAction2 {
 		InlineChatController.get(editor)?.run({ ...options });
 	}
 }
+
+export class HoldToSpeak extends AbstractInlineChatAction {
+
+	constructor() {
+		super({
+			id: 'inlineChat.holdForSpeech',
+			precondition: ContextKeyExpr.and(HasSpeechProvider, CTX_INLINE_CHAT_VISIBLE),
+			title: localize2('holdForSpeech', "Hold for Speech"),
+			keybinding: {
+				when: EditorContextKeys.textInputFocus,
+				weight: KeybindingWeight.WorkbenchContrib,
+				primary: KeyMod.CtrlCmd | KeyCode.KeyI,
+			},
+		});
+	}
+
+	override runInlineChatCommand(accessor: ServicesAccessor, ctrl: InlineChatController, editor: ICodeEditor, ...args: any[]): void {
+		holdForSpeech(accessor, ctrl, this.desc.id);
+	}
+}
+
+function holdForSpeech(accessor: ServicesAccessor, ctrl: InlineChatController | null, commandId: string): void {
+	const keybindingService = accessor.get(IKeybindingService);
+	const commandService = accessor.get(ICommandService);
+	if (!ctrl) {
+		return;
+	}
+	const holdMode = keybindingService.enableKeybindingHoldMode(commandId);
+	if (!holdMode) {
+		return;
+	}
+	let listening = false;
+	const handle = disposableTimeout(() => {
+		// start VOICE input
+		commandService.executeCommand(StartVoiceChatAction.ID);
+		listening = true;
+	}, 250);
+
+	holdMode.finally(() => {
+		if (listening) {
+			commandService.executeCommand(StopListeningAction.ID).finally(() => {
+				ctrl!.acceptInput();
+			});
+		}
+		handle.dispose();
+	});
+}

src/vs/workbench/contrib/inlineChat/electron-sandbox/inlineChatQuickVoice.ts

@@ -17,11 +17,13 @@ import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegis
 import { HasSpeechProvider, ISpeechService, SpeechToTextStatus } from 'vs/workbench/contrib/speech/common/speechService';
 import { CancellationTokenSource } from 'vs/base/common/cancellation';
 import { InlineChatController } from 'vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { getWindow, h, reset, runAtThisOrScheduleAtNextAnimationFrame } from 'vs/base/browser/dom';
+import * as dom from 'vs/base/browser/dom';
 import { IDimension } from 'vs/editor/common/core/dimension';
 import { EditorOption } from 'vs/editor/common/config/editorOptions';
 import { AbstractInlineChatAction } from 'vs/workbench/contrib/inlineChat/browser/inlineChatActions';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { Emitter, Event } from 'vs/base/common/event';
+import { DisposableStore } from 'vs/base/common/lifecycle';
 
 const CTX_QUICK_CHAT_IN_PROGRESS = new RawContextKey<boolean>('inlineChat.quickChatInProgress', false);
 
@@ -107,17 +109,27 @@ class QuickVoiceWidget implements IContentWidget {
 	readonly suppressMouseDown = true;
 
 	private readonly _domNode = document.createElement('div');
-	private readonly _elements = h('.inline-chat-quick-voice@main', [
-		h('span@mic'),
-		h('span.message@message'),
+	private readonly _elements = dom.h('.inline-chat-quick-voice@main', [
+		dom.h('span@mic'),
+		dom.h('span.message@message'),
 	]);
 
+	private _focusTracker: dom.IFocusTracker | undefined;
+
+	private readonly _onDidBlur = new Emitter<void>();
+	readonly onDidBlur: Event<void> = this._onDidBlur.event;
+
 	constructor(private readonly _editor: ICodeEditor) {
 		this._domNode.appendChild(this._elements.root);
 		this._domNode.style.zIndex = '1000';
 		this._domNode.tabIndex = -1;
 		this._domNode.style.outline = 'none';
-		reset(this._elements.mic, renderIcon(Codicon.micFilled));
+		dom.reset(this._elements.mic, renderIcon(Codicon.micFilled));
+	}
+
+	dispose(): void {
+		this._focusTracker?.dispose();
+		this._onDidBlur.dispose();
 	}
 
 	getId(): string {
@@ -150,24 +162,33 @@ class QuickVoiceWidget implements IContentWidget {
 		return null;
 	}
 
+	afterRender(): void {
+		this._domNode.focus();
+		this._focusTracker?.dispose();
+		this._focusTracker = dom.trackFocus(this._domNode);
+		this._focusTracker.onDidBlur(() => this._onDidBlur.fire());
+	}
+
 	// ---
 
 	updateInput(input: string | undefined, isDefinite: boolean): void {
 		this._elements.message.classList.toggle('preview', !isDefinite);
 		this._elements.message.textContent = input ?? '';
 	}
 
-	focus(): void {
-		this._domNode.focus();
+	show() {
+		this._editor.addContentWidget(this);
 	}
 
 	active(): void {
 		this._elements.main.classList.add('recording');
 	}
 
-	reset(): void {
+	hide() {
 		this._elements.main.classList.remove('recording');
 		this.updateInput(undefined, true);
+		this._editor.removeContentWidget(this);
+		this._focusTracker?.dispose();
 	}
 }
 
@@ -179,6 +200,7 @@ export class InlineChatQuickVoice implements IEditorContribution {
 		return editor.getContribution<InlineChatQuickVoice>(InlineChatQuickVoice.ID);
 	}
 
+	private readonly _store = new DisposableStore();
 	private readonly _ctxQuickChatInProgress: IContextKey<boolean>;
 	private readonly _widget: QuickVoiceWidget;
 	private _finishCallback?: (abort: boolean) => void;
@@ -188,24 +210,25 @@ export class InlineChatQuickVoice implements IEditorContribution {
 		@ISpeechService private readonly _speechService: ISpeechService,
 		@IContextKeyService contextKeyService: IContextKeyService,
 	) {
-		this._widget = new QuickVoiceWidget(this._editor);
+		this._widget = this._store.add(new QuickVoiceWidget(this._editor));
+		this._widget.onDidBlur(() => this._finishCallback?.(true), undefined, this._store);
 		this._ctxQuickChatInProgress = CTX_QUICK_CHAT_IN_PROGRESS.bindTo(contextKeyService);
 	}
 
 	dispose(): void {
 		this._finishCallback?.(true);
+		this._ctxQuickChatInProgress.reset();
+		this._store.dispose();
 	}
 
 	start() {
 
+		this._finishCallback?.(true);
+
 		const cts = new CancellationTokenSource();
-		this._editor.addContentWidget(this._widget);
+		this._widget.show();
 		this._ctxQuickChatInProgress.set(true);
 
-		runAtThisOrScheduleAtNextAnimationFrame(getWindow(this._widget.getDomNode()), () => {
-			this._widget.focus(); // requires RAF because...
-		});
-
 		let message: string | undefined;
 		const session = this._speechService.createSpeechToTextSession(cts.token);
 		const listener = session.onDidChange(e => {
@@ -233,8 +256,7 @@ export class InlineChatQuickVoice implements IEditorContribution {
 		const done = (abort: boolean) => {
 			cts.dispose(true);
 			listener.dispose();
-			this._widget.reset();
-			this._editor.removeContentWidget(this._widget);
+			this._widget.hide();
 			this._ctxQuickChatInProgress.reset();
 
 			if (!abort && message) {
@@ -252,5 +274,4 @@ export class InlineChatQuickVoice implements IEditorContribution {
 	cancel(): void {
 		this._finishCallback?.(true);
 	}
-
 }