mctaylors/Cassette
mctaylors/Cassette
1
0
Fork 0
Code Issues Pull requests Activity

Pass CancellationTokens where possible

Browse source 
cancellationtokens all 'round
This commit is contained in:
Macintxsh 2024-06-15 00:22:38 +05:00
parent 34c39e8491
commit ea313bab7b
Signed by: mctaylors
GPG key ID: 4EEF4F949A266EE2
6 changed files with 94 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Cassette/Commands/BotCommandGroup.cs
View file

@ -30,7 +30,7 @@ public sealed class BotCommandGroup(
[UsedImplicitly] [UsedImplicitly]
public async Task<Result> AboutCommandAsync() public async Task<Result> AboutCommandAsync()
{ {
var botResult = await userApi.GetCurrentUserAsync(); var botResult = await userApi.GetCurrentUserAsync(CancellationToken);
if (!botResult.IsDefined(out var bot)) if (!botResult.IsDefined(out var bot))
{ {
return Result.FromError(botResult); return Result.FromError(botResult);
@ -58,6 +58,6 @@ public sealed class BotCommandGroup(
new FeedbackMessageOptions(MessageComponents: new[] new FeedbackMessageOptions(MessageComponents: new[]
{ {
new ActionRowComponent(new[] { button }) new ActionRowComponent(new[] { button })
})); }), CancellationToken);
} }
} }

110
Cassette/Commands/ControlsCommandGroup.cs
View file

