ADK changes

PiperOrigin-RevId: 839135527

Author: google-genai-bot

src/app/core/services/audio-playing.service.spec.ts

@@ -54,6 +54,11 @@ describe('AudioPlayingService', () => {
     expect(service).toBeTruthy();
   });
 
+  function createMockSource() {
+    return jasmine.createSpyObj(
+        'AudioBufferSourceNode', ['stop', 'start', 'connect']);
+  }
+
   describe('playAudio', () => {
     it('should not play audio if the buffer is empty', () => {
       spyOn<any>(service, 'playPCM').and.callThrough();
@@ -75,5 +80,79 @@ describe('AudioPlayingService', () => {
       service.playAudio(buffer);
       expect((service as any).playPCM).toHaveBeenCalledWith(combinedBuffer);
     });
+
+    it('should schedule audio sources correctly', () => {
+      const buffer = [new Uint8Array([1, 2])];
+      const mockSource = createMockSource();
+      mockAudioContext.createBufferSource.and.returnValue(mockSource);
+
+      service.playAudio(buffer);
+
+      expect(mockAudioContext.createBufferSource).toHaveBeenCalled();
+      expect(mockSource.start).toHaveBeenCalled();
+    });
+
+    it('removes source from schedule after playback finishes', () => {
+      const mockSource = createMockSource();
+      mockAudioContext.createBufferSource.and.returnValue(mockSource);
+      const scheduledAudioSources =
+          (service as any).scheduledAudioSources as Set<any>;
+
+      service.playAudio([new Uint8Array([1])]);
+
+      // Assert that the source was added and the onended handler was attached.
+      expect(scheduledAudioSources.has(mockSource)).toBeTrue();
+      expect((mockSource as any).onended).toEqual(jasmine.any(Function));
+
+      // Simulate the audio finishing by calling the onended handler.
+      if ((mockSource as any).onended) {
+        (mockSource as any).onended();
+      }
+
+      // Assert that the source was removed from the set.
+      expect(scheduledAudioSources.has(mockSource)).toBeFalse();
+    });
+  });
+
+  describe('stopAudio', () => {
+    it('should stop all scheduled sources', () => {
+      const mockSource1 = createMockSource();
+      const mockSource2 = createMockSource();
+
+      mockAudioContext.createBufferSource.and.returnValues(
+          mockSource1, mockSource2);
+
+      // Play two audio clips
+      service.playAudio([new Uint8Array([1])]);
+      service.playAudio([new Uint8Array([2])]);
+
+      service.stopAudio();
+
+      expect(mockSource1.stop).toHaveBeenCalled();
+      expect(mockSource2.stop).toHaveBeenCalled();
+    });
+
+    it('should reset scheduling time so next audio plays immediately', () => {
+      const mockSource1 = createMockSource();
+      const mockSource2 = createMockSource();
+      mockAudioContext.createBufferSource.and.returnValues(
+          mockSource1, mockSource2);
+
+      // Play a long audio clip (duration 1s from mock)
+      service.playAudio([new Uint8Array([1])]);
+
+      // Advance time slightly
+      mockAudioContext.currentTime = 0.5;
+
+      // Stop audio
+      service.stopAudio();
+
+      // Play another clip
+      service.playAudio([new Uint8Array([2])]);
+
+      // The second clip should start at current time (0.5), not after the first
+      // clip (1.0)
+      expect(mockSource2.start).toHaveBeenCalledWith(0.5);
+    });
   });
 });

src/app/core/services/audio-playing.service.ts

@@ -24,6 +24,7 @@ import {AudioPlayingService as AudioPlayingServiceInterface} from './interfaces/
 export class AudioPlayingService implements AudioPlayingServiceInterface {
   private audioContext = new AudioContext({sampleRate: 22000});
   private lastAudioTime = 0;
+  private scheduledAudioSources = new Set<AudioBufferSourceNode>();
 
   playAudio(buffer: Uint8Array[]) {
     const pcmBytes = this.combineAudioBuffer(buffer);
@@ -32,6 +33,18 @@ export class AudioPlayingService implements AudioPlayingServiceInterface {
     this.playPCM(pcmBytes);
   }
 
+  stopAudio() {
+    for (const source of this.scheduledAudioSources) {
+      source.onended = null;
+      source.stop();
+    }
+
+    this.scheduledAudioSources.clear();
+    // Reset lastAudioTime to the current time so that any new audio played
+    // after stopping will start immediately.
+    this.lastAudioTime = this.audioContext.currentTime;
+  }
+
   private combineAudioBuffer(buffer: Uint8Array[]) {
     if (buffer.length === 0) return undefined;
 
@@ -68,11 +81,17 @@ export class AudioPlayingService implements AudioPlayingServiceInterface {
     const source = this.audioContext.createBufferSource();
     source.buffer = buffer;
     source.connect(this.audioContext.destination);
+    source.onended = () => {
+      this.scheduledAudioSources.delete(source);
+    };
+    this.scheduledAudioSources.add(source);
 
     const currentTime = this.audioContext.currentTime;
     const startTime = Math.max(this.lastAudioTime, currentTime);
     source.start(startTime);
 
+    // Update lastAudioTime to the end time of the current buffer to ensure
+    // subsequent audio starts after this one finishes.
     this.lastAudioTime = startTime + buffer.duration;
   }
 }

src/app/core/services/interfaces/audio-playing.ts

@@ -25,4 +25,5 @@ export const AUDIO_PLAYING_SERVICE =
  */
 export declare abstract class AudioPlayingService {
   abstract playAudio(buffer: Uint8Array[]): void;
+  abstract stopAudio(): void;
 }