Fixing build errors...

Author: rhurey

sdk/ai/Azure.AI.VoiceLive/Directory.Build.props

@@ -2,5 +2,10 @@
   <!--
     Add any shared properties you want for the projects under this package directory that need to be set before the auto imported Directory.Build.props
   -->
+  <PropertyGroup Condition="$(MSBuildProjectName.EndsWith('.Samples'))">
+    <IsTestProject>true</IsTestProject>
+    <IsTestSupportProject>true</IsTestSupportProject>
+  </PropertyGroup>
+
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory).., Directory.Build.props))\Directory.Build.props" />
 </Project>

sdk/ai/Azure.AI.VoiceLive/samples/BasicVoiceAssistant/AudioProcessor.cs

@@ -3,21 +3,22 @@
 
 using System.Threading.Channels;
 using NAudio.Wave;
+using Azure.Core.Pipeline;
 
 namespace Azure.AI.VoiceLive.Samples;
 
 /// <summary>
 /// Handles real-time audio capture and playback for the voice assistant.
-/// 
+///
 /// This processor demonstrates some of the new VoiceLive SDK convenience methods:
 /// - Uses existing SendInputAudioAsync() method for audio streaming
 /// - Shows how convenience methods simplify audio operations
-/// 
+///
 /// Additional convenience methods available in the SDK:
 /// - StartAudioTurnAsync() / AppendAudioToTurnAsync() / EndAudioTurnAsync() - Audio turn management
 /// - ClearStreamingAudioAsync() - Clear all streaming audio
 /// - ConnectAvatarAsync() - Avatar connection with SDP
-/// 
+///
 /// Threading Architecture:
 /// - Main thread: Event loop and UI
 /// - Capture thread: NAudio input stream reading