@ -34,7 +34,8 @@ public sealed class ControlsCommandGroup(
public async Task<Result> PlayCommandAsync( public async Task<Result> PlayCommandAsync(
[Description("URL or YouTube query")] string query) [Description("URL or YouTube query")] string query)
{ {
var player = await LavalinkPlayer.GetPlayerAsync(commandContext, audioService, feedbackService, true); var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService, true, CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -42,52 +43,57 @@ public sealed class ControlsCommandGroup(
if (File.Exists(query)) if (File.Exists(query))
{ {
var track = await audioService.Tracks.LoadTrackAsync(Path.GetFullPath(query), TrackSearchMode.None); var track = await audioService.Tracks.LoadTrackAsync(
return await PlayTrackResultAsync(player, track); Path.GetFullPath(query), TrackSearchMode.None, cancellationToken: CancellationToken);
return await PlayTrackResultAsync(player, track, CancellationToken);
} }
var loadResult = await audioService.Tracks.LoadTracksAsync(query, TrackSearchMode.YouTube); var loadResult = await audioService.Tracks.LoadTracksAsync(
query, TrackSearchMode.YouTube, cancellationToken: CancellationToken);
if (!loadResult.IsSuccess) if (!loadResult.IsSuccess)
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"Track loading error, try again later.", feedbackService.Theme.FaultOrDanger); "Track loading error, try again later.",
feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
if (loadResult.IsPlaylist) if (loadResult.IsPlaylist)
{ {
return await PlayListResultAsync(player, loadResult); return await PlayListResultAsync(player, loadResult, CancellationToken);
} }
return await PlayTrackResultAsync(player, loadResult.Track); return await PlayTrackResultAsync(player, loadResult.Track, CancellationToken);
} }
private async Task<Result> PlayTrackResultAsync(IQueuedLavalinkPlayer player, LavalinkTrack? track) private async Task<Result> PlayTrackResultAsync(IQueuedLavalinkPlayer player,
LavalinkTrack? track, CancellationToken ct = default)
{ {
if (track is null) if (track is null)
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"Not found.", feedbackService.Theme.FaultOrDanger); "Not found.", feedbackService.Theme.FaultOrDanger, ct);
} }
await player.PlayAsync(track); await player.PlayAsync(track, cancellationToken: ct);
var message = new StringBuilder().Append($"Added {track.Display()}"); var message = new StringBuilder().Append($"Added {track.Display()}");
if (player.Queue.IsEmpty) switch (player.Queue.IsEmpty)
{ {
message.Append(" to begin playing"); case true:
} message.Append(" to begin playing");
break;
if (!player.Queue.IsEmpty) case false:
{ message.Append(" to the queue at position ").Append(player.Queue.Count);
message.Append(" to the queue at position ").Append(player.Queue.Count); break;
} }
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
message.ToString(), feedbackService.Theme.Success); message.ToString(), feedbackService.Theme.Success, ct);
} }
private async Task<Result> PlayListResultAsync(IQueuedLavalinkPlayer player, TrackLoadResult loadResult) private async Task<Result> PlayListResultAsync(IQueuedLavalinkPlayer player,
TrackLoadResult loadResult, CancellationToken ct = default)
{ {
var playlistInfo = loadResult.Playlist; var playlistInfo = loadResult.Playlist;
if (playlistInfo is null) if (playlistInfo is null)
@ -97,11 +103,12 @@ public sealed class ControlsCommandGroup(
foreach (var track in loadResult.Tracks) foreach (var track in loadResult.Tracks)
{ {
await player.PlayAsync(track); await player.PlayAsync(track, cancellationToken: ct);
} }
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Added {Markdown.Bold(playlistInfo.Name)} playlist to the queue", feedbackService.Theme.Success); $"Added {Markdown.Bold(playlistInfo.Name)} playlist to the queue",
feedbackService.Theme.Success, ct);
} }
[Command("pause")] [Command("pause")]
@ -111,7 +118,7 @@ public sealed class ControlsCommandGroup(
public async Task<Result> PauseCommandAsync() public async Task<Result> PauseCommandAsync()
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -121,20 +128,21 @@ public sealed class ControlsCommandGroup(
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's nothing playing right now.", "There's nothing playing right now.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
if (player.IsPaused) if (player.IsPaused)
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"Player is currently paused", "Player is currently paused",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
await player.PauseAsync(); await player.PauseAsync(CancellationToken);
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Paused {player.CurrentTrack.Display()}", feedbackService.Theme.Success); $"Paused {player.CurrentTrack.Display()}",
feedbackService.Theme.Success, CancellationToken);
} }
[Command("resume")] [Command("resume")]
@ -144,7 +152,7 @@ public sealed class ControlsCommandGroup(
public async Task<Result> ResumeCommandAsync() public async Task<Result> ResumeCommandAsync()
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -154,20 +162,21 @@ public sealed class ControlsCommandGroup(
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's nothing playing right now.", "There's nothing playing right now.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
if (!player.IsPaused) if (!player.IsPaused)
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"Player is currently not paused.", "Player is currently not paused.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
await player.ResumeAsync(); await player.ResumeAsync(CancellationToken);
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Resumed {player.CurrentTrack.Display()}", feedbackService.Theme.Success); $"Resumed {player.CurrentTrack.Display()}",
feedbackService.Theme.Success, CancellationToken);
} }
[Command("repeat")] [Command("repeat")]
@ -178,7 +187,7 @@ public sealed class ControlsCommandGroup(
[Description("Track repeat mode")] TrackRepeatMode mode) [Description("Track repeat mode")] TrackRepeatMode mode)
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -188,21 +197,21 @@ public sealed class ControlsCommandGroup(
&& mode is not TrackRepeatMode.Queue) && mode is not TrackRepeatMode.Queue)
{ {
var queue = player.Queue; var queue = player.Queue;
await queue.RemoveAsync(queue[^1]); await queue.RemoveAsync(queue[^1], CancellationToken);
} }
if (player.RepeatMode is not TrackRepeatMode.Queue if (player.RepeatMode is not TrackRepeatMode.Queue
&& mode is TrackRepeatMode.Queue && mode is TrackRepeatMode.Queue
&& player.CurrentTrack is not null) && player.CurrentTrack is not null)
{ {
await player.PlayAsync(player.CurrentTrack); await player.PlayAsync(player.CurrentTrack, cancellationToken: CancellationToken);
} }
player.RepeatMode = mode; player.RepeatMode = mode;
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Repeat mode is now set to {Markdown.Bold(mode.ToString())}", $"Repeat mode is now set to {Markdown.Bold(mode.ToString())}",
feedbackService.Theme.Success); feedbackService.Theme.Success, CancellationToken);
} }
[Command("shuffle")] [Command("shuffle")]
@ -213,7 +222,7 @@ public sealed class ControlsCommandGroup(
[Description("Enable shuffle mode")] bool enable) [Description("Enable shuffle mode")] bool enable)
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -223,7 +232,7 @@ public sealed class ControlsCommandGroup(
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Shuffle mode is now {Markdown.Bold(enable ? "enabled" : "disabled")}", $"Shuffle mode is now {Markdown.Bold(enable ? "enabled" : "disabled")}",
feedbackService.Theme.Success); feedbackService.Theme.Success, CancellationToken);
} }
[Command("seek")] [Command("seek")]
@ -234,7 +243,7 @@ public sealed class ControlsCommandGroup(
[Description("Position to rewind")] TimeSpan position) [Description("Position to rewind")] TimeSpan position)
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -244,7 +253,7 @@ public sealed class ControlsCommandGroup(
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's nothing playing right now.", "There's nothing playing right now.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
var track = player.CurrentTrack; var track = player.CurrentTrack;
@ -255,13 +264,14 @@ public sealed class ControlsCommandGroup(
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Selected position ({position.ReadableDuration()}) is greater than " + $"Selected position ({position.ReadableDuration()}) is greater than " +
$"track's duration ({trackDuration.ReadableDuration()})", $"track's duration ({trackDuration.ReadableDuration()})",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
await player.SeekAsync(position); await player.SeekAsync(position, CancellationToken);
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"{track.Display()} rewound to {position.ReadableDuration()}", feedbackService.Theme.Success); $"{track.Display()} rewound to {position.ReadableDuration()}",
feedbackService.Theme.Success, CancellationToken);
} }
[Command("skip")] [Command("skip")]
@ -273,7 +283,7 @@ public sealed class ControlsCommandGroup(
int? index = null) int? index = null)
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -286,13 +296,13 @@ public sealed class ControlsCommandGroup(
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's no track with that index.", "There's no track with that index.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
var queueItem = queue[(int)index - 1]; var queueItem = queue[(int)index - 1];
var track = queueItem.Track; var track = queueItem.Track;
await player.Queue.RemoveAsync(queueItem); await player.Queue.RemoveAsync(queueItem, CancellationToken);
if (track is null) if (track is null)
{ {
@ -300,7 +310,8 @@ public sealed class ControlsCommandGroup(
} }
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Removed {track.Display()} from queue", feedbackService.Theme.Success); $"Removed {track.Display()} from queue",
feedbackService.Theme.Success, CancellationToken);
} }
var currentTrack = player.CurrentTrack; var currentTrack = player.CurrentTrack;
@ -308,12 +319,13 @@ public sealed class ControlsCommandGroup(
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's nothing playing right now.", "There's nothing playing right now.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
await player.SkipAsync(); await player.SkipAsync(cancellationToken: CancellationToken);
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Skipped {currentTrack.Display()}", feedbackService.Theme.Success); $"Skipped {currentTrack.Display()}",
feedbackService.Theme.Success, CancellationToken);
} }
} }

