work on #195282

Author: meganrogge

src/vs/platform/accessibility/common/accessibility.ts

@@ -56,10 +56,15 @@ export const IAccessibleNotificationService = createDecorator<IAccessibleNotific
 export interface IAccessibleNotificationService {
 	readonly _serviceBrand: undefined;
 	notify(event: AccessibleNotificationEvent, userGesture?: boolean): void;
+	notifyLineChanges(event: AccessibleNotificationEvent[]): void;
 }
 
 export const enum AccessibleNotificationEvent {
 	Clear = 'clear',
 	Save = 'save',
-	Format = 'format'
+	Format = 'format',
+	Breakpoint = 'breakpoint',
+	Error = 'error',
+	Warning = 'warning',
+	Folded = 'folded'
 }

src/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration.ts

@@ -56,7 +56,11 @@ export const enum AccessibilityVerbositySettingId {
 
 export const enum AccessibilityAlertSettingId {
 	Save = 'accessibility.alert.save',
-	Format = 'accessibility.alert.format'
+	Format = 'accessibility.alert.format',
+	Breakpoint = 'accessibility.alert.breakpoint',
+	Error = 'accessibility.alert.error',
+	Warning = 'accessibility.alert.warning',
+	FoldedArea = 'accessibility.alert.foldedArea'
 }
 
 export const enum AccessibleViewProviderId {
@@ -154,6 +158,30 @@ const configuration: IConfigurationNode = {
 			],
 			tags: ['accessibility']
 		},
+		[AccessibilityAlertSettingId.Breakpoint]: {
+			'markdownDescription': localize('alert.breakpoint', "When in screen reader mode, alerts when the active line has a breakpoint. Also see {0}.", '`#audioCues.breakpoint#`'),
+			'type': 'boolean',
+			'default': true,
+			tags: ['accessibility']
+		},
+		[AccessibilityAlertSettingId.Error]: {
+			'markdownDescription': localize('alert.error', "When in screen reader mode, alerts when the active line has an error. Also see {0}.", '`#audioCues.error#`'),
+			'type': 'boolean',
+			'default': true,
+			tags: ['accessibility']
+		},
+		[AccessibilityAlertSettingId.Warning]: {
+			'markdownDescription': localize('alert.warning', "When in screen reader mode, alerts when the active line has a warning. Also see {0}.", '`#audioCues.warning#`'),
+			'type': 'boolean',
+			'default': true,
+			tags: ['accessibility']
+		},
+		[AccessibilityAlertSettingId.FoldedArea]: {
+			'markdownDescription': localize('alert.foldedArea', "When in screen reader mode, alerts when the active line has a folded area that can be unfolded. Also see {0}.", '`#audioCues.foldedArea#`'),
+			'type': 'boolean',
+			'default': true,
+			tags: ['accessibility']
+		},
 		[AccessibilityVoiceSettingId.SpeechTimeout]: {
 			'markdownDescription': localize('voice.speechTimeout', "The duration in milliseconds that voice speech recognition remains active after you stop speaking. For example in a chat session, the transcribed text is submitted automatically after the timeout is met. Set to `0` to disable this feature."),
 			'type': 'number',

src/vs/workbench/contrib/accessibility/browser/accessibleNotificationService.ts

@@ -15,7 +15,11 @@ import { IWorkingCopyService } from 'vs/workbench/services/workingCopy/common/wo
 
 export class AccessibleNotificationService extends Disposable implements IAccessibleNotificationService {
 	declare readonly _serviceBrand: undefined;
-	private _events: Map<AccessibleNotificationEvent, { audioCue: AudioCue; alertMessage: string; alertSetting?: string }> = new Map();
+	private _events: Map<AccessibleNotificationEvent, {
+		audioCue: AudioCue;
+		alertMessage: string;
+		alertSetting?: string;
+	}> = new Map();
 	constructor(
 		@IAudioCueService private readonly _audioCueService: IAudioCueService,
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
@@ -26,17 +30,24 @@ export class AccessibleNotificationService extends Disposable implements IAccess
 		this._events.set(AccessibleNotificationEvent.Clear, { audioCue: AudioCue.clear, alertMessage: localize('cleared', "Cleared") });
 		this._events.set(AccessibleNotificationEvent.Save, { audioCue: AudioCue.save, alertMessage: localize('saved', "Saved"), alertSetting: AccessibilityAlertSettingId.Save });
 		this._events.set(AccessibleNotificationEvent.Format, { audioCue: AudioCue.format, alertMessage: localize('formatted', "Formatted"), alertSetting: AccessibilityAlertSettingId.Format });
+		this._events.set(AccessibleNotificationEvent.Breakpoint, { audioCue: AudioCue.break, alertMessage: localize('breakpoint', "Breakpoint"), alertSetting: AccessibilityAlertSettingId.Breakpoint });
+		this._events.set(AccessibleNotificationEvent.Error, { audioCue: AudioCue.error, alertMessage: localize('error', "Error"), alertSetting: AccessibilityAlertSettingId.Error });
+		this._events.set(AccessibleNotificationEvent.Warning, { audioCue: AudioCue.warning, alertMessage: localize('warning', "Warning"), alertSetting: AccessibilityAlertSettingId.Warning });
+		this._events.set(AccessibleNotificationEvent.Folded, { audioCue: AudioCue.foldedArea, alertMessage: localize('foldedArea', "Folded Area"), alertSetting: AccessibilityAlertSettingId.FoldedArea });
 
-		this._register(this._workingCopyService.onDidSave((e) => this._notify(AccessibleNotificationEvent.Save, e.reason === SaveReason.EXPLICIT)));
+		this._register(this._workingCopyService.onDidSave((e) => this._notifyBasedOnUserGesture(AccessibleNotificationEvent.Save, e.reason === SaveReason.EXPLICIT)));
 	}
 
+	/**
+	 * Notify on clear, save, format. Alerts and audio cues are mutually exclusive.
+	 */
 	notify(event: AccessibleNotificationEvent, userGesture?: boolean): void {
 		if (event === AccessibleNotificationEvent.Format) {
-			return this._notify(event, userGesture);
+			return this._notifyBasedOnUserGesture(AccessibleNotificationEvent.Format, userGesture);
 		}
 		const { audioCue, alertMessage } = this._events.get(event)!;
-		const audioCueValue = this._configurationService.getValue(audioCue.settingsKey);
-		if (audioCueValue === 'on' || audioCueValue === 'auto' && this._accessibilityService.isScreenReaderOptimized()) {
+		const audioCueSetting = this._configurationService.getValue(audioCue.settingsKey);
+		if (audioCueSetting === 'on' || audioCueSetting === 'auto' && this._accessibilityService.isScreenReaderOptimized()) {
 			this._logService.debug('AccessibleNotificationService playing sound: ', audioCue.name);
 			this._audioCueService.playAudioCue(audioCue);
 		} else {
@@ -45,7 +56,24 @@ export class AccessibleNotificationService extends Disposable implements IAccess
 		}
 	}
 
-	private _notify(event: AccessibleNotificationEvent, userGesture?: boolean): void {
+	/**
+	 * Line feature contributions can use this to notify the user of changes to the line.
+	 */
+	notifyLineChanges(events: AccessibleNotificationEvent[]): void {
+		const audioCues = events.map(e => this._events.get(e)!.audioCue);
+		if (audioCues.length) {
+			this._logService.debug('AccessibleNotificationService playing sounds if enabled: ', events.map(e => this._events.get(e)!.audioCue.name).join(', '));
+			this._audioCueService.playAudioCues(audioCues);
+		}
+
+		const alerts = events.filter(e => this._configurationService.getValue(this._events.get(e)!.alertSetting!) === true).map(e => this._events.get(e)?.alertMessage);
+		if (alerts.length) {
+			this._logService.debug('AccessibleNotificationService alerting: ', alerts.join(', '));
+			this._accessibilityService.alert(alerts.join(', '));
+		}
+	}
+
+	private _notifyBasedOnUserGesture(event: AccessibleNotificationEvent, userGesture?: boolean): void {
 		const { audioCue, alertMessage, alertSetting } = this._events.get(event)!;
 		if (!alertSetting) {
 			return;
@@ -79,4 +107,5 @@ export class TestAccessibleNotificationService extends Disposable implements IAc
 	declare readonly _serviceBrand: undefined;
 
 	notify(event: AccessibleNotificationEvent, userGesture?: boolean): void { }
+	notifyLineChanges(event: AccessibleNotificationEvent[]): void { }
 }

src/vs/workbench/contrib/audioCues/browser/audioCueLineFeatureContribution.ts

@@ -12,6 +12,7 @@ import { Position } from 'vs/editor/common/core/position';
 import { CursorChangeReason } from 'vs/editor/common/cursorEvents';
 import { ITextModel } from 'vs/editor/common/model';
 import { FoldingController } from 'vs/editor/contrib/folding/browser/folding';
+import { AccessibleNotificationEvent, IAccessibleNotificationService } from 'vs/platform/accessibility/common/accessibility';
 import { AudioCue, IAudioCueService } from 'vs/platform/audioCues/browser/audioCueService';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -26,8 +27,8 @@ export class AudioCueLineFeatureContribution
 	private readonly store = this._register(new DisposableStore());
 
 	private readonly features: LineFeature[] = [
-		this.instantiationService.createInstance(MarkerLineFeature, AudioCue.error, MarkerSeverity.Error),
-		this.instantiationService.createInstance(MarkerLineFeature, AudioCue.warning, MarkerSeverity.Warning),
+		this.instantiationService.createInstance(MarkerLineFeature, AccessibleNotificationEvent.Error, AudioCue.error, MarkerSeverity.Error),
+		this.instantiationService.createInstance(MarkerLineFeature, AccessibleNotificationEvent.Warning, AudioCue.warning, MarkerSeverity.Warning),
 		this.instantiationService.createInstance(FoldedAreaLineFeature),
 		this.instantiationService.createInstance(BreakpointLineFeature),
 	];
@@ -41,7 +42,8 @@ export class AudioCueLineFeatureContribution
 		@IEditorService private readonly editorService: IEditorService,
 		@IInstantiationService private readonly instantiationService: IInstantiationService,
 		@IAudioCueService private readonly audioCueService: IAudioCueService,
-		@IConfigurationService private readonly _configurationService: IConfigurationService
+		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IAccessibleNotificationService private readonly _accessibleNotificationService: IAccessibleNotificationService
 	) {
 		super();
 
@@ -155,15 +157,15 @@ export class AudioCueLineFeatureContribution
 						newValue?.featureStates.get(feature) &&
 						(!lastValue?.featureStates?.get(feature) || newValue.lineNumber !== lastValue.lineNumber)
 				);
-
-				this.audioCueService.playAudioCues(newFeatures.map(f => f.audioCue));
+				this._accessibleNotificationService.notifyLineChanges(newFeatures.map(feature => feature.event));
 			})
 		);
 	}
 }
 
 interface LineFeature {
 	audioCue: AudioCue;
+	event: AccessibleNotificationEvent;
 	debounceWhileTyping?: boolean;
 	getObservableState(
 		editor: ICodeEditor,
@@ -179,6 +181,7 @@ class MarkerLineFeature implements LineFeature {
 	public readonly debounceWhileTyping = true;
 	private _previousLine: number = 0;
 	constructor(
+		public readonly event: AccessibleNotificationEvent,
 		public readonly audioCue: AudioCue,
 		private readonly severity: MarkerSeverity,
 		@IMarkerService private readonly markerService: IMarkerService,
@@ -210,7 +213,7 @@ class MarkerLineFeature implements LineFeature {
 
 class FoldedAreaLineFeature implements LineFeature {
 	public readonly audioCue = AudioCue.foldedArea;
-
+	public readonly event = AccessibleNotificationEvent.Folded;
 	getObservableState(editor: ICodeEditor, model: ITextModel): IObservable<LineFeatureState> {
 		const foldingController = FoldingController.get(editor);
 		if (!foldingController) {
@@ -237,7 +240,7 @@ class FoldedAreaLineFeature implements LineFeature {
 
 class BreakpointLineFeature implements LineFeature {
 	public readonly audioCue = AudioCue.break;
-
+	public readonly event = AccessibleNotificationEvent.Breakpoint;
 	constructor(@IDebugService private readonly debugService: IDebugService) { }
 
 	getObservableState(editor: ICodeEditor, model: ITextModel): IObservable<LineFeatureState> {