private void OnSpeaking(SocketFrame Event)
{
var speak = Event.GetData <DownstreamEvents.Speak>();
_webrtcManager.SetSpeaking((uint)speak.SSRC, speak.Speaking);
FireEventOnDelegate(Event, Speak);
}
async void IpDiscover(object sender, PacketReceivedEventArgs args)
{
var packet = (byte[])args.Message;
string ip = "";
int port = 0;
try
{
ip = Encoding.UTF8.GetString(packet, 4, 70 - 6).TrimEnd('\0');
port = (packet[68] << 8) | packet[69];
}
catch /*(Exception exception)*/
{
//App.NavigateToBugReport(exception);
}
var info = new UdpProtocolInfo()
{
Address = ip,
Port = port,
Codecs = new List <Codec>()
{
new Codec()
{
Name = "opus",
payloadType = 120,
Priority = 1000,
Type = "audio",
rtxPayloadType = 120
},
new Codec()
{
Name = "VP8",
payloadType = 101,
Priority = 1000,
Type = "video",
rtxPayloadType = 102
}
}.ToArray(),
Mode = "xsalsa20_poly1305" //"_suffix"
};
var payload = new SelectProtocol()
{
Protocol = "udp",
Data = info
};
SocketFrame package = new SocketFrame()
{
Operation = (int)OperationCode.SelectProtocol,
Payload = payload,
Type = EventNames.SELECT_PROTOCOL
};
_udpSocket.MessageReceived -= IpDiscover;
_udpSocket.MessageReceived += processUdpPacket;
await _webMessageSocket.SendJsonObjectAsync(package);
}
// Use this for initialization
void Start()
{
frame = new SocketFrame();
clientSocket = new TcpClient();
clientSocket.Connect("127.0.0.1", 6500);
inStream = new byte[15000];
}
private async Task SendAsync(GatewayOpCode opCode, object payload)
{
var frame = new SocketFrame {
Operation = (int)opCode, Payload = payload
};
var bytes = _server.Serialize(frame, _outBuffer);
var segment = new ArraySegment <byte>(_outBuffer, 0, bytes);
await _socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None).ConfigureAwait(false);
}
private void OnReady(SocketFrame gatewayEvent)
{
var ready = gatewayEvent.GetData <Ready>();
lastReady = ready;
FireEventOnDelegate(gatewayEvent, Ready);
}
private async void OnReady(SocketFrame Event)
{
var ready = Event.GetData <Ready>();
lastReady = ready;
FireEventOnDelegate(Event, Ready);
await _webrtcManager.ConnectAsync(ready.Ip, ready.Port.ToString(), lastReady.SSRC);
}
private void OnChannelDeleted(SocketFrame gatewayEvent)
{
if (IsChannelAGuildChannel(gatewayEvent))
{
FireEventOnDelegate(gatewayEvent, GuildChannelDeleted);
}
else
{
FireEventOnDelegate(gatewayEvent, DirectMessageChannelDeleted);
}
}
private async void IdentifySelfToVoiceConnection()
{
var identifyEvent = new SocketFrame
{
Type = EventNames.IDENTIFY,
Operation = OperationCode.Identify.ToInt(),
Payload = GetIdentityAsync()
};
await _webMessageSocket.SendJsonObjectAsync(identifyEvent);
}
private async void OnReady(SocketFrame Event)
{
var ready = Event.GetData <Ready>();
lastReady = ready;
FireEventOnDelegate(Event, Ready);
await ConnectUDPAsync(ready.Ip, ready.Port.ToString());
SendSelectProtocol();
}
private async Task UpdateStatus(StatusUpdate status)
{
var statusevent = new SocketFrame()
{
Operation = 3,
Payload = status
};
await SendMessageAsync(JsonConvert.SerializeObject(statusevent));
//await _webMessageSocket.SendJsonObjectAsync(statusevent);
}
private void OnHelloReceived(SocketFrame gatewayEvent)
{
if (TryResume)
{
SendResumeRequest();
TryResume = false;
}
else
{
IdentifySelfToGateway();
BeginHeartbeatAsync(gatewayEvent.GetData <Hello>().HeartbeatInterval);
}
}
private async void IdentifySelfToGateway()
{
var identifyEvent = new SocketFrame
{
Type = EventNames.IDENTIFY,
Operation = OperationCode.Identify.ToInt(),
Payload = GetIdentityAsync()
};
await SendMessageAsync(JsonConvert.SerializeObject(identifyEvent));
// await _webMessageSocket.SendJsonObjectAsync(identifyEvent);
}
internal DiscordVoiceAPIClient(DiscordSocketConfig config, ulong guildId, WebSocketProvider webSocketProvider, UdpSocketProvider udpSocketProvider, JsonSerializer serializer = null)
{
GuildId = guildId;
_connectionLock = new SemaphoreSlim(1, 1);
_udp = udpSocketProvider();
Config = config;
_udp.ReceivedDatagram += async(data, index, count) =>
{
if (index != 0 || count != data.Length)
{
byte[] newData = new byte[count];
Buffer.BlockCopy(data, index, newData, 0, count);
data = newData;
}
await _receivedPacketEvent.InvokeAsync(data).ConfigureAwait(false);
};
WebSocketClient = webSocketProvider();
//_gatewayClient.SetHeader("user-agent", DiscordConfig.UserAgent); //(Causes issues in .Net 4.6+)
WebSocketClient.BinaryMessage += async(data, index, count) =>
{
using (MemoryStream compressed = new MemoryStream(data, index + 2, count - 2))
using (MemoryStream decompressed = new MemoryStream())
{
using (DeflateStream zlib = new DeflateStream(compressed, CompressionMode.Decompress))
zlib.CopyTo(decompressed);
decompressed.Position = 0;
using (StreamReader reader = new StreamReader(decompressed))
{
SocketFrame msg = JsonConvert.DeserializeObject <SocketFrame>(reader.ReadToEnd());
await _receivedEvent.InvokeAsync((VoiceOpCode)msg.Operation, msg.Payload).ConfigureAwait(false);
}
}
};
WebSocketClient.TextMessage += async text =>
{
SocketFrame msg = JsonConvert.DeserializeObject <SocketFrame>(text);
await _receivedEvent.InvokeAsync((VoiceOpCode)msg.Operation, msg.Payload).ConfigureAwait(false);
};
WebSocketClient.Closed += async ex =>
{
await DisconnectAsync().ConfigureAwait(false);
await _disconnectedEvent.InvokeAsync(ex).ConfigureAwait(false);
};
_serializer = serializer ?? new JsonSerializer {
ContractResolver = new DiscordContractResolver()
};
}
public async Task SendAsync(VoiceOpCode opCode, object payload, RequestOptions options = null)
{
byte[] bytes = null;
payload = new SocketFrame {
Operation = (int)opCode, Payload = payload
};
if (payload != null)
{
bytes = Encoding.UTF8.GetBytes(SerializeJson(payload));
}
await WebSocketClient.SendAsync(bytes, 0, bytes.Length, true).ConfigureAwait(false);
await _sentGatewayMessageEvent.InvokeAsync(opCode).ConfigureAwait(false);
}
private void OnInvalidSession(SocketFrame gatewayEvent)
{
if (invalidSessionRetryCount > 0)
{
invalidSessionRetryCount--;
_ = ConnectAsync(connectionUrl);
}
else
{
ConnectedSocket = false;
FireEventOnDelegate(gatewayEvent, InvalidSession);
}
}
private void OnChannelDeleted(SocketFrame gatewayEvent)
{
GatewayEventArgs <Channel> eventArgs;
if (IsChannelAGuildChannel(gatewayEvent))
{
eventArgs = new GatewayEventArgs <Channel>(gatewayEvent.GetData <GuildChannel>());
}
else
{
eventArgs = new GatewayEventArgs <Channel>(gatewayEvent.GetData <DirectMessageChannel>());
}
ChannelDeleted?.Invoke(this, eventArgs);
}
private void OnSessionDesc(SocketFrame Event)
{
var Desc = Event.GetData <SessionDescription>();
secretkey = Desc.SecretKey;
//Needs to speak 100 silent frames to get first listen packet
SendSpeaking(true);
for (int i = 0; i < 100; i++)
{
SendSilence();
}
SendSpeaking(false);
}
private void OnSocketMessageReceived(object sender, MessageReceivedEventArgs args)
{
var gatewayEvent = JsonConvert.DeserializeObject <SocketFrame>(args.Message);
lastEvent = gatewayEvent;
if (operationHandlers.ContainsKey(gatewayEvent.Operation.GetValueOrDefault()))
{
operationHandlers[gatewayEvent.Operation.GetValueOrDefault()](gatewayEvent);
}
if (gatewayEvent.Type != null && eventHandlers.ContainsKey(gatewayEvent.Type))
{
eventHandlers[gatewayEvent.Type](gatewayEvent);
}
}
/// <summary>
/// Subscribe to various channel-specific events (most notably "Typing")
/// </summary>
/// <param name="channelIds"></param>
/// <returns>True if the payload was valid, false if it wasn't</returns>
public async Task <bool> SubscribeToGuild(string[] channelIds)
{
if (channelIds.Length > 193) //This is really, really random, but it's apparently the maximum array size for the op12 event.
{
return(false);
}
var identifyEvent = new SocketFrame
{
Operation = OperationCode.SubscribeToGuild.ToInt(),
Payload = channelIds
};
await SendMessageAsync(JsonConvert.SerializeObject(identifyEvent));
return(true);
}
private async Task SendHeartbeatAsync()
{
try
{
var heartbeatEvent = new SocketFrame
{
Operation = OperationCode.Heartbeat.ToInt(),
Payload = Math.Round(DateTime.Now.ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds)
};
await _webMessageSocket.SendJsonObjectAsync(heartbeatEvent);
}
catch /*(Exception exception)*/
{
//App.NavigateToBugReport(exception);
}
}
private void HandleMessage(TextReader reader)
{
if (Logger?.IsEnabled(LogLevel.Trace) ?? false)
{
Logger?.LogTrace("Handle Message.");
}
using (JsonReader jsreader = new JsonTextReader(reader))
{
JsonSerializer serializer = new JsonSerializer();
SocketFrame frame = serializer.Deserialize <SocketFrame>(jsreader);
if (Logger?.IsEnabled(LogLevel.Trace) ?? false)
{
Logger?.LogTrace($"Frame:" +
$"\n\tOperation: {frame.Operation}" +
$"\n\tSequenceNumber: {frame.SequenceNumber}" +
$"\n\tType: {frame.Type}" +
$"\n\tPayload: {frame.Payload}"
);
}
if (frame.SequenceNumber.HasValue)
{
lastGatewayEventSeq = frame.SequenceNumber.Value;
}
if (operationHandlers.ContainsKey(frame.Operation.GetValueOrDefault()))
{
operationHandlers[frame.Operation.GetValueOrDefault()](frame);
}
else if (frame.Type != null && eventHandlers.ContainsKey(frame.Type))
{
eventHandlers[frame.Type](frame);
}
else
{
Logger?.LogDebug($"Unknown message:" +
$"\n\tOperation: {frame.Operation}" +
$"\n\tSequenceNumber: {frame.SequenceNumber}" +
$"\n\tType: {frame.Type}" +
$"\n\tPayload: {frame.Payload}"
);
}
}
}
public async Task Search(string query, List <string> guilds, int limit)
{
var frame = new SocketFrame()
{
Operation = 8,
Payload = new Search
{
query = query,
limit = limit,
guild_id = guilds
}
};
await SendMessageAsync(JsonConvert.SerializeObject(frame));
// var serialzedObject = ;
// await _webMessageSocket.SendJsonObjectAsync(frame);
}
private async void WebrtcManagerOnIpAndPortObtained(object sender, Tuple <string, ushort> e)
{
var info = new UdpProtocolInfo()
{
Address = e.Item1,
Port = e.Item2,
Codecs = new List <Codec>()
{
new Codec()
{
Name = "opus",
payloadType = 120,
Priority = 1000,
Type = "audio",
rtxPayloadType = 120,
},
new Codec()
{
Name = "VP8",
payloadType = 101,
Priority = 1000,
Type = "video",
rtxPayloadType = 102,
},
}.ToArray(),
Mode = "xsalsa20_poly1305", //"_suffix"
};
var payload = new SelectProtocol()
{
Protocol = "udp",
Data = info,
};
SocketFrame package = new SocketFrame()
{
Operation = (int)OperationCode.SelectProtocol,
Payload = payload,
Type = EventNames.SELECT_PROTOCOL,
};
await _webMessageSocket.SendJsonObjectAsync(package);
}
public async Task RequestAllGuildMembers(string guildid)
{
var payload = new GuildMembersRequest()
{
GuildId = guildid,
Query = "",
Limit = 0
};
var request = new SocketFrame()
{
Operation = (int)OperationCode.RequestGuildMembers,
Payload = payload
};
await SendMessageAsync(JsonConvert.SerializeObject(request));
//await _webMessageSocket.SendJsonObjectAsync(request);
}
public async void SendSpeaking(int speaking)
{
DownstreamEvents.Speak Event = new DownstreamEvents.Speak
{
Speaking = speaking,
};
Speak?.Invoke(this, new VoiceConnectionEventArgs <DownstreamEvents.Speak>(Event));
var speakingPacket = new SocketFrame
{
Operation = OperationCode.Speaking.ToInt(),
Payload = new UpstreamEvents.Speak()
{
Speaking = speaking,
Delay = 0,
SSRC = lastReady?.SSRC ?? 0,
},
};
await _webMessageSocket.SendJsonObjectAsync(speakingPacket);
}
public async Task SubscribeToGuildLazy(string guildId, IReadOnlyDictionary <string, IEnumerable <int[]> > channels = null, IEnumerable <string> members = null)
{
var updateGuildSubscriptions = new SocketFrame
{
Operation = (int)OperationCode.UpdateGuildSubscriptions,
Payload = new UpdateGuildSubscriptions()
{
GuildId = guildId,
Channels = channels,
Members = members,
Typing = true
}
};
await SendMessageAsync(JsonConvert.SerializeObject(updateGuildSubscriptions, Formatting.None, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}
));
}
public async Task VoiceStatusUpdate(string guildId, string channelId, bool selfMute, bool selfDeaf)
{
var payload = new VoiceStatusUpdate()
{
GuildId = guildId,
ChannelId = channelId,
Deaf = selfDeaf,
Mute = selfMute
};
var request = new SocketFrame()
{
Operation = (int)OperationCode.VoiceStateUpdate,
Payload = payload
};
await SendMessageAsync(JsonConvert.SerializeObject(request));
//await _webMessageSocket.SendJsonObjectAsync(request);
}
public async Task RequestGuildMembers(IEnumerable <string> guildIds, string query, int?limit, bool?presences, IEnumerable <string> userIds)
{
var updateGuildSubscriptions = new SocketFrame
{
Operation = (int)OperationCode.RequestGuildMembers,
Payload = new GuildRequestMembers()
{
GuildIds = guildIds,
Query = query,
Limit = limit,
Presences = presences,
UserIds = userIds
}
};
await SendMessageAsync(JsonConvert.SerializeObject(updateGuildSubscriptions, Formatting.None, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}
));
}
private async Task SendHeartbeatAsync()
{
try
{
var heartbeatEvent = new SocketFrame
{
Operation = OperationCode.Heartbeat.ToInt(),
Payload = lastGatewayEventSeq
};
if (DateTime.Now.Day == 1 && DateTime.Now.Month == 4) //April 1st
{
//App.PlayHeartBeat();
}
await SendMessageAsync(JsonConvert.SerializeObject(heartbeatEvent));
//await _webMessageSocket.SendJsonObjectAsync(heartbeatEvent);
}
catch /*(Exception exception)*/
{
//App.NavigateToBugReport(exception);
}
}
public async void SendSpeaking(bool speaking)
{
DownstreamEvents.Speak Event = new DownstreamEvents.Speak
{
Speaking = speaking
};
Speak?.Invoke(this, new VoiceConnectionEventArgs <DownstreamEvents.Speak>(Event));
if (speaking == false)
{
SendSilence();
}
var speakingPacket = new SocketFrame
{
Operation = OperationCode.Speaking.ToInt(),
Payload = new UpstreamEvents.Speak()
{
Speaking = speaking,
Delay = 0,
SSRC = lastReady != null ? lastReady.SSRC : 0
}
};
await _webMessageSocket.SendJsonObjectAsync(speakingPacket);
}