23
Cassette/Commands/InfoCommandGroup.cs
View file

@ -29,7 +29,7 @@ public sealed class InfoCommandGroup(
public async Task<Result> NowPlayingCommandAsync() public async Task<Result> NowPlayingCommandAsync()
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -40,11 +40,12 @@ public sealed class InfoCommandGroup(
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's nothing playing right now.", "There's nothing playing right now.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"You're listening to {currentTrack.Display(true)}", feedbackService.Theme.Text); $"You're listening to {currentTrack.Display(true)}",
feedbackService.Theme.Text, CancellationToken);
} }
[Command("queue")] [Command("queue")]
@ -54,7 +55,7 @@ public sealed class InfoCommandGroup(
public async Task<Result> QueueCommandAsync() public async Task<Result> QueueCommandAsync()
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -62,23 +63,24 @@ public sealed class InfoCommandGroup(
var builder = new StringBuilder(); var builder = new StringBuilder();
var getResult = await GetQueueAsync(player, builder); var getResult = await GetQueueAsync(player, builder, CancellationToken);
if (!getResult.IsSuccess) if (!getResult.IsSuccess)
{ {
return Result.FromError(getResult.Error); return Result.FromError(getResult.Error);
} }
return await feedbackService.SendContextualMessageResult(builder.ToString()); return await feedbackService.SendContextualMessageResult(builder.ToString(), ct: CancellationToken);
} }
private async Task<Result> GetQueueAsync(IQueuedLavalinkPlayer player, StringBuilder builder) private async Task<Result> GetQueueAsync(IQueuedLavalinkPlayer player,
StringBuilder builder, CancellationToken ct = default)
{ {
var queue = player.Queue; var queue = player.Queue;
if (queue.IsEmpty) if (queue.IsEmpty)
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's nothing in queue right now.", "There's nothing in queue right now.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, ct);
} }
var repeatMode = player.RepeatMode; var repeatMode = player.RepeatMode;
@ -119,13 +121,14 @@ public sealed class InfoCommandGroup(
public async Task<Result> VolumeCommandAsync() public async Task<Result> VolumeCommandAsync()
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
} }
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Current volume is {Markdown.Bold($"{player.Volume * 100}%")}", feedbackService.Theme.Text); $"Current volume is {Markdown.Bold($"{player.Volume * 100}%")}",
feedbackService.Theme.Text, CancellationToken);
} }
} }

21
Cassette/Commands/TrustedCommandGroup.cs
View file

