public static int OnReceiveCallback(byte[] data, uint datalen, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
Debug(AppConstants.DebugColorCyan, ".............. Callback Received.");
try
{
string s = Encoding.UTF8.GetString(data, 0, data.Length);
PushBulletType messageType = new PushBulletType();
var jo = JObject.Parse(s);
messageType.type = (string)jo["type"];
messageType.subtype = (string)jo["subtype"];
Debug(AppConstants.DebugColorCyan, ">>>>>>>>>>>> type=", messageType.type);
Debug(AppConstants.DebugColorCyan, ">>>>>>>>>>>> subtype=", messageType.subtype);
if (messageType.type == "tickle")
{
if (messageType.subtype == "push")
{
GetPushInformation();
}
}
}
catch (Exception e)
{
Debug(AppConstants.DebugColorRed, ">>>>>>>>>>>> OnReceiveCallback failed=", e.ToString());
//ErrorLog.Exception("PushBulletSystem> OnReceiveCallback() Exception:", e);
return(-1);
}
return(0);
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <param name="length"></param>
/// <param name="opcode"></param>
/// <param name="err"></param>
int Websocket_ReceiveCallback(byte[] data, uint length, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode,
WebSocketClient.WEBSOCKET_RESULT_CODES err)
{
if (opcode == WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__TEXT_FRAME)
{
var rx = System.Text.Encoding.UTF8.GetString(data, 0, (int)length);
if (rx.Length > 0)
{
ParseStreamRx(rx);
}
WSClient.ReceiveAsync();
}
else if (opcode == WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__CLOSE)
{
Debug.Console(1, this, "Websocket disconnect received from remote");
CleanUpWebsocketClient();
}
else
{
Debug.Console(1, this, "websocket rx opcode/err {0}/{1}", opcode, err);
WSClient.ReceiveAsync();
}
return(0);
}
static int hbWebSocketClient_OnMessage(byte[] data, uint length, WebSocketClient.WEBSOCKET_PACKET_TYPES type, WebSocketClient.WEBSOCKET_RESULT_CODES result)
{
if (type == WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__CLOSE)
{
hbWebSocketClient_OnClose(WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_ERROR, null);
}
_hbWebSocketClient.ReceiveAsync();
var e = Encoding.Default.GetString(data, 0, data.Length);
var o = JObject.Parse(e);
string name = (string)o["payload"]["name"];
//determine who the device belongs to....
if (HBLightbulb.CheckIfDeviceExists(name) > 0)
{
HBLightbulb.ProcessWebsocketResponse(o);
}
else if (HBSwitch.CheckIfDeviceExists(name) > 0)
{
HBSwitch.ProcessWebsocketResponse(o);
}
else if (HBFan.CheckIfDeviceExists(name) > 0)
{
HBFan.ProcessWebsocketResponse(o);
}
else if (HBOutlet.CheckIfDeviceExists(name) > 0)
{
HBOutlet.ProcessWebsocketResponse(o);
}
else if (HBDoor.CheckIfDeviceExists(name) > 0)
{
HBDoor.ProcessWebsocketResponse(o);
}
else if (HBGarageDoor.CheckIfDeviceExists(name) > 0)
{
HBGarageDoor.ProcessWebsocketResponse(o);
}
else if (HBWindow.CheckIfDeviceExists(name) > 0)
{
HBWindow.ProcessWebsocketResponse(o);
}
else if (HBOccupancySensor.CheckIfDeviceExists(name) > 0)
{
HBOccupancySensor.ProcessWebsocketResponse(o);
}
else if (HBThermostat.CheckIfDeviceExists(name) > 0)
{
HBThermostat.ProcessWebsocketResponse(o);
}
else if (HBSecuritySystem.CheckIfDeviceExists(name) > 0)
{
HBSecuritySystem.ProcessWebsocketResponse(o);
}
return(0);
}
public static int ReceiveCallback(byte[] data, uint datalen, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
try
{
string s = Encoding.UTF8.GetString(data, 0, data.Length);
if (s.Contains("push"))
{
getPush();
}
}
catch (Exception e)
{
return(-1);
}
return(0);
}
public int ReceiveCallback(byte[] data, uint datalen, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
try
{
string receiveBuffer = Encoding.UTF8.GetString(data, 0, data.Length);
if (debug > 0)
{
CrestronConsole.Print("\n Websocket ReceiveCallback receiveBuffer: " + receiveBuffer);
}
if (receiveBuffer.Contains("webSocketClientKeepAlive"))
{
keepAliveMessageReceived = true;
sendDataAsync("webSocketClientKeepAlive");
}
else if (receiveBuffer.Contains("webSocketClientDisconnect"))
{
//Prepare keepAlive check routine to disconnect
//We can't just call disconnect here because ReceiveCallback must return a value before the socket can disconnect.
keepAliveMessageReceived = false;
keepAliveCounter = 2;
}
else
{
dataReceiveEvent(receiveBuffer);
}
resultCodes = wsc.ReceiveAsync();
if (debug > 0)
{
CrestronConsole.Print("\n Websocket ReceiveAsync resultCodes: " + resultCodes.ToString());
}
}
catch (Exception e)
{
if (debug > 0)
{
CrestronConsole.Print("\n Websocket ReceiveCallback exception: " + e.Message);
}
return(-1);
}
return(0);
}
public int ReceiveCallback(
byte[] data,
uint datalen,
WebSocketClient.WEBSOCKET_PACKET_TYPES opcode,
WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
try
{
if (opcode == WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__CLOSE)
{
// Pass "true" as callback to ensure the callback
// will report disconnected instead of success
_socket.DisconnectAsync(true);
return((int)error);
}
string dataReceived = Encoding.Default.GetString(data, 0, (int)datalen);
DataEventArgs <string> args = new DataEventArgs <string>(dataReceived);
DataReceived.Invoke(this, args);
Log(string.Format("RX: {0}", dataReceived));
// Handle reconnect
if (error != WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_ALREADY_CONNECTED ||
error != WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_PENDING ||
error != WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SUCCESS)
{
ConnectClient();
}
}
catch (Exception e)
{
if (EnableLogging)
{
Log(string.Format("WebSocketTransport : Receive Callback Exception: {0}", e.Message));
}
}
finally
{
_socket.ReceiveAsync();
}
return((int)error);
}
private int WebSocketDataReceived(byte[] bytesIn, uint length, WebSocketClient.WEBSOCKET_PACKET_TYPES packetType, WebSocketClient.WEBSOCKET_RESULT_CODES results)
{
try
{
string incomingStream = Encoding.UTF8.GetString(bytesIn, 0, bytesIn.Length);
PushBulletStream pushBulletSteamIn = JsonConvert.DeserializeObject <PushBulletStream>(incomingStream);
if (pushBulletSteamIn.subtype != null)
{
PushBulletGetMissedPushes(doorbellAccessToken, doorbellIden);
}
webSocketClient.ReceiveAsync();
}
catch (Exception e)
{
ErrorLog.Error("SocketDataReceived Error: {0}", e.Message);
return(-1);
}
return(0);
}
public int _ReceiveCallback(byte[] data, uint datalen, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
//CrestronConsole.PrintLine("ReceiveCallBack\r\n");
try
{
string s = Encoding.UTF8.GetString(data, 0, data.Length);
//CrestronConsole.Print("ReceiveCallback : " + s + "\n");
if (s.Contains("push"))
{
getPush();
}
//ErrorLog.Notice(s);
}
catch (Exception e)
{
return(-1);
}
return(0);
}
public int ReceiveCallback(byte[] data, uint datalen,
WebSocketClient.WEBSOCKET_PACKET_TYPES opcode,
WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
try
{
string data_rcv = Encoding.UTF8.GetString(data, 0, data.Length);
CrestronConsole.PrintLine("[WSClient.ReceiveCallback] data rcv: {0}", data_rcv);
if (data_rcv.Trim() != "")
{
JObject obj = JObject.Parse(data_rcv);
int msg_type = int.Parse(obj["msg_type"].ToString());
string dt = obj["dt"].ToString();
switch (msg_type)
{
case (int)CommonUtil.MSG_TYPE.MSG_PONG:
CrestronConsole.PrintLine("[WSClient.ReceiveCallback] rcv PONG");
ping_count = 0;
break;
case (int)CommonUtil.MSG_TYPE.MSG_LIGHT_SWITCH_ONOFF:
CrestronConsole.PrintLine("[WSClient.ReceiveCallback] rcv SWITCH ON/OFF");
switch_on_off(dt);
break;
case (int)CommonUtil.MSG_TYPE.MSG_LIGHT_CHANGE_BRIGHTNESS:
change_brightness(dt);
break;
default:
break;
}
}
}
catch (Exception ex) {
CrestronConsole.PrintLine("[WSClient.ReceiveCallback] exception : {0}", ex.ToString());
}
return(0);
}
private int receiveWebsocket(byte[] data, uint len, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES e)
{
string sdata = Encoding.ASCII.GetString(data, 0, (int)len);
try {
WSData msg = JsonConvert.DeserializeObject <WSData>(sdata);
if (msg.type != "nop")
{
debug("websocket receive: " + sdata);
}
if (msg.type == "tickle" && msg.subtype == "push")
{
checkPushes();
}
} catch (Exception) {
debug("unknown websocket data received");
}
wsCli.ReceiveAsync();
return(0);
}
private int ReceiveCallback(byte[] bytes, uint bytesLength, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
if (OnReceive != null)
{
try
{
RxBuffer = Encoding.ASCII.GetString(bytes, 0, (int)bytesLength);
OnReceive((short)opcode, (short)error);
}
catch (Exception ex)
{
CrestronConsole.PrintLine("Exception in ReceiveCallback: {0}", ex.Message);
}
}
if (error == WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SUCCESS)
{
wsc.ReceiveAsync();
}
return((int)error);
}
public int ReceiveCallback(byte[] data, uint datalen, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, /*JW MAC*/ WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
string sData = Encoding.ASCII.GetString(data, 0, data.Length);
try
{
socketDataType msg = JsonConvert.DeserializeObject <socketDataType>(sData);
CrestronConsole.PrintLine("Received data: " + sData.ToString());
if (msg.type == "nop")
{
WSSReceivedPush = false;
flag = false;
}
if (msg.type == "tickle")
{
WSSReceivedPush = true;
if (onReceivePush != null && flag == false)
{
onReceivePush(null, null);
flag = true;
}
else if (onReceivePush != null && flag == true)
{
flag = false;
}
}
}
catch (Exception e)
{
CrestronConsole.PrintLine("Unknown Data Received" + e.ToString());
Disconnect();
}
MyWSConnection.ReceiveAsync();
return(0);
}
public int ReceiveCallback(byte[] data, uint datalen, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES error)
{
string sData = Encoding.ASCII.GetString(data, 0, data.Length);
try
{
socketData msg = JsonConvert.DeserializeObject <socketData>(sData);
if (msg.type != "nop")
{
CrestronConsole.PrintLine("Received data:" + sData.ToString());
}
if (msg.type == "tickle" && msg.subtype == "push")
{
checkPushes();
}
}
catch (Exception e)
{
CrestronConsole.PrintLine("Unknown Data Received" + e.ToString());
DisconnectWebSocket();
}
wsc.ReceiveAsync();
return(0);
}
private int ClientReceiveCallBack(byte[] data, uint length, WebSocketClient.WEBSOCKET_PACKET_TYPES opCode, WebSocketClient.WEBSOCKET_RESULT_CODES resultCode)
{
try
{
if (opCode == WebSocketClient.WEBSOCKET_PACKET_TYPES.LWS_WS_OPCODE_07__CLOSE)
{
_client.DisconnectAsync(this);
return(0);
}
else if (resultCode == WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SUCCESS)
{
var sData = Encoding.ASCII.GetString(data, 0, data.Length);
ReceiveDataEventArgs e = new ReceiveDataEventArgs();
e.ID = ID;
e.Data = sData;
OnReceiveDataChange(e);
if (onDataReceived != null)
{
onDataReceived(sData);
}
return(1);
}
else if (resultCode == WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_INVALID_HANDLE)
{
_client.DisconnectAsync(this);
return(0);
}
else
{
return(0);
}
}
catch (SocketException se)
{
if (debugMode)
{
ErrorLog.Exception(string.Format("WebSocketCleint ID {0} SocketException Occured in ClientReceiveCallBack", ID), se);
}
return(0);
}
catch (Exception e)
{
if (debugMode)
{
ErrorLog.Exception(string.Format("WebSocketCleint ID {0} Exception Occured in ClientReceiveCallBack", ID), e);
}
return(0);
}
finally
{
if (_client.Connected)
{
_client.ReceiveAsync();
}
}
}
