Update retrying flow

Author: standleypg

src/Application/DTOs/PlayRequest.cs

@@ -1,3 +1,3 @@
 namespace Application.DTOs;
 
-public record PlayRequest<TContext>(TContext Context, Func<Task> Callbacks);
+public record PlayRequest<TContext>(TContext Context, Func<string, Task> Callbacks);

src/Application/Interfaces/Services/INetCordAudioPlayerService.cs

@@ -4,5 +4,5 @@ public interface INetCordAudioPlayerService
 {
     event Func<Task>? DisconnectedVoiceClientEvent;
     event Func<Task>? NotInVoiceChannelCallback;
-    Task Play<T>(T ctx, Action<Func<Task>> disconnectAsync);
+    Task Play(Action<Func<Task>> disconnectAsync);
 }

src/Infrastructure/Commands/NetCordCommand.cs

@@ -1,17 +1,14 @@
-using System.ComponentModel;
 using Application.Interfaces.Services;
 using Domain.Common;
-using Domain.Entities;
 using Domain.Eventing;
-using Infrastructure.Services;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using NetCord.Rest;
+using NetCord.Services;
 using NetCord.Services.ApplicationCommands;
 using NetCord.Services.Commands;
 using YoutubeExplode;
 using YoutubeExplode.Common;
-using YoutubeExplode.Search;
 using Constants = Domain.Common.Constants;
 
 namespace Infrastructure.Commands;
@@ -20,15 +17,18 @@ public class NetCordCommand(IServiceProvider serviceProvider, IConfiguration con
     : ApplicationCommandModule<ApplicationCommandContext>
 {
     [SlashCommand("play", "Play a track from SoundCloud")]
-    [Description("Either song title, youtube URL or 'radio'")]
     public async Task PingAsync([CommandParameter(Remainder = true)] string command)
     {
+        if (await NotInVoiceChannel())
+        {
+            return;
+        }
         // `AddApplicationCommands()` registers services as singleton,
         // so scope is needed to resolve scoped services.
         using var scope = serviceProvider.CreateScope();
         var youtubeClient = scope.ServiceProvider.GetRequiredService<YoutubeClient>();
         var radioSourceService = scope.ServiceProvider.GetRequiredService<IRadioSourceService>();
-
+        
         var message = CreateMessage<InteractionMessageProperties>("Select a track to play:");
 
         switch (command)
@@ -38,7 +38,8 @@ public async Task PingAsync([CommandParameter(Remainder = true)] string command)
             case "Radio":
             {
                 var radiosSourceList = (await radioSourceService.GetAllRadioSourcesAsync()).Where(rs => rs.IsActive);
-                message.Components = CreateComponent(radiosSourceList.Select(rs => new ComponentModel(rs.Name, rs.Id.ToString())));
+                message.Components =
+                    CreateComponent(radiosSourceList.Select(rs => new ComponentModel(rs.Name, rs.Id.ToString())));
                 break;
             }
             case var _ when Uri.TryCreate(command, UriKind.Absolute, out _):
@@ -52,17 +53,22 @@ public async Task PingAsync([CommandParameter(Remainder = true)] string command)
                     await youtubeClient.Search.GetVideosAsync(command)
                         .CollectAsync(5);
 
-                message.Components = CreateComponent(source.Select(s => new ComponentModel(s.Title, s.Url, s.Author.ChannelTitle)));
+                message.Components =
+                    CreateComponent(source.Select(s => new ComponentModel(s.Title, s.Url, s.Author.ChannelTitle)));
             }
                 break;
         }
-        
+
         await RespondAsync(InteractionCallback.Message(message));
     }
 
     [SlashCommand("stop", "Stop playing and clear the queue")]
     public async Task Stop()
     {
+        if (await NotInVoiceChannel())
+        {
+            return;
+        }
         using var scope = serviceProvider.CreateScope();
         var eventDispatcher = scope.ServiceProvider.GetRequiredService<IEventDispatcher>();
         eventDispatcher.Dispatch(new EventType.Stop());
@@ -73,6 +79,10 @@ public async Task Stop()
     [SlashCommand("skip", "Skip the current track")]
     public async Task Skip()
     {
+        if (await NotInVoiceChannel())
+        {
+            return;
+        }
         using var scope = serviceProvider.CreateScope();
         var eventDispatcher = scope.ServiceProvider.GetRequiredService<IEventDispatcher>();
         eventDispatcher.Dispatch(new EventType.Skip());
@@ -103,6 +113,19 @@ private static IEnumerable<IMessageComponentProperties> CreateComponent<T>(T sou
             }
         ];
     }
