private void Socket_OnMessageSend(object sender, SocketMessageEventArgs e)
{
//Console.ForegroundColor = ConsoleColor.Yellow;
//Console.Write($"[{DateTime.Now}]");
//Console.ForegroundColor = ConsoleColor.Cyan;
//Console.WriteLine(e.Content);
}
private void OnMessageReceived(object sender, SocketMessageEventArgs socketMessageEventArgs)
{
var socketClient = (SocketClient)sender;
socketClient.MessageReceived -= OnMessageReceived; // TODO: validate the protocol confirmation
Add(socketClient);
}
private async Task VoiceWS_SocketMessage(IWebSocketClient client, SocketMessageEventArgs e)
{
if (!(e is SocketTextMessageEventArgs et))
{
this.Discord.Logger.LogCritical(VoiceNextEvents.VoiceGatewayError, "Discord Voice Gateway sent binary data - unable to process");
return;
}
if (this.Discord.Configuration.MinimumLogLevel == LogLevel.Trace)
{
var cs = new MemoryStream();
await et.Message.CopyToAsync(cs).ConfigureAwait(false);
cs.Seek(0, SeekOrigin.Begin);
et.Message.Seek(0, SeekOrigin.Begin);
using var sr = new StreamReader(cs, Utilities.UTF8);
this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceWsRx, await sr.ReadToEndAsync().ConfigureAwait(false));
}
var j = await DiscordJson.LoadJObjectAsync(et.Message).ConfigureAwait(false);
await this.HandleDispatch(j).ConfigureAwait(false);
}
private void ServerDataReceivedHandler(object sender, SocketMessageEventArgs e)
{
this.Invoke(new Action(() =>
{
var msg = System.Text.Encoding.ASCII.GetString(e.Buffer, 0, e.Size);
var rm = new ReceivedMessageEntry(msg, e.EndPoint.ToString());
RecordMessage(rm);
}));
}
private void OnMessageReceived(object sender, SocketMessageEventArgs e)
{
if (txtContent.InvokeRequired)
{
txtContent.Invoke(new EventHandler <SocketMessageEventArgs>(OnMessageReceived), sender, e);
return;
}
txtMsgReceived.Text = e.Content;
}
private Task VoiceWS_SocketMessage(SocketMessageEventArgs e)
{
if (!(e is SocketTextMessageEventArgs et))
{
this.Discord.DebugLogger.LogMessage(LogLevel.Critical, "VoiceNext", "Discord Voice Gateway spewed out binary gibberish!", DateTime.Now);
return(Task.CompletedTask);
}
return(this.HandleDispatch(JObject.Parse(et.Message)));
}
private async void StartListen()
{
try
{
while (_ws != null && _ws.State == WebSocketState.Open)
{
byte[] Sharedbuffer = new byte[ReceiveChunkSize];
using (var ms = new MemoryStream()) // auto release memory
{
WebSocketReceiveResult res;
do
{
res = await _ws.ReceiveAsync(Sharedbuffer, CancellationToken.None);
if (res.MessageType == WebSocketMessageType.Close)
{
CallOnDisconnected(null);
return;
}
ms.Write(Sharedbuffer, 0, res.Count);
// ms.Write(segment.Array, segment.Offset, res.Count);
}while (!res.EndOfMessage);
ms.Seek(0, SeekOrigin.Begin);
// Return data
byte[] returnBuffer = new byte[ms.Length];
Buffer.BlockCopy(ms.ToArray(), 0, returnBuffer, 0, (int)ms.Length);
string msg = Encoding.UTF8.GetString(returnBuffer);
// Fires the return packet in a new thread
ThreadPool.QueueUserWorkItem(state =>
{
SocketMessageEventArgs args = new SocketMessageEventArgs
{
Message = msg
};
MessageReceived?.Invoke(this, args);
});
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
CallOnDisconnected(ex.Message);
}
finally
{
_ws.Dispose();
}
}
private Task VoiceWS_SocketMessage(IWebSocketClient client, SocketMessageEventArgs e)
{
if (!(e is SocketTextMessageEventArgs et))
{
this.Discord.Logger.LogCritical(VoiceNextEvents.VoiceGatewayError, "Discord Voice Gateway sent binary data - unable to process");
return(Task.CompletedTask);
}
this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceWsRx, et.Message);
return(this.HandleDispatch(JObject.Parse(et.Message)));
}
private async Task InternalSocketMessageReceived(GatewayConnection conn, SocketMessageEventArgs e)
{
if (e.Payload.Opcode == 10)
{
_heartbeatInterval = JObject.FromObject(e.Payload.Data).Value <int>("heartbeat_interval");
_logger.LogTrace(LogEvent.InternalMessageReceived, "heartbeat_interval = {}", _heartbeatInterval);
new Thread(new ThreadStart(HeartbeatLoop)).Start();
}
if (e.Payload.Opcode == 1)
{
_lastSeqNum = (int)e.Payload.Data;
await SendHeartbeat();
}
}
private void ListenForMessage()
{
using (var listener = CreateListener())
{
while (true)
{
var handler = listener.Accept();
FetchMessage(handler, message =>
{
var args = new SocketMessageEventArgs(message);
OnMessageReceived(args);
PushMessage(handler, args.RespondedMessage);
handler.Close();
});
}
}
}
private void OnListenerAccepted(IAsyncResult ar)
{
_resetEvent.Set();
var listener = ar.AsyncState as Socket;
if (listener == null)
{
return;
}
var handler = listener.EndAccept(ar);
BeginFetchMessage(handler, message =>
{
var args = new SocketMessageEventArgs(message);
OnMessageReceived(args);
BeginPushMessage(handler, args.RespondedMessage);
handler.Close();
});
}
private void ServerDataReceivedHandler(object sender, SocketMessageEventArgs e)
{
var msg = MyHelper.BinaryDeserializeObject <MessageConvention>(e.Buffer);
if (msg.MsgType == MessageType.OccupySeat)
{
_viewSeat.UserSitdownAction(msg.Seat.SeatNumber, msg.Seat.UserName);
}
else if (msg.MsgType == MessageType.QueryOccupiedSeats)
{
var os = msg.OccupiedSeats;
foreach (var item in os)
{
_viewSeat.UserSitdownAction(item.SeatNumber, item.UserName);
}
}
else if (msg.MsgType == MessageType.UserLeave)
{
_viewSeat.UserStandupAction(msg.Seat.SeatNumber, msg.Seat.UserName);
}
}
public async Task HandleClientCommand(object sender, SocketMessageEventArgs model)
{
var response = new ClientResponse();
try
{
switch (model.Message.ActionType)
{
case ClientMessageType.Ping:
response.Type = ClientResponseType.Pong;
break;
case ClientMessageType.GetLSCState:
response = new ClientResponse <LightStripStatus>()
{
Success = true,
Message = string.Empty,
Type = ClientResponseType.LSCData,
Data = new LightStripStatus()
{
Frame = _lighter.Frame,
BoundIp = _lighter.BoundIp,
BoundPort = _lighter.BoundPort,
NetworkInterfaces = NetworkAddresses.GetNetworkAddresses()
}
};
await SendResponse <LightStripStatus>(model.ClientId, response);
break;
}
}
catch (Exception ex)
{
_ = Task.Run(() => { _logger?.WriteLog(ex.ToString()); });
response.Success = false;
response.Message = "Exception";
response.Type = ClientResponseType.None;
await SendResponse(model.ClientId, response);
}
}
internal void OnMessage(object sender, SocketMessageEventArgs e)
{
_logger.LogTrace($"Received: {e.Data}");
var response = JsonConvert.DeserializeObject <Message>(e.Data, SerializationSettings.Default);
// We may get multiple responses for register_0 - we can safely ignore this one!
if (response.Id == "register_0" && response.Payload.Value <string>("pairingType") == "PROMPT")
{
return;
}
if (_completionSources.TryRemove(response.Id, out var taskCompletion))
{
if (response.Type == "error")
{
taskCompletion.TrySetException(new CommandException(response.Error));
}
else
{
taskCompletion.TrySetResult(response);
}
}
}
private void Server_MessageReceived(SocketClient socket, SocketMessageEventArgs args)
{
int socketindex = clients.IndexOf(socket);
foreach (var msg in args.Messages)
{
if (msg.MsgType == MessageType.Data)
{
switch ((lib.DataType)msg.DataMessage.Data[0])
{
case DataType.SetName:
byte tindex = msg.DataMessage.Data[1];
string name = Encoding.UTF8.GetString(msg.DataMessage.Data, 2, (int)msg.DataMessage.Length - 2);
map.SnakeNames[tindex] = name;
server.SendToAllAsync(msg.DataMessage.Data);
Dispatcher.BeginInvoke(new Action(() =>
{
}));
break;
case DataType.UseInventory:
byte toplayer = msg.DataMessage.Data[2];
MapType inventoryType = (MapType)msg.DataMessage.Data[1];
if (map.Snakes[socketindex].Inventory.ContainsKey(inventoryType))
{
map.Snakes[socketindex].Inventory[inventoryType]--;
socket.SendAsync(new byte[] { (byte)DataType.AddInventory, (byte)inventoryType, map.Snakes[socketindex].Inventory[inventoryType] }).Wait();
if (map.Snakes[socketindex].Inventory[inventoryType] == 0)
{
map.Snakes[socketindex].Inventory.Remove(inventoryType);
}
clients[toplayer].SendAsync(new byte[] { (byte)DataType.UseInventory, (byte)inventoryType, 1 }).Wait();
if (socketindex == toplayer)
{
server.SendToAllAsync(new ServerNotification()
{
Index = toplayer,
PlayerMessage = string.Format("你对自己使用了 {0}", fruitString[inventoryType]),
ElseMessage = string.Format("{0} 对 他自己 使用了 {1}", map.SnakeNames[toplayer], fruitString[inventoryType])
}, 1);
}
else
{
server.SendToAllAsync(new ServerNotification()
{
Index = toplayer,
PlayerMessage = string.Format("{0} 对 你 使用了 {1}", map.SnakeNames[socketindex], fruitString[inventoryType]),
ElseMessage = string.Format("{0} 对 {1} 使用了 {2}", map.SnakeNames[socketindex], map.SnakeNames[toplayer], fruitString[inventoryType])
}, 1);
}
switch (inventoryType)
{
case MapType.BlindFruit:
break;
case MapType.RushFruit:
map.ChangeSnakeSpeed(toplayer, 1);
break;
case MapType.SlowFruit:
map.ChangeSnakeSpeed(toplayer, -1);
break;
case MapType.HardFruit:
map.SetSnakeHard(toplayer);
break;
}
}
break;
case lib.DataType.PingTest:
socket.SendAsync(msg.DataMessage.Data).Wait();
break;
case lib.DataType.SnakeData:
break;
case lib.DataType.ChangeDirection:
short x = (short)(msg.DataMessage.Data[1] - 1);
short y = (short)(msg.DataMessage.Data[2] - 1);
map.Snakes[socketindex].Direction = new Coord(x, y);
break;
case lib.DataType.Prepared:
playerStatus[socketindex] = PlayerStatus.Prepared;
this.Dispatcher.BeginInvoke(new Action <int>((num) =>
{
(grid_Connection.Children[num * 3 + 1] as TextBlock).Text = "准备";
}), System.Windows.Threading.DispatcherPriority.Normal, socketindex).Wait();
byte[] buf = new byte[2] {
(byte)lib.DataType.PlayerStatus, (byte)map.SnakeCount
}
.Concat(from elem in playerStatus
select(byte) elem)
.ToArray();
server.SendToAllAsync(buf).Wait();
bool prepared = isGameStarted == false;
for (int i = 0; i < map.SnakeCount; i++)
{
prepared = prepared && playerStatus[i] == PlayerStatus.Prepared;
}
if (prepared == true)
{
this.Dispatcher.BeginInvoke(new Action(() =>
{
GameStart();
})).Wait();
}
break;
}
}
}
}
private async Task WebSocket_OnMessage(SocketMessageEventArgs e)
{
//this.Discord.DebugLogger.LogMessage(LogLevel.Debug, "Lavalink", e.Message, DateTime.Now);
var json = e.Message;
var jsonData = JObject.Parse(json);
ulong guildId = 0;
switch (jsonData["op"].ToString())
{
case "playerUpdate":
guildId = (ulong)jsonData["guildId"];
var state = jsonData["state"].ToObject <LavalinkState>();
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl))
{
await lvl.InternalUpdatePlayerStateAsync(state).ConfigureAwait(false);
}
break;
case "stats":
var statsRaw = jsonData.ToObject <LavalinkStats>();
this.Statistics.Update(statsRaw);
break;
case "event":
var evtype = jsonData["type"].ToObject <EventType>();
switch (evtype)
{
case EventType.TrackEndEvent:
guildId = (ulong)jsonData["guildId"];
TrackEndReason reason = TrackEndReason.Cleanup;
switch (jsonData["reason"].ToString())
{
case "FINISHED":
reason = TrackEndReason.Finished;
break;
case "LOAD_FAILED":
reason = TrackEndReason.LoadFailed;
break;
case "STOPPED":
reason = TrackEndReason.Stopped;
break;
case "REPLACED":
reason = TrackEndReason.Replaced;
break;
case "CLEANUP":
reason = TrackEndReason.Cleanup;
break;
}
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_evtf))
{
await lvl_evtf.InternalPlaybackFinishedAsync(new TrackFinishData { Track = jsonData["track"].ToString(), Reason = reason }).ConfigureAwait(false);
}
break;
case EventType.TrackStuckEvent:
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_evts))
{
await lvl_evts.InternalTrackStuckAsync(new TrackStuckData { Track = jsonData["track"].ToString(), Threshold = (long)jsonData["thresholdMs"] }).ConfigureAwait(false);
}
break;
case EventType.TrackExceptionEvent:
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_evte))
{
await lvl_evte.InternalTrackExceptionAsync(new TrackExceptionData { Track = jsonData["track"].ToString(), Error = jsonData["error"].ToString() }).ConfigureAwait(false);
}
break;
}
break;
}
}
private static void Sender_MessageReceived(object sender, SocketMessageEventArgs e)
{
Console.WriteLine($"Respond: {e.ReceivedMessage}");
}
private void Sender_MessageReceived(object sender, SocketMessageEventArgs e)
{
txtSub.Text = e.ReceivedMessage;
}
private static void Listener_MessageReceived(object sender, SocketMessageEventArgs e)
{
Console.WriteLine($"Message received: {e.ReceivedMessage}");
e.RespondedMessage = "OK";
AnnouceListening();
}
private Task VoiceWS_SocketMessage(SocketMessageEventArgs e) => this.HandleDispatch(JObject.Parse(e.Message));
private void OnReceivedMessage(SocketMessageEventArgs eventArgs) => this.ReceivedMessage?.Invoke(this, eventArgs);
private void Listener_MessageReceived(object sender, SocketMessageEventArgs e)
{
txtMain.Text = e.ReceivedMessage;
e.RespondedMessage = GetHash(e.ReceivedMessage);
}
public void OnSocketMessage(object source, SocketMessageEventArgs e)
{
using (Stream streamXml = new MemoryStream(e.raw))
{
XmlReader reader = XmlReader.Create(streamXml, settings);
try
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "mem":
ReadMemXml(reader.ReadSubtree());
break;
case "map":
ReadMapXml(reader.ReadSubtree());
break;
case "player":
ReadPlayerXml(reader.ReadSubtree());
break;
case "proc":
ReadProcXml(reader.ReadSubtree());
break;
case "winner":
ReadWinnerXml(reader.ReadSubtree());
break;
case "aff":
ReadAffXml(reader.ReadSubtree());
break;
case "live":
ReadLiveXml(reader.ReadSubtree());
break;
case "cycle":
ReadCycleXml(reader.ReadSubtree());
break;
case "end":
ReadEndXml(reader.ReadSubtree());
break;
case "dead":
ReadDeadXml(reader.ReadSubtree());
break;
default:
Logger.Log.WriteLine("unknow element {0}", e.message);
break;
}
}
}
catch (XmlException xe)
{
Logger.Log.WriteLine("{0}({1})", e.message, e.message.Substring(xe.LinePosition, e.message.Length - xe.LinePosition));
throw new Exception(xe.Message);
}
reader.Close();
}
}
private async Task WebSocket_OnMessage(SocketMessageEventArgs e)
{
if (!(e is SocketTextMessageEventArgs et))
{
this.Discord.DebugLogger.LogMessage(LogLevel.Critical, "Lavalink", "Lavalink spewed out binary gibberish!", DateTime.Now);
return;
}
var json = et.Message;
var jsonData = JObject.Parse(json);
switch (jsonData["op"].ToString())
{
case "playerUpdate":
var gid = (ulong)jsonData["guildId"];
var state = jsonData["state"].ToObject <LavalinkState>();
if (this.ConnectedGuilds.TryGetValue(gid, out var lvl))
{
await lvl.InternalUpdatePlayerStateAsync(state).ConfigureAwait(false);
}
break;
case "stats":
var statsRaw = jsonData.ToObject <LavalinkStats>();
this.Statistics.Update(statsRaw);
await this._statsReceived.InvokeAsync(new StatisticsReceivedEventArgs(this.Statistics)).ConfigureAwait(false);
break;
case "event":
var evtype = jsonData["type"].ToObject <EventType>();
var guildId = (ulong)jsonData["guildId"];
switch (evtype)
{
case EventType.TrackStartEvent:
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_evtst))
{
await lvl_evtst.InternalPlaybackStartedAsync(jsonData["track"].ToString()).ConfigureAwait(false);
}
break;
case EventType.TrackEndEvent:
TrackEndReason reason = TrackEndReason.Cleanup;
switch (jsonData["reason"].ToString())
{
case "FINISHED":
reason = TrackEndReason.Finished;
break;
case "LOAD_FAILED":
reason = TrackEndReason.LoadFailed;
break;
case "STOPPED":
reason = TrackEndReason.Stopped;
break;
case "REPLACED":
reason = TrackEndReason.Replaced;
break;
case "CLEANUP":
reason = TrackEndReason.Cleanup;
break;
}
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_evtf))
{
await lvl_evtf.InternalPlaybackFinishedAsync(new TrackFinishData { Track = jsonData["track"].ToString(), Reason = reason }).ConfigureAwait(false);
}
break;
case EventType.TrackStuckEvent:
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_evts))
{
await lvl_evts.InternalTrackStuckAsync(new TrackStuckData { Track = jsonData["track"].ToString(), Threshold = (long)jsonData["thresholdMs"] }).ConfigureAwait(false);
}
break;
case EventType.TrackExceptionEvent:
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_evte))
{
await lvl_evte.InternalTrackExceptionAsync(new TrackExceptionData { Track = jsonData["track"].ToString(), Error = jsonData["error"].ToString() }).ConfigureAwait(false);
}
break;
case EventType.WebSocketClosedEvent:
if (this.ConnectedGuilds.TryGetValue(guildId, out var lvl_ewsce))
{
var code = jsonData["code"].ToObject <int>();
if (code == 4006 || code == 4009 || code == 4014)
{
this.ConnectedGuilds.TryRemove(guildId, out _);
}
await lvl_ewsce.InternalWebSocketClosedAsync(new WebSocketCloseEventArgs(code, jsonData["reason"].ToString(), jsonData["byRemote"].ToObject <bool>())).ConfigureAwait(false);
}
break;
}
break;
}
}
private async Task WebSocket_OnMessage(IWebSocketClient client, SocketMessageEventArgs e)
{
if (!(e is SocketTextMessageEventArgs et))
{
this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, "Lavalink sent binary data - unable to process");
return;
}
this.Discord.Logger.LogTrace(LavalinkEvents.LavalinkWsRx, et.Message);
var json = et.Message;
var jsonData = JObject.Parse(json);
switch (jsonData["op"].ToString())
{
case "playerUpdate":
var gid = (ulong)jsonData["guildId"];
var state = jsonData["state"].ToObject <LavalinkState>();
if (this._connectedGuilds.TryGetValue(gid, out var lvl))
{
await lvl.InternalUpdatePlayerStateAsync(state).ConfigureAwait(false);
}
break;
case "stats":
var statsRaw = jsonData.ToObject <LavalinkStats>();
this.Statistics.Update(statsRaw);
await this._statsReceived.InvokeAsync(this, new StatisticsReceivedEventArgs(this.Statistics)).ConfigureAwait(false);
break;
case "event":
var evtype = jsonData["type"].ToObject <EventType>();
var guildId = (ulong)jsonData["guildId"];
switch (evtype)
{
case EventType.TrackStartEvent:
if (this._connectedGuilds.TryGetValue(guildId, out var lvl_evtst))
{
await lvl_evtst.InternalPlaybackStartedAsync(jsonData["track"].ToString()).ConfigureAwait(false);
}
break;
case EventType.TrackEndEvent:
TrackEndReason reason = TrackEndReason.Cleanup;
switch (jsonData["reason"].ToString())
{
case "FINISHED":
reason = TrackEndReason.Finished;
break;
case "LOAD_FAILED":
reason = TrackEndReason.LoadFailed;
break;
case "STOPPED":
reason = TrackEndReason.Stopped;
break;
case "REPLACED":
reason = TrackEndReason.Replaced;
break;
case "CLEANUP":
reason = TrackEndReason.Cleanup;
break;
}
if (this._connectedGuilds.TryGetValue(guildId, out var lvl_evtf))
{
await lvl_evtf.InternalPlaybackFinishedAsync(new TrackFinishData { Track = jsonData["track"].ToString(), Reason = reason }).ConfigureAwait(false);
}
break;
case EventType.TrackStuckEvent:
if (this._connectedGuilds.TryGetValue(guildId, out var lvl_evts))
{
await lvl_evts.InternalTrackStuckAsync(new TrackStuckData { Track = jsonData["track"].ToString(), Threshold = (long)jsonData["thresholdMs"] }).ConfigureAwait(false);
}
break;
case EventType.TrackExceptionEvent:
if (this._connectedGuilds.TryGetValue(guildId, out var lvl_evte))
{
await lvl_evte.InternalTrackExceptionAsync(new TrackExceptionData { Track = jsonData["track"].ToString(), Error = jsonData["error"].ToString() }).ConfigureAwait(false);
}
break;
case EventType.WebSocketClosedEvent:
if (this._connectedGuilds.TryGetValue(guildId, out var lvl_ewsce))
{
lvl_ewsce.VoiceWsDisconnectTcs.SetResult(true);
await lvl_ewsce.InternalWebSocketClosedAsync(new WebSocketCloseEventArgs(jsonData["code"].ToObject <int>(), jsonData["reason"].ToString(), jsonData["byRemote"].ToObject <bool>())).ConfigureAwait(false);
}
break;
}
break;
}
}
private async Task VoiceWS_SocketMessage(SocketMessageEventArgs e)
{
await this.HandleDispatch(JObject.Parse(e.Message));
}
/// <summary>
/// Method hooked to the SocketClients MessageReceived Event
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs">SocketMessageEventArgs contains the received json message</param>
private async void OnMessageReceived(object sender, SocketMessageEventArgs eventArgs)
{
await this.HandleGatewayPayload(eventArgs.Payload);
}
public async Task HandleClientCommand(object sender, SocketMessageEventArgs model)
{
var response = new ClientResponse();
try
{
switch (model.Message.ActionType)
{
case ClientMessageType.Ping:
response.Type = ClientResponseType.Pong;
break;
case ClientMessageType.StartReader:
await _core.StartScreenReading();
break;
case ClientMessageType.StopReader:
await _core.StopScreenReading();
break;
case ClientMessageType.GetSAState:
response = new ClientResponse <ScreenAmbienceStatus>()
{
Success = true,
Message = string.Empty,
Type = ClientResponseType.SAData,
Data = new ScreenAmbienceStatus()
{
IsStarted = _screen.IsRunning,
Frame = _screen.Frame,
AverageDeltaTime = _screen.AverageDt,
IsHueConnected = _hueCore.IsConnectedToBridge,
UsingHue = _config.Model.hueSettings.useHue,
UsingRgb = _config.Model.rgbDeviceSettings.useKeyboards || _config.Model.rgbDeviceSettings.useMice || _config.Model.rgbDeviceSettings.useMotherboard,
UsingLightStrip = _config.Model.lightStripSettings.useLightStrip,
ScreenInfo = new ScreenInfo()
{
Id = _screen.ScreenInfo.Source,
RealHeight = _screen.ScreenInfo.RealHeight,
RealWidth = _screen.ScreenInfo.RealWidth,
Height = _screen.ScreenInfo.Height,
Width = _screen.ScreenInfo.Width,
Rate = _screen.ScreenInfo.Rate
}
}
};
await SendResponse <ScreenAmbienceStatus>(model.ClientId, response);
break;
}
}
catch (Exception ex)
{
_ = Task.Run(() => { _logger?.WriteLog(ex.ToString()); });
response.Success = false;
response.Message = "Exception";
response.Type = ClientResponseType.None;
await SendResponse(model.ClientId, response);
}
}