@ -33,18 +33,18 @@ public sealed class TrustedCommandGroup(
[MinValue(1)] [MaxValue(200)] float percentage) [MinValue(1)] [MaxValue(200)] float percentage)
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
} }
var previousVolume = player.Volume / 100; var previousVolume = player.Volume / 100;
await player.SetVolumeAsync(percentage / 100); await player.SetVolumeAsync(percentage / 100, CancellationToken);
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Volume changed {Markdown.Bold($"{previousVolume}%")} to {Markdown.Bold($"{percentage}%")}", $"Volume changed {Markdown.Bold($"{previousVolume}%")} to {Markdown.Bold($"{percentage}%")}",
feedbackService.Theme.Success); feedbackService.Theme.Success, CancellationToken);
} }
[Command("stop")] [Command("stop")]
@ -55,7 +55,7 @@ public sealed class TrustedCommandGroup(
public async Task<Result> StopCommandAsync() public async Task<Result> StopCommandAsync()
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
@ -65,15 +65,16 @@ public sealed class TrustedCommandGroup(
{ {
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"There's nothing playing right now.", "There's nothing playing right now.",
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, CancellationToken);
} }
var track = player.CurrentTrack; var track = player.CurrentTrack;
await player.StopAsync(); await player.StopAsync(CancellationToken);
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
$"Stopped {track.Display()} and cleared the queue.", feedbackService.Theme.Success); $"Stopped {track.Display()} and cleared the queue.",
feedbackService.Theme.Success, CancellationToken);
} }
[Command("disconnect")] [Command("disconnect")]
@ -84,15 +85,15 @@ public sealed class TrustedCommandGroup(
public async Task<Result> DisconnectCommandAsync() public async Task<Result> DisconnectCommandAsync()
{ {
var player = await LavalinkPlayer.GetPlayerAsync( var player = await LavalinkPlayer.GetPlayerAsync(
commandContext, audioService, feedbackService); commandContext, audioService, feedbackService, ct: CancellationToken);
if (player is null) if (player is null)
{ {
return Result.FromSuccess(); return Result.FromSuccess();
} }
await player.DisconnectAsync(); await player.DisconnectAsync(CancellationToken);
return await feedbackService.SendContextualMessageResult( return await feedbackService.SendContextualMessageResult(
"Disconnected.", feedbackService.Theme.Success); "Disconnected.", feedbackService.Theme.Success, CancellationToken);
} }
} }

5
Cassette/Extensions/FeedbackServiceExtensions.cs
View file

@ -9,10 +9,11 @@ namespace Cassette.Extensions;
public static class FeedbackServiceExtensions public static class FeedbackServiceExtensions
{ {
public static async Task<Result> SendContextualMessageResult( public static async Task<Result> SendContextualMessageResult(
this IFeedbackService feedbackService, string message, Color? color = null) this IFeedbackService feedbackService, string message, Color? color = null,
CancellationToken ct = default)
{ {
return (Result)await feedbackService.SendContextualMessageAsync( return (Result)await feedbackService.SendContextualMessageAsync(
new FeedbackMessage(message, color ?? feedbackService.Theme.Secondary)); new FeedbackMessage(message, color ?? feedbackService.Theme.Secondary), ct: ct);
} }
public static async Task<Result> SendContextualEmbedResult( public static async Task<Result> SendContextualEmbedResult(

7
Cassette/LavalinkPlayer.cs
View file

@ -12,13 +12,14 @@ public abstract class LavalinkPlayer
{ {
public static async ValueTask<QueuedLavalinkPlayer?> GetPlayerAsync( public static async ValueTask<QueuedLavalinkPlayer?> GetPlayerAsync(
ICommandContext commandContext, IAudioService audioService, ICommandContext commandContext, IAudioService audioService,
FeedbackService feedbackService, bool connectToVoiceChannel = false) FeedbackService feedbackService, bool connectToVoiceChannel = false,
CancellationToken ct = default)
{ {
var retrieveOptions = new PlayerRetrieveOptions( var retrieveOptions = new PlayerRetrieveOptions(
ChannelBehavior: connectToVoiceChannel ? PlayerChannelBehavior.Join : PlayerChannelBehavior.None); ChannelBehavior: connectToVoiceChannel ? PlayerChannelBehavior.Join : PlayerChannelBehavior.None);
var result = await audioService.Players var result = await audioService.Players
.RetrieveAsync(commandContext, PlayerFactory.Queued, retrieveOptions); .RetrieveAsync(commandContext, PlayerFactory.Queued, retrieveOptions, ct);
if (result.IsSuccess) if (result.IsSuccess)
{ {
@ -33,7 +34,7 @@ public abstract class LavalinkPlayer
}; };
await feedbackService.SendContextualMessageResult(errorMessage, await feedbackService.SendContextualMessageResult(errorMessage,
feedbackService.Theme.FaultOrDanger); feedbackService.Theme.FaultOrDanger, ct);
return null; return null;
} }