public void Discover(Tech tech, Settlement.Settlement settlement)
{
settlement.AddMessage(new TechDiscoveredMessage(tech));
//Add all blueprints
tech.Blueprints.ForEach(blueprint => settlement.Blueprints.Add(blueprint));
Discovered.Add(tech);
}
public void Run()
{
thread = new Thread(() => {
try
{
var ep = new IPEndPoint(IPAddress.Any, Port);
var client = new UdpClient(ep);
while (true)
{
try
{
var r = client.Receive(ref ep);
var eventArgs = Parse(r);
// If the discovery packet is from a different app, then ignore it.
if (!string.Equals(eventArgs.App, App, StringComparison.OrdinalIgnoreCase))
{
continue;
}
Discovered?.Invoke(eventArgs);
}
catch (Exception e)
{
Log.Warn(TAG, $"Failed to handle udp message with error {e}");
}
}
}
catch (Exception e)
{
Log.Error(TAG, $"Failed to listen for udp on port {Port} with error {e}");
}
});
thread.Start();
}
private void ShowAdvertisementData(List <Advertisement> rows)
{
listView1.Items.Clear();
int code = 0;
Country combocountry = new Country();
combocountry = (Country)comboBox1.SelectedItem;
City combocity = new City();
combocity = (City)comboBox2.SelectedItem;
Category combocategory = new Category();
combocategory = (Category)comboBox3.SelectedItem;
SubCategory combosubCategory = new SubCategory();
combosubCategory = (SubCategory)comboBox4.SelectedItem;
Discovered combodiscovered = new Discovered();
combodiscovered = (Discovered)comboBox5.SelectedItem;
if (combocountry.NameCountry == "" && combocategory.NameCategory == "" && combodiscovered.Status == "")
{
code = 0;
viewer.ViewData(rows, code);
return;
}
if (combocountry.NameCountry != "" && combocategory.NameCategory != "" && combodiscovered.Status != "" && combocity.NameCity != "" && combosubCategory.NameSubcategory != "")
{
code = 1;
viewer.ViewData(rows, code);
return;
}
}
private void OnScanResponse(object sender, ScanResponseEventArgs e)
{
var type = (DiscoveryType)e.PacketType;
var mac = new MAC(e.Sender);
var macType = (MacType)e.AddressType;
var eventArgs = new DiscoveryEventArgs(type, mac, macType, e.Data, e.RSSI);
Discovered?.Invoke(this, eventArgs);
}
public void Start()
{
Task.Factory.StartNew(() =>
{
while (true)
{
var nodeInfo = _client.Receive <NodeInfo>();
var nodeInfoEntry = new NodeInfoEntry(nodeInfo);
Discovered.AddOrUpdate(nodeInfo.Id, nodeInfoEntry, (id, n) => nodeInfoEntry);
}
}, TaskCreationOptions.LongRunning);
}
public override void DiscoveredPeripheral(CBCentralManager central, CBPeripheral peripheral, NSDictionary advertisementData, NSNumber RSSI)
{
Console.WriteLine("Discovered {0}, data {1}, RSSI {2}", peripheral.Name, advertisementData, RSSI);
if (!string.IsNullOrEmpty(peripheral.Name))
{
Discovered?.Invoke(new RomeRemoteSystem(peripheral)
{
DisplayName = peripheral.Name,
Id = peripheral.Identifier.ToString()
});
}
}
internal void wrapper_NetworkPeerDiscovered(object sender, NetworkPeerChangedEventArgs e)
{
if (InvokeRequired)
{
Discovered d = new Discovered(wrapper_NetworkPeerDiscovered);
((MasterForm)d.Target).Invoke(d, new object[] { sender, e });
return;
}
Wrapper wrapper = (Wrapper)sender;
LOGGER.Info("NetworkPeerDiscovered, HostId: " + wrapper.NetworkManager.Localhost.Id + ", Count: " + e.NetworkPeers.Count);
TreeView tv = mTreeViewsById[wrapper.Id];
ICollection <NetworkContext> contexts = wrapper.KnownNetworkContexts;
int rootIndex = 0;
foreach (NetworkContext nc in contexts)
{
TreeNode rootNode = null;
if (tv.Nodes.Count <= rootIndex || !tv.Nodes[rootIndex].Text.Equals(nc.Name))
{
rootNode = new TreeNode(nc.Name);
tv.Nodes.Insert(rootIndex, rootNode);
mRootNodes[wrapper.Id].Add(nc.Name, rootNode);
}
else
{
rootNode = mRootNodes[wrapper.Id][nc.Name];
}
ICollection <INetworkPeerRemote> peers = nc.KnownNetworkPeers;
int i = 0;
foreach (INetworkPeerRemote peer in peers)
{
string peerId = peer.Id;
if (rootNode.Nodes.Count <= i || !rootNode.Nodes[i].Name.Equals(peerId))
{
TreeNode node = new TreeNode(string.Format("{0} ({1})", peerId, peer.Distance));
node.Tag = peer;
node.Name = peerId;
mPeerNodes[wrapper.Id].Add(peer.Id, node);
rootNode.Nodes.Insert(i, node);
SetNodeFont(node, peer);
}
i++;
}
rootIndex++;
}
}
public override void OnEvent(Payload e)
{
lock (m_Lock)
{
var Location = e.Pairs.FirstOrDefault(P => string.Equals(P.Type, "location", StringComparison.OrdinalIgnoreCase));
var MACAddress = e.Pairs.FirstOrDefault(P => string.Equals(P.Type, "SerialNumber", StringComparison.OrdinalIgnoreCase));
if (Location != null && MACAddress != null)
{
string IpAddress = Location.Value.Substring(7);
IpAddress = IpAddress.Substring(0, IpAddress.IndexOf(':'));
Discovered?.Invoke(null, new BBDeviceFound {
MAC = MACAddress.Value, IPAddress = IpAddress
});
}
}
}
public void Execute_BFS()
{
BFSQueue.Enqueue(sourceVertex);
Discovered.Add(sourceVertex.Id);
Parent.Add(sourceVertex.Id, -1);
while (BFSQueue.Count != 0)
{
var current = BFSQueue.Dequeue();
ProcessVertex_Early(current);
Processed.Add(current.Id);
foreach (var node in current.AdjacencyList)
{
if (!Processed.Contains(node.Id))
{
ProcessEdge(current, node);
}
if (!Discovered.Contains(node.Id))
{
Discovered.Add(node.Id);
BFSQueue.Enqueue(node);
if (!Parent.ContainsKey(node.Id))
{
Parent[node.Id] = current.Id;
}
else
{
Console.WriteLine("We shouldn't be here during BFS");
}
}
}
ProcessVertex_Late(current);
}
}
internal HashSet <int> GetSafeIsland(int click_x, int click_y)
{
HashSet <int> result = new HashSet <int>();
Queue <int> q = new Queue <int>();
bool[][] visited = new bool[Row][];
foreach (int i in Enumerable.Range(0, Row))
{
visited[i] = new bool[Col];
}
foreach (int i in Enumerable.Range(0, Row))
{
foreach (int j in Enumerable.Range(0, Col))
{
visited[i][j] = false;
}
}
visited[click_x][click_y] = true;
q.Enqueue(click_x * Col + click_y);
while (q.Count > 0)
{
int d = q.Dequeue();
result.Add(d);
Discovered.Add(d);
if (CountMines(d / Col, d % Col) > 0)
{
continue;
}
foreach (int neighbor in GetNeighbors(d / Col, d % Col))
{
if (!visited[neighbor / Col][neighbor % Col])
{
visited[neighbor / Col][neighbor % Col] = true;
q.Enqueue(neighbor);
}
}
}
return(result);
}
private async void OnBroadcast(CancellationTokenSource cancellationToken)
{
try
{
var parameter = new RemoteParameter()
{
Command = RemoteCommands.MiriotDiscovery
};
while (!cancellationToken.IsCancellationRequested)
{
var udpClient = new UdpClient();
var requestData = Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(parameter));
var serverEp = new IPEndPoint(IPAddress.Any, 0);
udpClient.EnableBroadcast = true;
udpClient.Send(requestData, requestData.Length, new IPEndPoint(IPAddress.Broadcast, _port));
var serverResponseData = udpClient.Receive(ref serverEp);
var serverResponse = Encoding.ASCII.GetString(serverResponseData);
var system = JsonConvert.DeserializeObject <RomeRemoteSystem>(serverResponse);
system.EndPoint = serverEp;
Debug.WriteLine("Received {0} from {1}", system.DisplayName, system.EndPoint.Address + ":" + system.EndPoint.Port);
Discovered?.Invoke(system);
udpClient.Close();
await Task.Delay(1000);
}
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
// Called by manager
private static bool RaiseDiscovered(BluetoothDeviceInfo bt, HIDDeviceInfo hid)
{
if (bt?.IsInvalid ?? true)
{
Debug.WriteLine($"{hid} Discovered");
}
else
{
Debug.WriteLine($"{bt} Discovered");
}
WiimoteDeviceInfo device;
//FIXME: Quick fix to support both Bluetooth and DolphinBar connections.
if (bt?.IsInvalid ?? true) // && DolphinBarMode)
{
device = new WiimoteDeviceInfo(hid, true);
}
else
{
device = new WiimoteDeviceInfo(bt, hid);
}
WiimoteDiscoveredEventArgs e = new WiimoteDiscoveredEventArgs(device);
Discovered?.Invoke(null, e);
if (e.AddDevice)
{
try {
Connect(e.Device);
}
catch (Exception ex) {
RaiseConnectionFailed(e.Device, ex);
return(true);
}
}
return(e.KeepSearching);
}
public void UdpListener_Received(byte[] data, IPEndPoint endPoint)
{
try
{
var dhcpData = new DhcpData(data)
{
RelatedServer = this
};
var msgType = dhcpData.GetCurrentMessageType();
var client = dhcpData.GetClientInfo();
switch (msgType)
{
case DhcpMessgeType.DHCP_DISCOVER:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPDISCOVER received."
});
Discovered?.Invoke(client);
var newIp = ownedIpAddressPool.Find(x => (x.AuthorizedClientMac == client.MacAddress) || (x.IsAllocated == false && x.AuthorizedClientMac == null));
if (newIp.Ip == null)
{
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "No ip is available to allocate."
});
return;
}
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPOFFER sent."
});
// MUST be unicast over raw socket (unimplemented)
// broadcast used
SendDhcpMessage(DhcpMessgeType.DHCP_OFFER, dhcpData, newIp);
break;
case DhcpMessgeType.DHCP_REQUEST:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPREQUEST received."
});
Requested?.Invoke(client);
switch (GetDhcpRequestType(client, endPoint))
{
// respond to client which has responded to DHCPOFFER message from this server
case DhcpRequestType.Selecting:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during SELECTING state."
});
if (_settings.ServerIp.Equals(client.ServerAddress))
{
var allocatedIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.RequestAddress));
if (allocatedIp.Ip != null && !allocatedIp.IsAllocated)
{
allocatedIp.IsAllocated = true;
allocatedIp.AuthorizedClientMac = client.MacAddress;
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
// broadcast
SendDhcpMessage(DhcpMessgeType.DHCP_ACK, dhcpData, allocatedIp);
}
}
break;
case DhcpRequestType.InitReboot:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during INIT-REBOOT state."
});
if (!client.RelayAgentAddress.Equals(IPAddress.Any))
{
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Relay agent is not supported in this version."
});
}
var rebootIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.RequestAddress));
if (rebootIp.Ip != null && rebootIp.AuthorizedClientMac == client.MacAddress)
{
// broadcast
SendDhcpMessage(DhcpMessgeType.DHCP_ACK, dhcpData, rebootIp);
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
}
break;
case DhcpRequestType.ReNewing:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during RENEWING state."
});
var reNewIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.ClientAddress));
if (reNewIp.Ip != null && reNewIp.AuthorizedClientMac == client.MacAddress)
{
// unicast
SendDhcpMessage(client.ClientAddress.ToString(), DhcpMessgeType.DHCP_ACK, dhcpData, reNewIp);
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
}
break;
case DhcpRequestType.ReBinding:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during REBINDING state."
});
var reBindIp = ownedIpAddressPool.Find(x => x.IsAllocated == false);
if (reBindIp.Ip != null)
{
reBindIp.IsAllocated = true;
reBindIp.AuthorizedClientMac = client.MacAddress;
// broadcast
SendDhcpMessage(DhcpMessgeType.DHCP_ACK, dhcpData, reBindIp);
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case DhcpMessgeType.DHCP_DECLINE:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPDECLINE received."
});
var declinedIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.ClientAddress));
if (declinedIp.Ip != null)
{
ownedIpAddressPool.Remove(declinedIp);
}
break;
case DhcpMessgeType.DHCP_RELEASE:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPRELESE received."
});
var releasedIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.ClientAddress));
if (releasedIp.Ip != null)
{
releasedIp.IsAllocated = false;
}
break;
case DhcpMessgeType.DHCP_INFORM:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPINFORM received."
});
// unicast
SendDhcpMessage(client.ClientAddress.ToString(), DhcpMessgeType.DHCP_ACK, dhcpData, null);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception e)
{
ErrorRaised?.Invoke(this, new ErrorMessageEventArgs {
Message = e.Message
});
Terminate();
throw e;
}
}
public List <Tech> GetAvailableTech(Settlement.Settlement settlement)
{
return(Tree.Technologies.Where(tech => !Discovered.Contains(tech) && tech.IsAvailable(settlement)).ToList());
}
private async void StartUnpairedDeviceWatcher()
{
// Request additional properties
string[] requestedProperties = new string[] { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
_deviceWatcher = DeviceInformation.CreateWatcher(BluetoothLEDevice.GetDeviceSelectorFromPairingState(false),
requestedProperties,
DeviceInformationKind.AssociationEndpoint);
// Hook up handlers for the watcher events before starting the watcher
_deviceWatcher.Added += new TypedEventHandler <DeviceWatcher, DeviceInformation>(async(watcher, deviceInfo) =>
{
// Make sure device name isn't blank
if (deviceInfo.Name != "")
{
try
{
var service = await GattDeviceService.FromIdAsync(deviceInfo.Id);
if (service != null)
{
}
}
catch (Exception)
{
}
//if (service != null)
//{
// var rfcommServices = await service?.GetRfcommServicesForIdAsync(
//RfcommServiceId.FromUuid(Constants.SERVICE_UUID), BluetoothCacheMode.Uncached);
// if (rfcommServices?.Services.Count > 0)
// {
//if (service.Uuid == Constants.SERVICE_UUID)
Discovered?.Invoke(new RomeRemoteSystem(deviceInfo)
{
Id = deviceInfo.Id,
DisplayName = deviceInfo.Name,
});
// }
//}
}
});
_deviceWatcher.Updated += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
var temp = _devices.ToList();
foreach (var device in temp)
{
if (device.Id == deviceInfoUpdate.Id)
{
(device.NativeObject as DeviceInformation).Update(deviceInfoUpdate);
var d = _devices.Single(df => df.Id == device.Id);
d = new RomeRemoteSystem(device);
Updated?.Invoke(d);
break;
}
}
});
_deviceWatcher.EnumerationCompleted += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
});
_deviceWatcher.Removed += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
Removed?.Invoke(deviceInfoUpdate.Id);
});
_deviceWatcher.Stopped += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
});
_deviceWatcher.Start();
}
protected void OnDiscovered(IAnalyzer analyzer, EventArgs args)
{
Discovered?.Invoke(analyzer, args);
}