@@ -28,29 +29,29 @@ public class AudioProcessor : IDisposable
 {
     private readonly VoiceLiveSession _session;
     private readonly ILogger<AudioProcessor> _logger;
-    
+
     // Audio configuration - PCM16, 24kHz, mono as specified
     private const int SampleRate = 24000;
     private const int Channels = 1;
     private const int BitsPerSample = 16;
-    
+
     // NAudio components
     private WaveInEvent? _waveIn;
     private WaveOutEvent? _waveOut;
     private BufferedWaveProvider? _playbackBuffer;
-    
+
     // Audio capture and playback state
     private bool _isCapturing;
     private bool _isPlaying;
-    
+
     // Audio streaming channels
     private readonly Channel<byte[]> _audioSendChannel;
     private readonly Channel<byte[]> _audioPlaybackChannel;
     private readonly ChannelWriter<byte[]> _audioSendWriter;
     private readonly ChannelReader<byte[]> _audioSendReader;
     private readonly ChannelWriter<byte[]> _audioPlaybackWriter;
     private readonly ChannelReader<byte[]> _audioPlaybackReader;
-    
+
     // Background tasks
     private Task? _audioSendTask;
     private Task? _audioPlaybackTask;
@@ -66,45 +67,45 @@ public AudioProcessor(VoiceLiveSession session, ILogger<AudioProcessor> logger)
     {
         _session = session ?? throw new ArgumentNullException(nameof(session));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        
+
         // Create unbounded channels for audio data
         _audioSendChannel = Channel.CreateUnbounded<byte[]>();
         _audioSendWriter = _audioSendChannel.Writer;
         _audioSendReader = _audioSendChannel.Reader;
-        
+
         _audioPlaybackChannel = Channel.CreateUnbounded<byte[]>();
         _audioPlaybackWriter = _audioPlaybackChannel.Writer;
         _audioPlaybackReader = _audioPlaybackChannel.Reader;
-        
+
         _cancellationTokenSource = new CancellationTokenSource();
         _playbackCancellationTokenSource = new CancellationTokenSource();
 
         _logger.LogInformation("AudioProcessor initialized with {SampleRate}Hz PCM16 mono audio", SampleRate);
     }
-    
+
     /// <summary>
     /// Start capturing audio from microphone.
     /// </summary>
     public Task StartCaptureAsync()
     {
         if (_isCapturing)
             return Task.CompletedTask;
-            
+
         _isCapturing = true;
-        
+
         try
         {
             _waveIn = new WaveInEvent
             {
                 WaveFormat = new WaveFormat(SampleRate, BitsPerSample, Channels),
                 BufferMilliseconds = 50 // 50ms buffer for low latency
             };
-            
+
             _waveIn.DataAvailable += OnAudioDataAvailable;
             _waveIn.RecordingStopped += OnRecordingStopped;
 
             _logger.LogInformation($"There are {WaveIn.DeviceCount} devices available.");
-            for(int i = 0; i < WaveIn.DeviceCount; i++)
+            for (int i = 0; i < WaveIn.DeviceCount; i++)
             {
                 var deviceInfo = WaveIn.GetCapabilities(i);
 
@@ -113,10 +114,10 @@ public Task StartCaptureAsync()
             _waveIn.DeviceNumber = 1;
 
             _waveIn.StartRecording();
-            
+
             // Start audio send task
             _audioSendTask = ProcessAudioSendAsync(_cancellationTokenSource.Token);
-            
+
             _logger.LogInformation("Started audio capture");
             return Task.CompletedTask;
         }
@@ -127,17 +128,17 @@ public Task StartCaptureAsync()
             throw;
         }
     }
-    
+
     /// <summary>
     /// Stop capturing audio.
     /// </summary>
     public async Task StopCaptureAsync()
     {
         if (!_isCapturing)
             return;
-            
+
         _isCapturing = false;
-        
+
         if (_waveIn != null)
         {
             _waveIn.StopRecording();
@@ -146,49 +147,49 @@ public async Task StopCaptureAsync()
             _waveIn.Dispose();
             _waveIn = null;
         }
-        
+
         // Complete the send channel and wait for the send task
         _audioSendWriter.TryComplete();
         if (_audioSendTask != null)
         {
             await _audioSendTask.ConfigureAwait(false);
             _audioSendTask = null;
         }
-        
+
         _logger.LogInformation("Stopped audio capture");
     }
-    
+
     /// <summary>
     /// Initialize audio playback system.
     /// </summary>
     public Task StartPlaybackAsync()
     {
         if (_isPlaying)
             return Task.CompletedTask;
-            
+
         _isPlaying = true;
-        
+
         try
         {
             _waveOut = new WaveOutEvent
             {
                 DesiredLatency = 100 // 100ms latency
             };
-            
+
             _playbackBuffer = new BufferedWaveProvider(new WaveFormat(SampleRate, BitsPerSample, Channels))
             {
                 BufferDuration = TimeSpan.FromMinutes(5), // 5 second buffer
                 DiscardOnBufferOverflow = true
             };
-            
+
             _waveOut.Init(_playbackBuffer);
             _waveOut.Play();
 
             _playbackCancellationTokenSource = new CancellationTokenSource();
 
             // Start audio playback task
             _audioPlaybackTask = ProcessAudioPlaybackAsync();
-            
+
             _logger.LogInformation("Audio playback system ready");
             return Task.CompletedTask;
         }
@@ -199,34 +200,35 @@ public Task StartPlaybackAsync()
             throw;
         }
     }
-    
+
     /// <summary>
     /// Stop audio playback and clear buffer.
     /// </summary>
     public async Task StopPlaybackAsync()
     {
         if (!_isPlaying)
             return;
-            
+
         _isPlaying = false;
-        
+
         // Clear the playback channel
-        while (_audioPlaybackReader.TryRead(out _)) { }
-        
+        while (_audioPlaybackReader.TryRead(out _))
+        { }
+
         if (_playbackBuffer != null)
         {
             _playbackBuffer.ClearBuffer();
         }
-        
+
         if (_waveOut != null)
         {
             _waveOut.Stop();
             _waveOut.Dispose();
             _waveOut = null;
         }
-        
+
         _playbackBuffer = null;
-        
+
         // Complete the playback channel and wait for the playback task
         _playbackCancellationTokenSource.Cancel();
 
@@ -235,10 +237,10 @@ public async Task StopPlaybackAsync()
             await _audioPlaybackTask.ConfigureAwait(false);
             _audioPlaybackTask = null;
         }
