Merge pull request microsoft#185268 from microsoft/merogge/loop-cue

add audio cues for AI panel chat

Author: meganrogge

src/vs/editor/standalone/browser/standaloneServices.ts

@@ -87,7 +87,7 @@ import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput';
 import { IStorageService, InMemoryStorageService } from 'vs/platform/storage/common/storage';
 import { DefaultConfiguration } from 'vs/platform/configuration/common/configurations';
 import { WorkspaceEdit } from 'vs/editor/common/languages';
-import { AudioCue, IAudioCueService, Sound } from 'vs/platform/audioCues/browser/audioCueService';
+import { AudioCue, AudioCueGroupId, IAudioCueService, Sound } from 'vs/platform/audioCues/browser/audioCueService';
 import { LogService } from 'vs/platform/log/common/logService';
 import { getEditorFeatures } from 'vs/editor/common/editorFeatures';
 import { onUnexpectedError } from 'vs/base/common/errors';
@@ -1055,6 +1055,11 @@ class StandaloneAudioService implements IAudioCueService {
 
 	async playSound(cue: Sound, allowManyInParallel?: boolean | undefined): Promise<void> {
 	}
+	playAudioCueLoop(cue: AudioCue): IDisposable {
+		return toDisposable(() => { });
+	}
+	playRandomAudioCue(groupId: AudioCueGroupId, allowManyInParallel?: boolean): void {
+	}
 }
 
 export interface IEditorOverrideServices {

src/vs/platform/audioCues/browser/audioCueService.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { FileAccess } from 'vs/base/common/network';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -22,6 +22,8 @@ export interface IAudioCueService {
 	onEnabledChanged(cue: AudioCue): Event<void>;
 
 	playSound(cue: Sound, allowManyInParallel?: boolean): Promise<void>;
+	playAudioCueLoop(cue: AudioCue, milliseconds: number): IDisposable;
+	playRandomAudioCue(groupId: AudioCueGroupId, allowManyInParallel?: boolean): void;
 }
 
 export class AudioCueService extends Disposable implements IAudioCueService {
@@ -51,6 +53,12 @@ export class AudioCueService extends Disposable implements IAudioCueService {
 		await Promise.all(Array.from(sounds).map(sound => this.playSound(sound, true)));
 	}
 
+	public playRandomAudioCue(groupId: AudioCueGroupId, allowManyInParallel?: boolean): void {
+		const cues = AudioCue.allAudioCues.filter(cue => cue.groupId === groupId);
+		const index = Math.floor(Math.random() * cues.length);
+		this.playAudioCue(cues[index], allowManyInParallel);
+	}
+
 	private getVolumeInPercent(): number {
 		const volume = this.configurationService.getValue<number>('audioCues.volume');
 		if (typeof volume !== 'number') {
@@ -66,7 +74,6 @@ export class AudioCueService extends Disposable implements IAudioCueService {
 		if (!allowManyInParallel && this.playingSounds.has(sound)) {
 			return;
 		}
-
 		this.playingSounds.add(sound);
 		const url = FileAccess.asBrowserUri(`vs/platform/audioCues/browser/media/${sound.fileName}`).toString(true);
 
@@ -87,6 +94,23 @@ export class AudioCueService extends Disposable implements IAudioCueService {
 		}
 	}
 
+	public playAudioCueLoop(cue: AudioCue, milliseconds: number): IDisposable {
+		let playing = true;
+		const playSound = () => {
+			if (playing) {
+				this.playAudioCue(cue, true).finally(() => {
+					setTimeout(() => {
+						if (playing) {
+							playSound();
+						}
+					}, milliseconds);
+				});
+			}
+		};
+		playSound();
+		return toDisposable(() => playing = false);
+	}
+
 	private readonly obsoleteAudioCuesEnabled = observableFromEvent(
 		Event.filter(this.configurationService.onDidChangeConfiguration, (e) =>
 			e.affectsConfiguration('audioCues.enabled')
@@ -190,19 +214,30 @@ export class Sound {
 	public static readonly diffLineInserted = Sound.register({ fileName: 'diffLineInserted.mp3' });
 	public static readonly diffLineDeleted = Sound.register({ fileName: 'diffLineDeleted.mp3' });
 	public static readonly diffLineModified = Sound.register({ fileName: 'diffLineModified.mp3' });
+	public static readonly chatRequestSent = Sound.register({ fileName: 'chatRequestSent.mp3' });
+	public static readonly chatResponsePending = Sound.register({ fileName: 'chatResponsePending.mp3' });
+	public static readonly chatResponseReceived1 = Sound.register({ fileName: 'chatResponseReceived1.mp3' });
+	public static readonly chatResponseReceived2 = Sound.register({ fileName: 'chatResponseReceived2.mp3' });
+	public static readonly chatResponseReceived3 = Sound.register({ fileName: 'chatResponseReceived3.mp3' });
+	public static readonly chatResponseReceived4 = Sound.register({ fileName: 'chatResponseReceived4.mp3' });
+	public static readonly chatResponseReceived5 = Sound.register({ fileName: 'chatResponseReceived5.mp3' });
 
 	private constructor(public readonly fileName: string) { }
 }
 
+export const enum AudioCueGroupId {
+	chatResponseReceived = 'chatResponseReceived'
+}
+
 export class AudioCue {
 	private static _audioCues = new Set<AudioCue>();
-
 	private static register(options: {
 		name: string;
 		sound: Sound;
 		settingsKey: string;
+		groupId?: AudioCueGroupId;
 	}): AudioCue {
-		const audioCue = new AudioCue(options.sound, options.name, options.settingsKey);
+		const audioCue = new AudioCue(options.sound, options.name, options.settingsKey, options.groupId);
 		AudioCue._audioCues.add(audioCue);
 		return audioCue;
 	}
@@ -309,9 +344,53 @@ export class AudioCue {
 		settingsKey: 'audioCues.diffLineModified'
 	});
 
+	public static readonly chatRequestSent = AudioCue.register({
+		name: localize('audioCues.chatRequestSent', 'Chat Request Sent'),
+		sound: Sound.chatRequestSent,
+		settingsKey: 'audioCues.chatRequestSent'
+	});
+
+	public static readonly chatResponseReceived = {
+		name: localize('audioCues.chatResponseReceived', 'Chat Response Received'),
+		settingsKey: 'audioCues.chatResponseReceived',
+		groupId: AudioCueGroupId.chatResponseReceived
+	};
+
+	public static readonly chatResponseReceived1 = AudioCue.register({
+		sound: Sound.chatResponseReceived1,
+		...this.chatResponseReceived
+	});
+
+	public static readonly chatResponseReceived2 = AudioCue.register({
+		sound: Sound.chatResponseReceived2,
+		...this.chatResponseReceived
+	});
+
+	public static readonly chatResponseReceived3 = AudioCue.register({
+		sound: Sound.chatResponseReceived3,
+		...this.chatResponseReceived
+	});
+
+	public static readonly chatResponseReceived4 = AudioCue.register({
+		sound: Sound.chatResponseReceived4,
+		...this.chatResponseReceived
+	});
+
+	public static readonly chatResponseReceived5 = AudioCue.register({
+		sound: Sound.chatResponseReceived5,
+		...this.chatResponseReceived
+	});
+
+	public static readonly chatResponsePending = AudioCue.register({
+		name: localize('audioCues.chatResponsePending', 'Chat Response Pending'),
+		sound: Sound.chatResponsePending,
+		settingsKey: 'audioCues.chatResponsePending'
+	});
+
 	private constructor(
 		public readonly sound: Sound,
 		public readonly name: string,
 		public readonly settingsKey: string,
+		public readonly groupId?: string
 	) { }
 }

src/vs/platform/audioCues/browser/media/chatRequestSent.mp3

@@ -117,6 +117,21 @@ Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).regis
 			'description': localize('audioCues.notebookCellFailed', "Plays a sound when a notebook cell execution fails."),
 			...audioCueFeatureBase,
 		},
+		'audioCues.chatRequestSent': {
+			'description': localize('audioCues.chatRequestSent', "Plays a sound when a chat request is made."),
+			...audioCueFeatureBase,
+			default: 'off'
+		},
+		'audioCues.chatResponsePending': {
+			'description': localize('audioCues.chatResponsePending', "Plays a sound on loop while the response is pending."),
+			...audioCueFeatureBase,
+			default: 'off'
+		},
+		'audioCues.chatResponseReceived': {
+			'description': localize('audioCues.chatResponseReceived', "Plays a sound on loop while the response has been received."),
+			...audioCueFeatureBase,
+			default: 'off'
+		}
 	}
 });