public Client()
{
InitLogging();
WaitUntilServerStarts();
var factory = new Func <ClientWebSocket>(() =>
{
var client = new ClientWebSocket
{
Options =
{
KeepAliveInterval = TimeSpan.FromSeconds(5000),
// Proxy = ...
// ClientCertificates = ...
}
};
//client.Options.SetRequestHeader("Origin", "xxx");
return(client);
});
webSocketClient = new WebsocketClient(serverUrl, factory)
{
Name = "First Client"
};
webSocketClient.DisconnectionHappened.Subscribe(info =>
Log.Warning($"Disconnection happened, type: {info.Type}"));
Log.Information("Starting...");
webSocketClient.Start().Wait();
Log.Information("Started.");
//var res = SendAsync("ping").Result;
//Log.Information($"Message received: {res}");
//ExitEvent.WaitOne();
}
public async Task ConnectAsync()
{
_client = new WebsocketClient(GetEndpoint(), wsFactory)
{
ReconnectTimeout = TimeSpan.FromSeconds(35),
ErrorReconnectTimeout = TimeSpan.FromSeconds(30)
};
_client.DisconnectionHappened.Subscribe(info =>
{
_logger.LogWarning(75421, $"Stream disconnected: {info.Type}: {info.Exception}");
if (_onDisconnected != null)
{
Task.Run(() => _onDisconnected(info));
}
});
_client.ReconnectionHappened.Subscribe(info =>
{
if (info.Type == ReconnectionType.Initial)
{
_logger.LogInformation("Starting initial census stream connect");
}
else
{
_logger.LogInformation($"Stream reconnection occured: {info.Type}");
}
if (_onConnect != null)
{
Task.Run(() => _onConnect(info.Type));
}
});
_client.MessageReceived.Subscribe(msg =>
{
if (_onMessage != null)
{
Task.Run(() => _onMessage(msg.Text));
}
});
await _client.Start();
}
public async Task ConnectAsync(CensusStreamSubscription subscription)
{
_client = new WebsocketClient(GetEndpoint(), wsFactory)
{
ReconnectTimeout = TimeSpan.FromSeconds(35),
ErrorReconnectTimeout = TimeSpan.FromSeconds(30)
};
_client.DisconnectionHappened.Subscribe(info =>
{
_logger.LogWarning(75421, $"Stream disconnected: {info.Type}: {info.Exception}");
if (_onDisconnected != null)
{
Task.Run(() => _onDisconnected(info));
}
});
_client.ReconnectionHappened.Subscribe(info =>
{
_logger.LogInformation($"Stream reconnection occured: {info.Type}");
if (subscription.EventNames.Any())
{
var sMessage = JsonConvert.SerializeObject(subscription, sendMessageSettings);
_client.Send(sMessage);
_logger.LogInformation($"Subscribed to census with: {sMessage}");
}
});
_client.MessageReceived.Subscribe(msg =>
{
if (_onMessage != null)
{
Task.Run(() => _onMessage(msg.Text));
}
});
await _client.Start();
}
public async Task <bool> Connect()
{
try
{
Client = new WebsocketClient(new Uri(Settings.Instance.PubSettings.Uri), WebSocketFactory)
{
Name = "PubSub",
ReconnectTimeout = TimeSpan.FromSeconds(5),
ErrorReconnectTimeout = TimeSpan.FromSeconds(5)
};
PubSubPingTimer = new Timer(new TimerCallback(SendingPing), Client, 0, 5000);
await Client.Start();
Subscribe();
return(true);
}
catch
{
return(false);
}
}
public async Task <IWebsocketClient> InitAsync()
{
if (_logger.IsInfo)
{
_logger.Info($"Starting ETH stats...");
}
var url = new Uri(_webSocketsUrl);
_client = new WebsocketClient(url)
{
ErrorReconnectTimeoutMs = _reconnectionInterval,
ReconnectTimeoutMs = int.MaxValue
};
_client.MessageReceived.Subscribe(async message =>
{
if (_logger.IsDebug)
{
_logger.Debug($"Received ETH stats message '{message}'");
}
if (string.IsNullOrWhiteSpace(message.Text))
{
return;
}
if (message.Text.Contains(ServerPingMessage))
{
await HandlePingAsync(message.Text);
}
});
await _client.Start();
if (_logger.IsDebug)
{
_logger.Debug($"Started ETH stats.");
}
return(_client);
}
/// <inheritdoc/>
public async Task StartAsync(CancellationToken cancellationToken)
{
_client = await _clientFactory.CreateClientAsync();
_client.Name = "deCONZ";
_client.ReconnectTimeout = TimeSpan.FromMinutes(5);
_client.ErrorReconnectTimeout = TimeSpan.FromSeconds(30);
_client.ReconnectionHappened.Subscribe(info =>
{
if (info.Type == ReconnectionType.Initial)
{
_logger.LogInformation($"Connecting to websocket: {_client.Url}");
}
else
{
_logger.LogInformation($"Reconnecting to websocket: {_client.Url} - cause: {info.Type}");
}
});
_client.DisconnectionHappened.Subscribe(info =>
{
_logger.LogWarning($"Websocket got disconnected - cause: {info.Type}");
});
_client.MessageReceived.Subscribe(async msg =>
{
_logger.LogInformation($"Message received: {msg}");
var message = JsonConvert.DeserializeObject <Message>(msg.Text);
// emit event so mqtt service will pick it up.
await _mediator.Publish(new DeConzMessageEvent(message), cancellationToken);
});
_logger.LogInformation("Starting websocket client...");
await _client.Start();
}
public async Task <IWebsocketClient> InitAsync()
{
if (_logger.IsInfo)
{
_logger.Info($"Starting ETH stats [{_webSocketsUrl}]...");
}
if (!_webSocketsUrl.StartsWith("wss"))
{
try
{
using HttpClient httpClient = new HttpClient();
string host = _webSocketsUrl.Split("://").Last();
HttpResponseMessage response = await httpClient.GetAsync($"http://{host}");
Uri requestedUrl = response.RequestMessage.RequestUri;
if (requestedUrl.Scheme.Equals("https"))
{
_webSocketsUrl = $"wss://{host}";
if (_logger.IsInfo)
{
_logger.Info($"Moved ETH stats to: {_webSocketsUrl}");
}
}
}
catch
{
// ignored
}
}
Uri url = new Uri(_webSocketsUrl);
_client = new WebsocketClient(url)
{
ErrorReconnectTimeout = TimeSpan.FromMilliseconds(_reconnectionInterval),
ReconnectTimeout = null
};
_client.MessageReceived.Subscribe(async message =>
{
if (_logger.IsDebug)
{
_logger.Debug($"Received ETH stats message '{message}'");
}
if (string.IsNullOrWhiteSpace(message.Text))
{
return;
}
if (message.Text.Contains(ServerPingMessage))
{
await HandlePingAsync(message.Text);
}
});
await _client.Start();
if (_logger.IsDebug)
{
_logger.Debug($"Started ETH stats.");
}
return(_client);
}
public async Task RunWebSocketAsync()
{
client.ReconnectTimeout = null;
client.ErrorReconnectTimeout = TimeSpan.FromSeconds(60);
client.MessageReceived.Subscribe(json =>
{
//Convert JSon to object
var obj = JsonConvert.DeserializeObject <RXRootObject>(json.ToString());
//Parse data into object
var payloadBytes = StringToByteArray(obj.data);
var sensorData = new SensorData();
if (obj.cmd == "rx")
{
var RoomEUI = _context.RoomEUI.FirstOrDefault(o => o.EUI == obj.EUI);
sensorData.RoomID = -1;
if (RoomEUI != null)
{
sensorData.RoomID = RoomEUI.RoomID;
}
/*
* hum 2 bytes
* temp 2 bytes
* co2 2 bytes
* IsOccupied 1 bytes
*/
sensorData.Humidity = BitConverter.ToUInt16(new[] { payloadBytes[0], payloadBytes[1] }, 0);
sensorData.Temperature = BitConverter.ToUInt16(new[] { payloadBytes[2], payloadBytes[3] }, 0);
sensorData.CO2 = BitConverter.ToUInt16(new[] { payloadBytes[4], payloadBytes[5] }, 0);
sensorData.IsOccupied = BitConverter.ToUInt16(new[] { (byte)0, payloadBytes[6] }, 0) == 1 ? true : false;
sensorData.AudioLevel = 0;
sensorData.Timestamp = DateTime.Now
_context.SensorData.Add(sensorData);
_context.SaveChangesAsync();
//Get triggers for the room
var triggers = _context.Trigger.Where(t => t.RoomID == sensorData.RoomID);
foreach (var trigger in triggers)
{
switch (trigger.Sensor)
{
case SensorType.Humidity:
if ((trigger.GreaterThan && sensorData.Humidity < trigger.Value) || (!trigger.GreaterThan && sensorData.Humidity > trigger.Value))
{
SendResponce(trigger.RoomID, obj.EUI, trigger.Command, obj.port);
}
break;
case SensorType.CO2:
if ((trigger.GreaterThan && sensorData.CO2 < trigger.Value) || (!trigger.GreaterThan && sensorData.CO2 > trigger.Value))
{
SendResponce(trigger.RoomID, obj.EUI, trigger.Command, obj.port);
}
break;
case SensorType.Temperature:
if ((trigger.GreaterThan && sensorData.Temperature < trigger.Value) || (!trigger.GreaterThan && sensorData.Temperature > trigger.Value))
{
SendResponce(trigger.RoomID, obj.EUI, trigger.Command, obj.port);
}
break;
case SensorType.Audio:
if ((trigger.GreaterThan && sensorData.AudioLevel < trigger.Value) || (!trigger.GreaterThan && sensorData.AudioLevel > trigger.Value))
{
SendResponce(trigger.RoomID, obj.EUI, trigger.Command, obj.port);
}
break;
case SensorType.IsOccupied:
if ((trigger.GreaterThan && sensorData.IsOccupied) || (!trigger.GreaterThan && !sensorData.IsOccupied))
{
SendResponce(trigger.RoomID, obj.EUI, trigger.Command, obj.port);
}
break;
default:
break;
}
}
}
});
client.Start().Wait();
Task.Run(() => StartSendingPing(client));
}