+    
+    private async Task<bool> NotInVoiceChannel()
+    {
+        if (!Context.Guild!.VoiceStates.TryGetValue(Context.User.Id, out _))
+        {
+            var notInVoiceChannelMessage =
+                CreateMessage<InteractionMessageProperties>("You must be in a voice channel to use this command.");
+            await RespondAsync(InteractionCallback.Message(notInVoiceChannelMessage));
+            return true;
+        }
+
+        return false;
+    }
 
     private record ComponentModel(string Title, string Url, string? Description = null);
 }

src/Infrastructure/Interaction/NetCordInteraction.cs

@@ -19,10 +19,21 @@ public class NetCordInteraction(
     [ComponentInteraction(Constants.CustomIds.Play)]
     public async Task<string> Play()
     {
+        var context = Context;
+        if (!NotInVoiceChannel())
+        {
+            return "You must be in a voice channel to use this command.";
+        }
+        
+        if (!NotDeafened())
+        {
+            return "You must be deafened to use this command.";
+        }
+        
         logger.LogInformation("Play command invoked by user {UserId} in guild {GuildId}", Context.User.Id,
             Context.Guild?.Id);
 
-        var playRequest = new PlayRequest<StringMenuInteractionContext>(Context, NotInVoiceChannelCallback);
+        var playRequest = new PlayRequest<StringMenuInteractionContext>(Context, RespondAsyncCallback);
         queueService.Enqueue(playRequest);
         eventDispatcher.Dispatch(new EventType.Play());
         var selectedValue = Context.SelectedValues[0];
@@ -40,6 +51,29 @@ public async Task<string> Play()
 
         return message;
 
-        Task<InteractionCallbackResponse> NotInVoiceChannelCallback() => RespondAsync(InteractionCallback.Message("You are not connected to any voice channel!"))!;
     }
+    
+    private bool NotInVoiceChannel()
+    {
+        return Context.Guild!.VoiceStates.TryGetValue(Context.User.Id, out _);
+    }
+    
+    private bool NotDeafened()
+    {
+        var voiceState = Context.Guild!.VoiceStates[Context.User.Id];
+        return !(voiceState.IsDeafened || voiceState.IsSelfDeafened);
+    }
+    
+    private bool UserAndBotInSameVoiceChannel()
+    {
+        var voiceState = Context.Guild!.VoiceStates[Context.User.Id];
+        if (!Context.Guild.VoiceStates.TryGetValue(Context.Client.Id, out var botVoiceState))
+        {
+            return false;
+        }
+        
+        return voiceState.ChannelId == botVoiceState.ChannelId;
+    }
+
+    private Task<InteractionCallbackResponse> RespondAsyncCallback(string message) => RespondAsync(InteractionCallback.Message(message))!;
 }

src/Infrastructure/Services/NetCordAudioPlayerService.cs

