private void SendMove(float leftSpeed, float rightSpeed)
{
var leftSByte = Convert.ToSByte(leftSpeed);
var rightSByte = Convert.ToSByte(rightSpeed);
webSocket.Send(new[] { (byte)Operation.Move, (byte)leftSByte, (byte)rightSByte });
}
public void Send(ArraySegment <byte> payload)
{
if (websocket.ReadyState != WebSocketSharp.WebSocketState.Open)
{
throw new WebSocketException("Socket is not open");
}
try
{
if (payload.Offset > 0 || payload.Count < payload.Array.Length)
{
// STA Websockets cant take offsets nor buffer lenghts.
byte[] buf = new byte[payload.Count];
Buffer.BlockCopy(payload.Array, payload.Offset, buf, 0, payload.Count);
websocket.Send(buf);
}
else
{
websocket.Send(payload.Array);
}
}
catch (Exception e)
{
throw new WebSocketException("Unknown error while sending the message", e);
}
}
private void openswitch(x1 x)
{
lock (wss_lock)
{
String rtuid = rtu[x.HCD];
String cmd = "{\"ctp\":1,\"uid\":\"service\",\"utp\":1,\"rtu\": \"" + rtuid + "\",\"op\":\"4D\",\"value\":\"0101\",\"serial\":\"" + x.GUID + "\"}";
wss.Send(cmd);
Console.WriteLine(x.STM + "发送开启阀门命令...");
}
}
private void Initiliaze()
{
Console.WriteLine();
socket.Connect();
//socket.Send("42[\"SubAdd\",{\"subs\":[\"0~Cryptsy~BTC-USD\",\"0~Bitstamp~BTC~USD\",\"0~OKCoin~BTC~USD\",\"0~Coinbase~BTC~USD\",\"0~Poloniex~BTC~USD\",\"0~Cexio~BTC~USD\",\"0~BTCE~BTC~USD\",\"0~BitTrex~BTC~USD\",\"0~Kraken~BTC~USD\",\"0~Bitfinex~BTC~USD\",\"0~LocalBitcoins~BTC~USD\",\"0~itBit~BTC~USD\",\"0~HitBTC~BTC~USD\",\"0~Coinfloor~BTC~USD\",\"0~Huobi~BTC~USD\",\"0~LakeBTC~BTC~USD\",\"0~Coinsetter~BTC~USD\",\"0~CCEX~BTC~USD\",\"0~MonetaGo~BTC~USD\",\"0~Gatecoin~BTC~USD\",\"0~Gemini~BTC~USD\",\"0~CCEDK~BTC~USD\",\"0~Exmo~BTC~USD\",\"0~Yobit~BTC~USD\",\"0~BitBay~BTC~USD\",\"0~QuadrigaCX~BTC~USD\",\"0~BitSquare~BTC~USD\",\"0~TheRockTrading~BTC~USD\",\"0~Quoine~BTC~USD\",\"0~LiveCoin~BTC~USD\"]}]");
//socket.Send("42[\"SubAdd\",{\"subs\":[\"0~Cryptsy~BTC~USD\",\"0~Bitstamp~BTC~USD\",\"0~OKCoin~BTC~USD\",\"0~Coinbase~BTC~USD\",\"0~Poloniex~BTC~USD\",\"0~Cexio~BTC~USD\",\"0~BTCE~BTC~USD\",\"0~BitTrex~BTC~USD\",\"0~Kraken~BTC~USD\",\"0~Bitfinex~BTC~USD\",\"0~LocalBitcoins~BTC~USD\",\"0~itBit~BTC~USD\",\"0~HitBTC~BTC~USD\",\"0~Coinfloor~BTC~USD\",\"0~Huobi~BTC~USD\",\"0~LakeBTC~BTC~USD\",\"0~Coinsetter~BTC~USD\",\"0~CCEX~BTC~USD\",\"0~MonetaGo~BTC~USD\",\"0~Gatecoin~BTC~USD\",\"0~Gemini~BTC~USD\",\"0~CCEDK~BTC~USD\",\"0~Exmo~BTC~USD\",\"0~Yobit~BTC~USD\",\"0~BitBay~BTC~USD\",\"0~QuadrigaCX~BTC~USD\",\"0~BitSquare~BTC~USD\",\"0~TheRockTrading~BTC~USD\",\"0~Quoine~BTC~USD\",\"0~LiveCoin~BTC~USD\"]}]");
socket.Send("42[\"SubAdd\",{\"subs\":[\"2~Bitfinex~BTC~USD\",\"2~Coinbase~BTC~USD\",\"2~Kraken~BTC~USD\",\"2~Poloniex~BTC~USD\",\"2~Bittrex~BTC~USD\"" +
",\"2~Bitfinex~ETH~USD\",\"2~Coinbase~ETH~USD\",\"2~Kraken~ETH~USD\",\"2~Poloniex~ETH~USD\",\"2~Bittrex~ETH~USD\"" +
",\"2~Bitfinex~XRP~BTC\",\"2~Coinbase~XRP~BTC\",\"2~Kraken~XRP~BTC\",\"2~Poloniex~XRP~BTC\",\"2~Bittrex~XRP~BTC\"" +
",\"2~Bitfinex~REP~BTC\",\"2~Coinbase~REP~BTC\",\"2~Kraken~REP~BTC\",\"2~Poloniex~REP~BTC\",\"2~Bittrex~REP~BTC\"" +
",\"5~CCCAGG~BTC~USD\",\"5~CCCAGG~ETH~USD\",\"5~CCCAGG~XRP~BTC\",\"5~CCCAGG~REP~BTC\"" +
"]}]");
}
void FixedUpdate()
{
if (!ws.IsConnected)
{
Debug.Log("not connected:" + url);
return;
}
if (lastSendTime + cycleTimeStepSize <= Time.time)
{
lastSendTime = Time.time;
if (Time.time - episodeStartTime > episodeTimeLength)
{
TimeOver();
}
if (agent.state.endEpisode)
{
StartNewEpisode();
}
agent.UpdateState();
var packer = new MsgPack.CompiledPacker();
byte[] msg = packer.Pack(agent.state);
received.Reset();
ws.Send(msg);
received.WaitOne();
OnCycleUpdateAfterReceiveAction();
}
}
public static string StartWSSession(string url, string cmd)
{
string reply = null;
using (var ws = new WebSocketSharp.WebSocket(url))
{
int received = 0;
// Set the WebSocket events.
ws.OnOpen += (sender, e) =>
{
Response jsonmsg = new Response();
jsonmsg.Identifier = 2000;
jsonmsg.Message = cmd;
jsonmsg.Name = "PowershellWS";
string output = JsonConvert.SerializeObject(jsonmsg);
ws.Send(output);
};
ws.OnMessage += (sender, e) => {
Response response = JsonConvert.DeserializeObject<Response>(e.Data);
if (response.Identifier == 2000) {
Console.WriteLine(response.Message);
reply = response.Message;
received ++;
ws.Close();
}
};
ws.OnError += (sender, e) =>
Console.WriteLine(e.Message);
ws.OnClose += (sender, e) =>
Console.WriteLine(e.Reason);
// Connect to the server.
ws.Connect();
while (received < 1){Thread.Sleep(1);}
}
return reply;
}
private void connect()
{
if (wss != null)
{
wss.Close();
}
wss = new WebSocketSharp.WebSocket("ws://1.85.44.234:9612");
wss.WaitTime = new TimeSpan(0, 0, 8);
wss.OnMessage += (s, e1) => {
Console.WriteLine(e1.Data);
sockobj d = JsonConvert.DeserializeObject <sockobj>(e1.Data);
if (d.op == "4D")
{
update(d);
}
};
wss.OnOpen += (s, e1) => {
String a = "{ctp:\"0\",uid:\"" + user0 + "\",utp:\"1\",op:\"0\"}";
lock (wss_lock)
{
wss.Send(a);
}
Console.WriteLine(" websocket open!");
};
wss.OnClose += (s, e1) =>
{
Console.WriteLine("close!");
};
wss.OnError += (s, e1) =>
{
Console.WriteLine("error1");
};
wss.Connect();
}
private IEnumerator StartWebSocket()
{
yield return(StartCoroutine(Connect()));
processor.OnDebugMessage(this, "Connection established", false);
while (true)
{
lock (mOutQueue)
{
while (mOutQueue.Count > 0)
{
Debug.Log("asd");
ws.Send(Encoding.UTF8.GetBytes(mOutQueue.Dequeue()));
}
}
string reply = RecvString();
if (reply != null)
{
processor.OnMessage(this, reply);
}
if (wsError != null)
{
processor.OnDebugMessage(this, wsError, true);
break;
}
yield return(0);
}
ws.Close();
}
private void ExecuteInForeground()
{
WebSocketSharp.WebSocket ws = new WebSocketSharp.WebSocket(url);
Debug.Log("connecting... " + url);
ws.OnMessage += (sender, e) => MassageCallBack(e.RawData);
while (true)
{
ws.Connect();
while (!ws.IsConnected)
{
Thread.Sleep(1000);
}
while (ws.IsConnected)
{
byte[] data = PopAgentState();
if (data != null)
{
ws.Send(data);
}
//Thread.Sleep(0);
}
}
}
public void TestEchoSignalingServer()
{
// Modeling situtaion, when connected client send some message through the signaling mechanism
WebSocketSharp.WebSocket receiver = new WebSocketSharp.WebSocket(url_of_signaling, tokens_to_signaling);
receiver.Connect();
receiver.Send(Correct_Message);
// Time to receive result by Testing object
Thread.Sleep(450);
receiver.Close();
string TestResult = Tested_Object.LastReceivedMessage;
Tested_Object.Dispose();
//Console.WriteLine(TestResult);
//Console.WriteLine(Tested_Object.LastReceivedMessage);
//string TestResult2 = TestResult;
//TestResult2 += "aaa";
//Console.WriteLine(TestResult2);
//output: Hello world!!!aaa, but TestResult: Hello world!!!
// and string referece type, where here is problem? String class have value semantic.
Assert.AreEqual(Correct_Message, TestResult);
Assert.Pass();
}
private void MarketData()
{
decimal openPrice = 0;
decimal closePrice = 0;
decimal highPrice = 0;
decimal lowPrice = 0;
DateTime hourTimestamp = DateTime.UtcNow;
using (var ws = new WebSocketSharp.WebSocket("wss://www.bitmex.com/realtime"))
{
ws.OnMessage += (sender, e) =>
{
CryptoLib.Models.Bitmex.Model <CryptoLib.Models.Bitmex.Quote> incomingObject = JsonConvert.DeserializeObject <CryptoLib.Models.Bitmex.Model <CryptoLib.Models.Bitmex.Quote> >(e.Data);
PropertyInfo[] incomingProperties = incomingObject.data.FirstOrDefault().GetType().GetProperties();
if (incomingObject.data.FirstOrDefault().timestamp.Date > hourTimestamp.Date || incomingObject.data.FirstOrDefault().timestamp.Hour > hourTimestamp.Hour || incomingObject.data.FirstOrDefault().timestamp.Minute > hourTimestamp.Minute)
{
CryptoLib.MarketsEntities context = new CryptoLib.MarketsEntities();
CryptoLib.MarketData marketData = new CryptoLib.MarketData
{
InstrumentID = 1,
Timestamp = incomingObject.data.FirstOrDefault().timestamp,
OpenPrice = openPrice,
ClosePrice = closePrice,
HighPrice = highPrice,
LowPrice = lowPrice
};
if (marketData.OpenPrice != 0 && marketData.ClosePrice != 0 && marketData.HighPrice != 0 && marketData.LowPrice != 0)
{
context.MarketDatas.Add(marketData);
context.SaveChanges();
}
openPrice = 0;
closePrice = 0;
highPrice = 0;
lowPrice = 0;
hourTimestamp = incomingObject.data.FirstOrDefault().timestamp;
}
decimal incomingMidPrice = ((incomingObject.data.FirstOrDefault().askPrice + incomingObject.data.FirstOrDefault().bidPrice) / 2);
highPrice = Math.Max(incomingMidPrice, highPrice);
lowPrice = Math.Min(incomingMidPrice, lowPrice);
closePrice = incomingMidPrice;
if (openPrice == 0)
{
openPrice = incomingMidPrice;
}
if (lowPrice == 0)
{
lowPrice = incomingMidPrice;
}
};
ws.Connect();
ws.Send("{\"op\": \"subscribe\", \"args\": \"quote:XBTUSD\"}");
Console.ReadLine();
}
}
public static async Task Start(Session session, CancellationToken cancellationToken)
{
await Task.Delay(30000);//delay running 30s
System.Net.ServicePointManager.Expect100Continue = false;
cancellationToken.ThrowIfCancellationRequested();
var socketURL = session.LogicSettings.DataSharingDataUrl;
using (var ws = new WebSocketSharp.WebSocket(socketURL))
{
ws.Log.Level = WebSocketSharp.LogLevel.Error;
//ws.OnMessage += (sender, e) =>
// Console.WriteLine("New message from controller: " + e.Data);
while (true)
{
try
{
ws.Connect();
Logger.Write("Pokemon spawn point data service connection established.");
while (ws.ReadyState == WebSocketSharp.WebSocketState.Open)
{
lock (events)
{
while (events.Count > 0)
{
if (ws.ReadyState == WebSocketSharp.WebSocketState.Open)
{
var item = events.Dequeue();
var data = Serialize(item);
ws.Send($"42[\"pokemon\",{data}]");
}
}
}
await Task.Delay(POLLING_INTERVAL);
ws.Ping();
}
}
catch (IOException)
{
session.EventDispatcher.Send(new ErrorEvent
{
Message = "The connection to the data sharing location server was lost."
});
}
catch (Exception)
{
}
finally
{
//everytime disconnected with server bot wil reconnect after 15 sec
await Task.Delay(POLLING_INTERVAL, cancellationToken);
}
}
}
}
private T SendAndReciveObject <T>(CainiaoPrintDocumentRequest request, string printServerAdd) where T : CainiaoPrintDocumentResponse
{
WebSocketSharp.WebSocket webSocket = new WebSocketSharp.WebSocket(printServerAdd);
try
{
webSocket.OnMessage += WebSocket_OnMessage;
webSocket.OnOpen += WebSocket_OnOpen;
webSocket.OnError += WebSocket_OnError;
this.data = "";
this.error = "";
this.autoResetEvent.Reset();
//连接
webSocket.Connect();
if (autoResetEvent.WaitOne(5 * 1000) == false)
{
throw new Exception("等待回收数据超时:5秒");
}
if (string.IsNullOrWhiteSpace(this.error) == false || webSocket.ReadyState != WebSocketSharp.WsState.OPEN)
{
throw new Exception("连接打印组件错误，请检查菜鸟或者拼多多打印组件是否开启:" + this.error);
}
//发送数据
webSocket.Send(Newtonsoft.Json.JsonConvert.SerializeObject(request));
if (autoResetEvent.WaitOne(60 * 1000) == false)
{
throw new Exception("等待回收数据超时:60秒");
}
if (string.IsNullOrWhiteSpace(this.data))
{
throw new Exception("打印组件发送数据失败，没有返回数据：" + this.error);
}
var response = Newtonsoft.Json.JsonConvert.DeserializeObject <T>(this.data);
if (request.requestID != response.requestID)
{
throw new Exception("发送的请求：" + request.requestID + " 与返回的请求不匹配：" + response.requestID);
}
if (response.status.Equals("success", StringComparison.OrdinalIgnoreCase) == false)
{
throw new Exception("发送指令失败：" + response.msg);
}
return(response);
}
catch (AggregateException ae)
{
throw new Exception("连接打印组件错误，请打印是否开启", ae.InnerException);
}
finally
{
//关闭连接
if (webSocket != null && webSocket.IsAlive)
{
webSocket.Close();
}
}
}
public static void Initialize()
{
// Initialize our message handlers
_messageHandlers.Add("PRIVMSG", MessageHandlers.PRIVMSG);
_messageHandlers.Add("ROOMSTATE", MessageHandlers.ROOMSTATE);
_messageHandlers.Add("USERNOTICE", MessageHandlers.USERNOTICE);
_messageHandlers.Add("USERSTATE", MessageHandlers.USERSTATE);
_messageHandlers.Add("CLEARCHAT", MessageHandlers.CLEARCHAT);
_messageHandlers.Add("CLEARMSG", MessageHandlers.CLEARMSG);
_messageHandlers.Add("MODE", MessageHandlers.MODE);
_messageHandlers.Add("JOIN", MessageHandlers.JOIN);
// Create our websocket object and setup the callbacks
_ws = new WebSocketSharp.WebSocket("wss://irc-ws.chat.twitch.tv:443");
_ws.OnOpen += (sender, e) =>
{
Plugin.Log("Connected! Sending login info!");
_ws.Send("CAP REQ :twitch.tv/tags twitch.tv/commands twitch.tv/membership");
string username = Config.Instance.TwitchUsername;
if (username == String.Empty || Config.Instance.TwitchOAuthToken == String.Empty)
{
username = "******" + _rand.Next(10000, 1000000);
}
else
{
_ws.Send($"PASS {Config.Instance.TwitchOAuthToken}");
}
_ws.Send($"NICK {username}");
if (Config.Instance.TwitchChannelName != String.Empty)
{
_ws.Send($"JOIN #{Config.Instance.TwitchChannelName}");
}
// Display a message in the chat informing the user whether or not the connection to the channel was successful
ConnectionTime = DateTime.Now;
ChatHandler.Instance.displayStatusMessage = true;
Initialized = true;
};
_ws.OnMessage += Ws_OnMessage;
// Then start the connection
_ws.ConnectAsync();
}
public void Send(byte[] message)
{
if (m_socket == null || message == null)
{
return;
}
m_socket.Send(message);
}
public void Send(byte[] buffer)
{
#if UNITY_WEBGL && !UNITY_EDITOR
SocketSend(m_NativeRef, buffer, buffer.Length);
#else
m_Socket.Send(buffer);
#endif
}
private void Send(string message)
{
if (logMessages)
{
Debug.Log("Send: " + message);
}
ws.Send(message);
}
void sendOverMouseEvent(MouseEventMessage msg)
{
string jsonMsg = JsonConvert.SerializeObject(msg, Formatting.Indented);
if (isWSConnected)
{
wsClient.Send(jsonMsg);
}
}
public bool SendMessage(RTMMessageOut message)
{
try {
ws.Send(JsonConvert.SerializeObject(message));
ConsoleMessenger.PrintSuccess($@"Sent message: ""{message.text}"" to channel ""{message.channel}""");
return(true);
} catch (Exception) {
ConsoleMessenger.PrintError("Could not send message");
return(false);
}
}
private async Task SendMessage(string soketId, WebSocketSharp.WebSocket soket, string message)
{
if (!string.IsNullOrEmpty(soketId))
{
await SendMessageAsync(soketId, message);
return;
}
soket?.Send(message);
}
static void Main(string[] args)
{
DataTable painters = SQLiteConnector.get();
List <DbStringMsg> dbStringMsgs = createDbStringMsgList(painters);
using (var ws = new WebSocket("ws://localhost:8080/"))
{
ws.OnOpen += (sender, e) => Console.WriteLine("Connected to server.");
ws.OnMessage += (sender, e) =>
{
MsgType msgType = (MsgType)JsonDocument.Parse(e.Data).RootElement.GetProperty("type").GetInt32();
if (msgType == MsgType.SendKey)
{
string publicKey = JsonDocument.Parse(e.Data).RootElement.GetProperty("key").ToString();
Encryptor.publicKey = publicKey;
Console.WriteLine("Server send public key: " + publicKey);
foreach (var dbStringMsg in dbStringMsgs)
{
string msg = JsonSerializer.Serialize <DbStringMsg>(dbStringMsg);
DESDbStringMes decMsg = Encryptor.DESencrypt(msg);
decMsg.Key = Encryptor.RSAencrypt(decMsg.Key);
msg = JsonSerializer.Serialize <DESDbStringMes>(decMsg);
ws.Send(msg);
}
}
else
{
Console.WriteLine(e.Data);
}
};
ws.Connect();
string getKeyMsg = JsonSerializer.Serialize <GetKeyMsg>(new GetKeyMsg());
ws.Send(getKeyMsg);
Console.ReadKey(true);
ws.Close();
}
}
public void SendAsClient(Server server, IMessenger msgr, BaseTransportMessage msg)
{
var ctx = new WebSocketServerContext(server);
var l = server.ServerContext.L;
Task.Run(() =>
{
l.Log("Establishing connection to local socket server.");
using (var ws = new WebSocketSharp.WebSocket($"ws://{IPAddress.Loopback}:{ctx.Port}/"))
{
var settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects,
SerializationBinder = server.TypeBinder
};
var helper = new MessageTypedSender(C.M);
ws.OnMessage += (sender, args) =>
{
if (args.IsText)
{
var dataText = args.Data;
if (string.IsNullOrWhiteSpace(dataText))
{
return;
}
if (JsonConvert.DeserializeObject(dataText, settings) is BaseTransportMessage m)
{
helper.UnPackSendReceivedMessage(new ExternalMessage(m.SessionId, m));
}
}
else
{
throw new InvalidOperationException("Only text data is supported.");
}
};
ws.Connect();
var json = JsonConvert.SerializeObject(new HelloRequest(), settings);
ws.Send(json);
while (ws.IsAlive)
{
}
}
});
}
public Boolean healthCheck()
{
try
{
JObject jMessage = new JObject();
jMessage.Add("type", "health_check");
jMessage.Add("data", "hello");
ws.Send(jMessage.ToString());
return(true);
}
catch (Exception error)
{
Console.WriteLine(error);
return(false);
}
}
private static void Ws_OnMessage(object sender, WebSocketSharp.MessageEventArgs ev)
{
if (!ev.IsText)
{
return;
}
string rawMessage = ev.Data.TrimEnd();
if (rawMessage.StartsWith("PING"))
{
Plugin.Log("Ping... Pong.");
_ws.Send("PONG :tmi.twitch.tv");
}
var messageType = _twitchMessageRegex.Match(rawMessage);
if (messageType.Length == 0)
{
Plugin.Log($"Unhandled message: {rawMessage}");
return;
}
string channelName = messageType.Groups["ChannelName"].Value;
if (channelName != Config.Instance.TwitchChannelName)
{
return;
}
// Instantiate our twitch message
TwitchMessage twitchMsg = new TwitchMessage();
twitchMsg.rawMessage = rawMessage;
twitchMsg.message = _messageRegex.Match(twitchMsg.rawMessage).Groups["Message"].Value;
twitchMsg.hostString = messageType.Groups["HostName"].Value;
twitchMsg.messageType = messageType.Groups["MessageType"].Value;
twitchMsg.channelName = channelName;
// Find all the message tags
var tags = _tagRegex.Matches(rawMessage);
// Call the appropriate handler for this messageType
if (_messageHandlers.ContainsKey(twitchMsg.messageType))
{
_messageHandlers[twitchMsg.messageType]?.Invoke(twitchMsg, tags);
}
}
public static void Main(string[] args)
{
var creditentialsFromRest = Helper.GetCreditentialsFromRestAPI();
var jsonAuthToken = Helper.JsonfyWebAuthenticateUser(creditentialsFromRest.SessionToken);
using (var ws = new WebSocketSharp.WebSocket($"wss://wss.b2bx.exchange/WSGateway/?session_token={creditentialsFromRest.SessionToken}"))
{
ws.OnError += (sender, e) => Console.WriteLine("Incoming message: " + e.Exception + "||" + e.Message);
ws.OnMessage += (sender, e) => Console.WriteLine("Incoming message: " + e.Data);
//ws.OnOpen += (sender, e) => ws.Send();
ws.Connect();
ws.Send(jsonAuthToken);
}
Console.ReadKey(true);
}
public async Task Init(bool flag)
{
if (flag)
{
var symbolsData = await NetHelper.GetSymbolDetails();
if (!string.IsNullOrEmpty(symbolsData))
{
dynamic symbols = JsonConvert.DeserializeObject(symbolsData);
foreach (dynamic symbol in symbols)
{
var pair = $"t{Convert.ToString(symbol.pair).ToUpper()}";
if (!Global._tickerMinSizePairs.ContainsKey(pair))
{
continue;
}
Global._tickerMinSizePairs[pair] = Convert.ToDouble(symbol.minimum_order_size);
}
}
_wsList = new List <WebSocketSharp.WebSocket>();
string[] pairs = Global._tickerPricePairs.Keys.ToArray();
foreach (var pair in pairs)
{
dynamic payload = new System.Dynamic.ExpandoObject();
((IDictionary <string, object>)payload)["event"] = "subscribe";
((IDictionary <string, object>)payload)["channel"] = "ticker";
((IDictionary <string, object>)payload)["symbol"] = pair;
var _subscribeWS = new WebSocketSharp.WebSocket("wss://api-pub.bitfinex.com/ws/2");
_subscribeWS.OnMessage += (sender, e) => this.SubscribeFunc(pair, e.Data);
_subscribeWS.Connect();
_wsList.Add(_subscribeWS);
_subscribeWS.Send(JsonConvert.SerializeObject(payload));
}
}
else
{
foreach (var subscribeWS in _wsList)
{
subscribeWS.Close();
}
_wsList.Clear();
}
}
public static void SendWatchList(this WebSocketSharp.WebSocket ws)
{
List <string> itemsToWatch = new List <string>();
foreach (var item in Global.Configuration.Items)
{
itemsToWatch.Add(item.UrlName);
}
string itemString = string.Join(",", itemsToWatch);
var itemCompressed = Utils.CompressData(itemString);
if (ws.IsAlive)
{
ws.Send(itemCompressed);
}
}
static StackObject *Send_1(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Byte[] @data = (System.Byte[]) typeof(System.Byte[]).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
WebSocketSharp.WebSocket instance_of_this_method = (WebSocketSharp.WebSocket) typeof(WebSocketSharp.WebSocket).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
instance_of_this_method.Send(@data);
return(__ret);
}
private Task SendAsync(CancellationToken cancelToken)
{
var sendInterval = _config.WebSocketInterval;
return(Task.Run(async() =>
{
try
{
while (!cancelToken.IsCancellationRequested)
{
string json;
while (_sendQueue.TryDequeue(out json))
{
_webSocket.Send(json);
}
await Task.Delay(sendInterval, cancelToken).ConfigureAwait(false);
}
}
catch (OperationCanceledException) { }
}));
}
public void Reconnect()
{
if (_hasErrors)
{
return;
}
twitchChatCallbackHandler.Reconnect();
ws.Connect();
if (ws.ReadyState == WebSocketState.Open)
{
ws.Send("CAP REQ :twitch.tv/tags");
ws.Send("CAP REQ :twitch.tv/commands");
ws.Send("PASS " + configuration.OAuth);
ws.Send("NICK " + configuration.BotName);
ws.Send("JOIN #" + configuration.ChannelName);
}
else
{
Debug.Log("Connection NOT Ready.");
}
}
