private void DiscoverThread()
{
while (IsStarted)
{
var devices = BluetoothAdapter.DiscoverDevices();
if (!IsStarted)
{
return;
}
//Remove lost devices.
foreach (var device in _discoveredServices.ToList())
{
if (!devices.Exists(x => x.Address == device.DiscoveryInfo.Address && x.Name == device.DiscoveryInfo.Name))
{
_discoveredServices.Remove(device);
ServiceLost?.Invoke(this, new ResonanceDiscoveredServiceEventArgs <ResonanceBluetoothDiscoveredDevice, BluetoothDevice>(device));
}
}
//Add new devices.
foreach (var device in devices)
{
if (!_discoveredServices.Exists(x => x.DiscoveryInfo.Address == device.Address && x.DiscoveryInfo.Name == device.Name))
{
var newDevice = new ResonanceBluetoothDiscoveredDevice(device);
_discoveredServices.Add(newDevice);
ServiceDiscovered?.Invoke(this, new ResonanceDiscoveredServiceEventArgs <ResonanceBluetoothDiscoveredDevice, BluetoothDevice>(newDevice));
}
}
}
}
/// <summary>
/// Called when a new service has been discovered.
/// </summary>
/// <param name="discoveryInfo">The discovery information.</param>
protected virtual void OnServiceRegistered(TReportedServiceInformation discoveryInfo)
{
if (!_discoveredServices.Exists(x => x.DiscoveryInfo.ServiceId == discoveryInfo.ServiceId))
{
_discoveredServices.Add(new ResonanceSignalRDiscoveredService <TReportedServiceInformation>(discoveryInfo));
ServiceDiscovered?.Invoke(this, new ResonanceDiscoveredServiceEventArgs <ResonanceSignalRDiscoveredService <TReportedServiceInformation>, TReportedServiceInformation>(new ResonanceSignalRDiscoveredService <TReportedServiceInformation>(discoveryInfo)));
}
}
private void Sd_ServiceDiscovered(object sender, DomainName serviceName)
{
logger.Info($"service '{serviceName}' discovered");
ServiceDiscovered?.Invoke(sender, new ServiceDiscoveredEventArgs()
{
ServiceName = serviceName.ToString()
});
if (serviceName.ToString().Contains(ServiceType))
{
mdns.SendQuery(serviceName, type: DnsType.PTR);
}
}
void OnAnswer(object sender, MessageEventArgs e)
{
var msg = e.Message;
// Any DNS-SD answers?
var sd = msg.Answers
.OfType <PTRRecord>()
.Where(r => r.Name == ServiceName);
foreach (var ptr in sd)
{
ServiceDiscovered?.Invoke(this, ptr.DomainName);
}
}
void OnAnswer(object sender, MessageEventArgs e)
{
var msg = e.Message;
if (log.IsDebugEnabled)
{
log.Debug($"Answer from {e.RemoteEndPoint}");
}
if (log.IsTraceEnabled)
{
log.Trace(msg);
}
// Any DNS-SD answers?
var sd = msg.Answers
.OfType <PTRRecord>()
.Where(ptr => ptr.Name.IsSubdomainOf(LocalDomain));
foreach (var ptr in sd)
{
if (ptr.Name == ServiceName)
{
ServiceDiscovered?.Invoke(this, ptr.DomainName);
}
else if (ptr.TTL == TimeSpan.Zero)
{
var args = new ServiceInstanceShutdownEventArgs
{
ServiceInstanceName = ptr.DomainName,
Message = msg
};
ServiceInstanceShutdown?.Invoke(this, args);
}
else
{
var args = new ServiceInstanceDiscoveryEventArgs
{
ServiceInstanceName = ptr.DomainName,
Message = msg
};
ServiceInstanceDiscovered?.Invoke(this, args);
}
}
}
void OnAnswer(object sender, MessageEventArgs e)
{
var msg = e.Message;
// Any DNS-SD answers?
var sd = msg.Answers.OfType <PTRRecord>();
foreach (var ptr in sd)
{
if (ptr.Name == ServiceName)
{
ServiceDiscovered?.Invoke(this, ptr.DomainName);
}
else
{
var args = new ServiceInstanceDiscoveryEventArgs
{
ServiceInstanceName = ptr.DomainName,
Message = msg
};
ServiceInstanceDiscovered?.Invoke(this, args);
}
}
}
public void BeginSearch(int sendInterval = 100)
{
EndSearch();
lock (searchSyncLock)
{
ahoyServiceInfoList.Clear();
shouldSearch = true;
searchComplete.Reset();
searchThread = new Thread(delegate()
{
Connection imuConnection = null;
string serialNumber;
SerialConnectionInfo serialConnectionInfo = new SerialConnectionInfo()
{
PortName = portName,
BaudRate = 115200,
RtsCtsEnabled = false,
};
try
{
do
{
//Thread.CurrentThread.Join(100);
try
{
imuConnection = new Connection(serialConnectionInfo);
imuConnection.Connect();
}
catch
{
imuConnection?.Dispose();
imuConnection = null;
}
}while (shouldSearch == true && imuConnection == null);
if (shouldSearch == false)
{
return;
}
do
{
//Thread.CurrentThread.Join(100);
//SerialConnectionInfo info;
//string serialNumber;
//if (TryConnection(portName, 115200, false, sendInterval, 1, out info, out serialNumber) == false)
//{
// continue;
//}
try
{
if (Commands.Send(imuConnection, Command.Ahoy, sendInterval, 1, out serialNumber) != CommunicationProcessResult.Success)
{
continue;
}
}
catch
{
continue;
}
AhoyServiceInfo serviceInfo = new AhoyServiceInfo(IPAddress.Any, IPAddress.Any, 0, 0, serialNumber, string.Empty, new object[] { serialConnectionInfo }, 0);
if (ahoyServiceInfoList.Contains(serviceInfo) == true)
{
continue;
}
ahoyServiceInfoList.Add(serviceInfo);
ServiceDiscovered?.Invoke(serviceInfo);
SerialDeviceDiscovered?.Invoke(serialNumber, serialConnectionInfo);
return;
}while (shouldSearch == true);
}
finally
{
imuConnection?.Dispose();
searchComplete.Set();
}
});
searchThread.Name = "Ahoy Scan Port " + portName;
searchThread.Start();
}
}
private void OnServiceDiscovered(AhoyServiceInfo serviceInfo)
{
ahoyServiceInfoList.Add(serviceInfo);
ServiceDiscovered?.Invoke(serviceInfo);
}
private void ReceiveThreadMethod()
{
while (IsStarted)
{
try
{
var clientEndPoint = new IPEndPoint(IPAddress.Any, Port);
var data = _udpClient.Receive(ref clientEndPoint);
Logger.LogDebug($"Data received ({data.ToFriendlyByteSize()}), decoding discovery information...");
TDiscoveryInfo discoveryInfo = Decoder.Decode <TDiscoveryInfo>(data);
Logger.LogDebug($"Discovery information decoded:\n{discoveryInfo.ToJsonString()}");
string address = clientEndPoint.Address.ToString();
Logger.LogDebug($"Service host address: {address}.");
ResonanceUdpDiscoveredService <TDiscoveryInfo> discoveredService = new ResonanceUdpDiscoveredService <TDiscoveryInfo>(discoveryInfo, address);
//validate service existence using TCP connection.
if (EnableTcpValidation)
{
Logger.LogDebug($"Validating service existence using TCP...");
try
{
TcpClient client = new TcpClient();
client.Connect(address, Port);
client.Dispose();
Logger.LogDebug("Service validated.");
}
catch
{
var missingService = _discoveredServices.ToList().FirstOrDefault(existingService => _discoveredServiceCompareFunc(existingService, discoveredService));
if (missingService != null)
{
Logger.LogDebug("Service TCP validation failed. Reporting service lost...");
_discoveredServices.Remove(missingService);
Logger.LogDebug($"Total discovered services: {_discoveredServices.Count}.");
ServiceLost?.Invoke(this, new ResonanceDiscoveredServiceEventArgs <ResonanceUdpDiscoveredService <TDiscoveryInfo>, TDiscoveryInfo>(missingService));
}
else
{
Logger.LogDebug("Service TCP validation failed.");
}
continue;
}
}
if (!_discoveredServices.ToList().Exists(existingService => _discoveredServiceCompareFunc(existingService, discoveredService)))
{
Logger.LogInformation("New service discovered on address {Address}. Reporting service discovered...", discoveredService.Address);
_discoveredServices.Add(discoveredService);
Logger.LogDebug($"Total discovered services: {_discoveredServices.Count}.");
ServiceDiscovered?.Invoke(this, new ResonanceDiscoveredServiceEventArgs <ResonanceUdpDiscoveredService <TDiscoveryInfo>, TDiscoveryInfo>(discoveredService));
}
else
{
Logger.LogDebug("Service was already discovered.");
}
}
catch (Exception ex)
{
if (ex.Message != "A blocking operation was interrupted by a call to WSACancelBlockingCall")
{
Logger.LogError(ex, "Error occurred on discovery method.");
}
}
}
}
