github/Discord.Net
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Readded outgoing audio

Browse Source
This commit is contained in:
RogueException
2016-12-30 00:41:29 -04:00
parent c9a12cde10
commit 2877653a09
15 changed files with 257 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/Discord.Net.WebSocket/Entities/Channels/ISocketAudioChannel.cs
View File

@@ -1,6 +1,10 @@
namespace Discord.WebSocket
using Discord.Audio;
using System.Threading.Tasks;
namespace Discord.WebSocket
{
public interface ISocketAudioChannel : IAudioChannel
{
Task<IAudioClient> ConnectAsync();
}
}

8
src/Discord.Net.WebSocket/Entities/Channels/SocketGroupChannel.cs
View File

@@ -1,4 +1,5 @@
using Discord.Rest;
using Discord.Audio;
using Discord.Rest;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
@@ -64,6 +65,11 @@ namespace Discord.WebSocket
public Task LeaveAsync(RequestOptions options = null)
=> ChannelHelper.DeleteAsync(this, Discord, options);
public Task<IAudioClient> ConnectAsync()
{
throw new NotSupportedException("Voice is not yet supported for group channels.");
}
//Messages
public SocketMessage GetCachedMessage(ulong id)
=> _messages?.Get(id);

14
src/Discord.Net.WebSocket/Entities/Channels/SocketVoiceChannel.cs
View File

@@ -41,6 +41,17 @@ namespace Discord.WebSocket
public Task ModifyAsync(Action<VoiceChannelProperties> func, RequestOptions options = null)
=> ChannelHelper.ModifyAsync(this, Discord, func, options);
public async Task<IAudioClient> ConnectAsync()
{
var audioMode = Discord.AudioMode;
if (audioMode == AudioMode.Disabled)
throw new InvalidOperationException($"Audio is not enabled on this client, {nameof(DiscordSocketConfig.AudioMode)} in {nameof(DiscordSocketConfig)} must be set.");
return await Guild.ConnectAudioAsync(Id,
(audioMode & AudioMode.Incoming) == 0,
(audioMode & AudioMode.Outgoing) == 0).ConfigureAwait(false);
}
public override SocketGuildUser GetUser(ulong id)
{
var user = Guild.GetUser(id);
@@ -52,9 +63,6 @@ namespace Discord.WebSocket
private string DebuggerDisplay => $"{Name} ({Id}, Voice)";
internal new SocketVoiceChannel Clone() => MemberwiseClone() as SocketVoiceChannel;
//IVoiceChannel
Task<IAudioClient> IVoiceChannel.ConnectAsync() { throw new NotSupportedException(); }
//IGuildChannel
Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(GetUser(id));

99
src/Discord.Net.WebSocket/Entities/Guilds/SocketGuild.cs
View File

@@ -421,34 +421,64 @@ namespace Discord.WebSocket
}
//Audio
public async Task DisconnectAudioAsync(AudioClient client = null)
internal async Task<IAudioClient> ConnectAudioAsync(ulong channelId, bool selfDeaf, bool selfMute)
{
selfDeaf = false;
selfMute = false;
TaskCompletionSource<AudioClient> promise;
await _audioLock.WaitAsync().ConfigureAwait(false);
try
{
await DisconnectAudioInternalAsync().ConfigureAwait(false);
promise = new TaskCompletionSource<AudioClient>();
_audioConnectPromise = promise;
await Discord.ApiClient.SendVoiceStateUpdateAsync(Id, channelId, selfDeaf, selfMute).ConfigureAwait(false);
}
catch (Exception)
{
await DisconnectAudioInternalAsync().ConfigureAwait(false);
throw;
}
finally
{
_audioLock.Release();
}
try
{
var timeoutTask = Task.Delay(15000);
if (await Task.WhenAny(promise.Task, timeoutTask) == timeoutTask)
throw new TimeoutException();
return await promise.Task.ConfigureAwait(false);
}
catch (Exception)
{
await DisconnectAudioAsync().ConfigureAwait(false);
throw;
}
}
internal async Task DisconnectAudioAsync()
{
await _audioLock.WaitAsync().ConfigureAwait(false);
try
{
await DisconnectAudioInternalAsync(client).ConfigureAwait(false);
await DisconnectAudioInternalAsync().ConfigureAwait(false);
}
finally
{
_audioLock.Release();
}
}
private async Task DisconnectAudioInternalAsync(AudioClient client = null)
private async Task DisconnectAudioInternalAsync()
{
var oldClient = AudioClient;
if (oldClient != null)
{
if (client == null || oldClient == client)
{
_audioConnectPromise?.TrySetCanceledAsync(); //Cancel any previous audio connection
_audioConnectPromise = null;
}
if (oldClient == client)
{
AudioClient = null;
await oldClient.DisconnectAsync().ConfigureAwait(false);
}
}
_audioConnectPromise?.TrySetCanceledAsync(); //Cancel any previous audio connection
_audioConnectPromise = null;
if (AudioClient != null)
await AudioClient.DisconnectAsync().ConfigureAwait(false);
AudioClient = null;
}
internal async Task FinishConnectAudio(int id, string url, string token)
{
@@ -462,6 +492,14 @@ namespace Discord.WebSocket
var audioClient = new AudioClient(this, id);
audioClient.Disconnected += async ex =>
{
//If the initial connection hasn't been made yet, reconnecting will lead to deadlocks
if (!_audioConnectPromise.Task.IsCompleted)
{
try { audioClient.Dispose(); } catch { }
AudioClient = null;
return;
}
await _audioLock.WaitAsync().ConfigureAwait(false);
try
{
@@ -476,14 +514,14 @@ namespace Discord.WebSocket
{
var voiceChannelId = voiceState2.Value.VoiceChannel?.Id;
if (voiceChannelId != null)
{
await Discord.ApiClient.SendVoiceStateUpdateAsync(Id, voiceChannelId, voiceState2.Value.IsSelfDeafened, voiceState2.Value.IsSelfMuted);
return;
}
}
}
else
{
try { AudioClient.Dispose(); } catch { }
AudioClient = null;
}
try { audioClient.Dispose(); } catch { }
AudioClient = null;
}
}
finally
@@ -498,25 +536,12 @@ namespace Discord.WebSocket
}
catch (OperationCanceledException)
{
await DisconnectAudioAsync().ConfigureAwait(false);
await DisconnectAudioInternalAsync().ConfigureAwait(false);
}
catch (Exception e)
{
await _audioConnectPromise.SetExceptionAsync(e).ConfigureAwait(false);
await DisconnectAudioAsync().ConfigureAwait(false);
}
finally
{
_audioLock.Release();
}
}
internal async Task FinishJoinAudioChannel()
{
await _audioLock.WaitAsync().ConfigureAwait(false);
try
{
if (AudioClient != null)
await _audioConnectPromise.TrySetResultAsync(AudioClient).ConfigureAwait(false);
await DisconnectAudioInternalAsync().ConfigureAwait(false);
}
finally
{