@@ -20,34 +20,34 @@ public class NetCordAudioPlayerService(
     public event Func<Task>? DisconnectedVoiceClientEvent;
     public event Func<Task>? NotInVoiceChannelCallback;
     private Action<Func<Task>> OnDisconnectAsync { get; set; } = _ => { };
-    private StringMenuInteractionContext Context { get; set; } = null!;
 
-    private int _retryCount = 0;
+    private int _retryCount;
+    private bool _retrying;
 
-    public async Task Play<T>(T ctx, Action<Func<Task>> onDisconnectAsync)
+    public async Task Play(Action<Func<Task>> onDisconnectAsync)
     {
-        if (ctx is not StringMenuInteractionContext context)
-        {
-            throw new ArgumentException("Invalid context type. Expected StringMenuInteractionContext.", nameof(ctx));
-        }
-
         OnDisconnectAsync = onDisconnectAsync;
-        Context = context;
-
         await HandleMusicPlayingAsync();
     }
 
     private async Task HandleMusicPlayingAsync()
     {
-        var guild = Context.Guild!;
+        var currentTrack = queue.Peek<StringMenuInteractionContext>();
+        
+        if (currentTrack is null)
+        {
+            logger.LogError("Current track is null");
+            return;
+        }
+        var guild = currentTrack.Context.Guild!;
         // Get the user voice state
-        if (!guild.VoiceStates.TryGetValue(Context.User.Id, out var voiceState))
+        if (!guild.VoiceStates.TryGetValue(currentTrack.Context.User.Id, out var voiceState))
         {
             await (NotInVoiceChannelCallback?.Invoke() ?? Task.CompletedTask);
             return;
         }
 
-        var client = Context.Client;
+        var client = currentTrack.Context.Client;
 
         if (playerState.CurrentAction == PlayerAction.Stop)
         {
@@ -74,13 +74,6 @@ async Task HandleVoiceStream()
             var radioSourceService = scope.ServiceProvider
                 .GetRequiredService<IRadioSourceService>();
 
-            var currentTrack = queue.Peek<StringMenuInteractionContext>();
-            if (currentTrack is null)
-            {
-                logger.LogError("Current track is null");
-                return;
-            }
-
             var selectedValue = currentTrack.Context.SelectedValues[0];
             var sourceUrl = await GetSourceUrl(selectedValue, radioSourceService, youTubeService, currentTrack);
 
@@ -113,7 +106,7 @@ await playerState.CurrentVoiceClient.EnterSpeakingStateAsync(
         async Task DisconnectVoiceClientAsync()
         {
             await client.UpdateVoiceStateAsync(
-                new VoiceStateProperties(Context.Guild!.Id, null),
+                new VoiceStateProperties(currentTrack.Context.Guild!.Id, null),
                 null,
                 playerState.StopCts?.Token ?? CancellationToken.None);
             await playerState.CurrentVoiceClient.CloseAsync(
@@ -160,19 +153,19 @@ private async Task<string> GetSourceUrl(string selectedValue, IRadioSourceServic
                     playerState.SkipCts?.Token ?? CancellationToken.None),
                 UserId = currentTrack.Context.User.Id
             };
-            ffmpegProcessService.OnProcessStart += () => HandleOnProcessStartAsync(song);
+            ffmpegProcessService.OnProcessStart += () => HandleOnProcessStartAsync(song, currentTrack.Context);
         }
 
         return sourceUrl;
     }
 
-    private async Task HandleOnProcessStartAsync(SongDtoBase song)
+    private async Task HandleOnProcessStartAsync(SongDtoBase song, StringMenuInteractionContext currentContext)
     {
         using var scope = serviceProvider.CreateScope();
         var statisticsService = scope.ServiceProvider
             .GetRequiredService<IStatisticsService>();
         await statisticsService
-            .LogSongPlayAsync(Context.User.Id, Context.User.Username, Context.User.GlobalName ?? string.Empty, song)
+            .LogSongPlayAsync(currentContext.User.Id, currentContext.User.Username, currentContext.User.GlobalName ?? string.Empty, song)
             .ConfigureAwait(false);
 
         playerState.CurrentAction = PlayerAction.Play;
@@ -181,7 +174,7 @@ await statisticsService
 
     private async Task HandleOnProcessExitAsync()
     {
-        if (queue.Count == 0)
+        if (queue.Count == 0 && !_retrying)
         {
             await (DisconnectedVoiceClientEvent?.Invoke() ?? Task.CompletedTask);
         }
@@ -196,12 +189,17 @@ private async Task HandleFfmpegErrorAsync()
     {
         // Retry to get new stream URL and play again
         logger.LogWarning("Ffmpeg error received, retrying to play the stream");
+        _retrying = true;
         _retryCount++;
         if(_retryCount > 3)
         {
             logger.LogError("Ffmpeg error received, maximum retry count reached, stopping playback");
-            await (DisconnectedVoiceClientEvent?.Invoke() ?? Task.CompletedTask);
-            return;
+            if(queue.Count == 0)
+            {
+                await (DisconnectedVoiceClientEvent?.Invoke() ?? Task.CompletedTask);
+                _retrying = false;
+                return;
+            }
         }
         await HandleMusicPlayingAsync();
     }

src/Infrastructure/Services/NetCordPlayerHandler.cs

@@ -90,16 +90,17 @@ private async Task HandlePlayNextAsync()
 
                 playerService.NotInVoiceChannelCallback += async () =>
                 {
-                    await callbacks.Invoke();
+                    await callbacks.Invoke("You are not connected to any voice channel!");
                 };
 
                 playerService.DisconnectedVoiceClientEvent += async () =>
                 {
                     logger.LogInformation("Voice client disconnected - stopping playback");
                     await DisconnectVoiceClient();
+                    await callbacks.Invoke("Disconnected from voice channel either due to inactivity or error encountered.");
                 };
 
-                await playerService.Play(context, SetDisconnectCallback);
+                await playerService.Play(SetDisconnectCallback);
 
                 queue.DequeueAsync(CancellationToken.None);
             } while (!playerState.StopCts.Token.IsCancellationRequested && queue.Count > 0);