-        
+
         _logger.LogInformation("Stopped audio playback");
     }
-    
+
     /// <summary>
     /// Queue audio data for playback.
     /// </summary>
@@ -250,7 +252,7 @@ public async Task QueueAudioAsync(byte[] audioData)
             await _audioPlaybackWriter.WriteAsync(audioData).ConfigureAwait(false);
         }
     }
-    
+
     /// <summary>
     /// Event handler for audio data available from microphone.
     /// </summary>
@@ -260,15 +262,15 @@ private void OnAudioDataAvailable(object? sender, WaveInEventArgs e)
         {
             byte[] audioData = new byte[e.BytesRecorded];
             Array.Copy(e.Buffer, 0, audioData, 0, e.BytesRecorded);
-            
+
             // Queue audio data for sending (non-blocking)
             if (!_audioSendWriter.TryWrite(audioData))
             {
                 _logger.LogWarning("Failed to queue audio data for sending - channel may be full");
             }
         }
     }
-    
+
     /// <summary>
     /// Event handler for recording stopped.
     /// </summary>
@@ -279,19 +281,19 @@ private void OnRecordingStopped(object? sender, StoppedEventArgs e)
             _logger.LogError(e.Exception, "Audio recording stopped due to error");
         }
     }
-    
+
     /// <summary>
     /// Background task to process audio data and send to VoiceLive service.
     /// </summary>
     private async Task ProcessAudioSendAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await foreach (byte[] audioData in _audioSendReader.ReadAllAsync(cancellationToken))
+            await foreach (byte[] audioData in _audioSendReader.ReadAllAsync(cancellationToken).ConfigureAwait(false))
             {
                 if (cancellationToken.IsCancellationRequested)
                     break;
-                    
+
                 try
                 {
                     // Send audio data directly to the session using the convenience method
@@ -315,7 +317,7 @@ private async Task ProcessAudioSendAsync(CancellationToken cancellationToken)
             _logger.LogError(ex, "Error in audio send processing");
         }
     }
-    
+
     /// <summary>
     /// Background task to process audio playback.
     /// </summary>
@@ -326,11 +328,11 @@ private async Task ProcessAudioPlaybackAsync()
             CancellationTokenSource combinedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_playbackCancellationTokenSource.Token, _cancellationTokenSource.Token);
             var cancellationToken = combinedTokenSource.Token;
 
-            await foreach (byte[] audioData in _audioPlaybackReader.ReadAllAsync(cancellationToken))
+            await foreach (byte[] audioData in _audioPlaybackReader.ReadAllAsync(cancellationToken).ConfigureAwait(false))
             {
                 if (cancellationToken.IsCancellationRequested)
                     break;
-                    
+
                 try
                 {
                     if (_playbackBuffer != null && _isPlaying)
@@ -354,36 +356,38 @@ private async Task ProcessAudioPlaybackAsync()
             _logger.LogError(ex, "Error in audio playback processing");
         }
     }
-    
+
     /// <summary>
     /// Clean up audio resources.
     /// </summary>
     public async Task CleanupAsync()
     {
         await StopCaptureAsync().ConfigureAwait(false);
         await StopPlaybackAsync().ConfigureAwait(false);
-        
+
         _cancellationTokenSource.Cancel();
-        
+
         // Wait for background tasks to complete
         var tasks = new List<Task>();
-        if (_audioSendTask != null) tasks.Add(_audioSendTask);
-        if (_audioPlaybackTask != null) tasks.Add(_audioPlaybackTask);
-        
+        if (_audioSendTask != null)
+            tasks.Add(_audioSendTask);
+        if (_audioPlaybackTask != null)
+            tasks.Add(_audioPlaybackTask);
+
         if (tasks.Count > 0)
         {
             await Task.WhenAll(tasks).ConfigureAwait(false);
         }
-        
+
         _logger.LogInformation("Audio processor cleaned up");
     }
-    
+
     /// <summary>
     /// Dispose of resources.
     /// </summary>
     public void Dispose()
     {
-        CleanupAsync().GetAwaiter().GetResult();
+        CleanupAsync().Wait();
         _cancellationTokenSource.Dispose();
     }
 }