public async void GetNetworks()
{
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (result.Count >= 1)
{
firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
await firstAdapter.ScanAsync();
deviceNetwork = firstAdapter.NetworkReport.AvailableNetworks.FirstOrDefault(N => N.Ssid == selectedDevice.GivenName);
var qualifyingWifi = firstAdapter.NetworkReport.AvailableNetworks.Where(N => !N.Ssid.ToLower().StartsWith("ioespt-thing"));
foreach (var network in qualifyingWifi)
{
networks.Add(network);
}
selectedNetwork = networks.FirstOrDefault();
}
}
private async void ScanButton_Click(object sender, RoutedEventArgs e)
{
await firstAdapter.ScanAsync();
ConnectionBar.Visibility = Visibility.Collapsed;
DisplayNetworkReport(firstAdapter.NetworkReport);
}
public static void Main()
{
try
{
// Get the first WiFI Adapter
WiFiAdapter wifi = WiFiAdapter.FindAllAdapters()[0];
// Set up the AvailableNetworksChanged event to pick up when scan has completed
wifi.AvailableNetworksChanged += Wifi_AvailableNetworksChanged;
// Loop forever scanning every 30 seconds
while (true)
{
Debug.WriteLine("starting WiFi scan");
wifi.ScanAsync();
Thread.Sleep(30000);
}
}
catch (Exception ex)
{
Debug.WriteLine("message:" + ex.Message);
Debug.WriteLine("stack:" + ex.StackTrace);
}
Thread.Sleep(Timeout.Infinite);
}
public static async Task <IEnumerable <WiFiNetworkInfo> > GetNetworksAsync(WiFiAdapter adapter)
{
List <WiFiNetworkInfo> wifiNetworks = new List <WiFiNetworkInfo>();
await adapter.ScanAsync();
foreach (var network in adapter.NetworkReport.AvailableNetworks)
{
wifiNetworks.Add(new WiFiNetworkInfo()
{
BSSID = network.Bssid,
SSID = network.Ssid,
ChannelCenterFrequencyInKilohertz = network.ChannelCenterFrequencyInKilohertz,
SignalBars = network.SignalBars,
IsWiFiDirect = network.IsWiFiDirect,
NetworkRssiInDecibelMilliwatts = network.NetworkRssiInDecibelMilliwatts,
PhyKind = network.PhyKind,
NetworkKind = network.NetworkKind,
AuthenticationType = network.SecuritySettings.NetworkAuthenticationType,
EncryptionType = network.SecuritySettings.NetworkEncryptionType,
BeaconInterval = network.BeaconInterval,
Uptime = network.Uptime
});
}
return(wifiNetworks);
}
public async void Scan()
{
var access = await WiFiAdapter.RequestAccessAsync();
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (result.Count >= 1)
{
nwAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
await nwAdapter.ScanAsync();
sp.Children.Clear();
foreach (var item in nwAdapter.NetworkReport.AvailableNetworks)
{
StackPanel s = new StackPanel();
s.Orientation = Orientation.Horizontal;
Button b = new Button();
TextBlock t = new TextBlock();
t.Text = $"{item.NetworkRssiInDecibelMilliwatts} {item.ChannelCenterFrequencyInKilohertz} {item.IsWiFiDirect} {item.NetworkKind} {item.SecuritySettings.NetworkAuthenticationType} {item.SecuritySettings.NetworkAuthenticationType} {item.SignalBars} {item.Uptime}";
b.Content += item.Ssid;
b.Click += B_Click;
s.Children.Add(b);
s.Children.Add(t);
sp.Children.Add(s);
}
}
}
/// <summary>
/// Return the SSIDs of the available network list.
/// </summary>
public async Task <List <string> > GetNetworkList()
{
List <string> m_networkList = new List <string>();
if (m_wiFiAdapter == null)
{
while (await Initialize() != 0)
{
}
return(await GetNetworkList());
}
else
{
await m_wiFiAdapter.ScanAsync();
if (m_wiFiAdapter.NetworkReport.AvailableNetworks.Count > 0)
{
foreach (WiFiAvailableNetwork network in m_wiFiAdapter.NetworkReport.AvailableNetworks.Distinct())
{
rootPage.Log(string.Format("NETWORK_MANAGER::GetNetworkList: AP {0} found.", network.Ssid));
m_networkList.Add(network.Ssid);
}
return(m_networkList.Distinct().ToList());
}
}
return(null);
}
public async void Scan()
{
var access = await WiFiAdapter.RequestAccessAsync();
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (result.Count >= 1)
{
nwAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
await nwAdapter.ScanAsync();
sp.Children.Clear();
foreach (var item in nwAdapter.NetworkReport.AvailableNetworks)
{
StackPanel s = new StackPanel();
s.Orientation = Orientation.Horizontal;
Button b = new Button();
TextBlock t = new TextBlock();
t.Text = $"{item.NetworkRssiInDecibelMilliwatts} {item.ChannelCenterFrequencyInKilohertz} {item.IsWiFiDirect} {item.NetworkKind} {item.SecuritySettings.NetworkAuthenticationType} {item.SecuritySettings.NetworkAuthenticationType} {item.SignalBars} {item.Uptime}";
b.Content += item.Ssid;
b.Click += B_Click;
s.Children.Add(b);
s.Children.Add(t);
sp.Children.Add(s);
}
}
}
private async void ScanForWiFiNetworksAsync()
{
if (m_selectedWiFiAdapterIndex >= 0)
{
m_wiFiAdapter = m_wiFiAdapterList[m_selectedWiFiAdapterIndex];
}
if (m_wiFiAdapter != null)
{
UpdateConnectivityStatusAsync();
NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged;
UpdateStatusAsync("Scanning for available WiFi networks...", NotifyType.StatusMessage);
await m_wiFiAdapter.ScanAsync();
m_onboarderNetworkList.Clear();
if (m_wiFiAdapter.NetworkReport.AvailableNetworks.Count > 0)
{
foreach (WiFiAvailableNetwork network in m_wiFiAdapter.NetworkReport.AvailableNetworks)
{
m_onboarderNetworkList.Add(network);
}
ConnectPanelVisibility = Visibility.Visible;
UpdateStatusAsync("Scan complete. Please select a network to connect.", NotifyType.StatusMessage);
}
else
{
UpdateStatusAsync("Scan complete. No WiFi networks found.", NotifyType.ErrorMessage);
}
}
}
public static NetworkConfig GetNetworkConfig()
{
var nis = NetworkInterface.GetAllNetworkInterfaces();
if (nis.Length <= 0)
{
return(new NetworkConfig(NetworkInterfaceType.Unknown, string.Empty, double.NaN, string.Empty,
string.Empty));
}
// get the first interface
var ni = nis[0];
if (ni.NetworkInterfaceType != NetworkInterfaceType.Wireless80211)
{
return(new NetworkConfig(ni.NetworkInterfaceType, string.Empty, double.NaN, ni.IPv4Address,
ni.IPv4GatewayAddress));
}
var wc = Wireless80211Configuration.GetAllWireless80211Configurations()[ni.SpecificConfigId];
_wifiAdapter.ScanAsync();
_autoResetEvent.WaitOne();
double rssi = double.NaN;
foreach (var networkReportAvailableNetwork in _wifiAdapter.NetworkReport.AvailableNetworks)
{
if (networkReportAvailableNetwork.Ssid == wc.Ssid)
{
rssi = networkReportAvailableNetwork.NetworkRssiInDecibelMilliwatts;
}
}
return(new NetworkConfig(ni.NetworkInterfaceType, wc.Ssid, rssi, ni.IPv4Address, ni.IPv4GatewayAddress));
}
private async Task <bool> _getNetworks()
{
WiFiAccessStatus access = await WiFiAdapter.RequestAccessAsync();
if (access != WiFiAccessStatus.Allowed)
{
_done = true;
return(false);
}
else
{
DeviceInformationCollection adapterResults = await DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (adapterResults.Count() >= 1)
{
_WiFiAdapter = await WiFiAdapter.FromIdAsync(adapterResults[0].Id);
}
else
{
_done = true;
return(false);
}
}
await _WiFiAdapter.ScanAsync();
foreach (WiFiAvailableNetwork availableNetwork in _WiFiAdapter.NetworkReport.AvailableNetworks)
{
_WiFiNetworks.Add(availableNetwork.Ssid);
}
return(true);
}
private async Task <bool> _connect(string ssid, string psk)
{
await _WiFiAdapter.ScanAsync();
WiFiAvailableNetwork _network = _WiFiAdapter.NetworkReport.AvailableNetworks.First(n => n.Ssid == ssid);
PasswordCredential credential = new PasswordCredential();
credential.Password = psk;
Task <WiFiConnectionResult> connected = _WiFiAdapter.ConnectAsync(_network, WiFiReconnectionKind.Manual, credential).AsTask();
WiFiConnectionResult result = null;
if (connected != null)
{
result = await connected;
}
if (result != null && result.ConnectionStatus == WiFiConnectionStatus.Success)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Retrieve SSID of connected wifi network
/// </summary>
/// <param name="wiFiAdapter"></param>
/// <returns>String - SSID</returns>
private static async Task <String> getConnectedWifi(WiFiAdapter wiFiAdapter)
{
await wiFiAdapter.ScanAsync();
ConnectionProfile connectedProfile = await wiFiAdapter.NetworkAdapter.GetConnectedProfileAsync();
return(connectedProfile.GetNetworkNames()[0]);
}
private static void Spp_ReceivedData(IBluetoothSpp sender, SppReceivedDataEventArgs ReadRequestEventArgs)
{
string message = ReadRequestEventArgs.DataString;
Debug.WriteLine($"Received=>{message}");
string[] args = message.Trim().Split(' ');
if (args.Length != 0)
{
switch (args[0].ToLower())
{
// Scan for wifi networks
case "scan":
InitWiFiScan();
sender.SendString("Scanning Networks\n");
wifi.ScanAsync();
break;
// Dummy set WiFi credentials
case "wifi":
if (args.Length != 3)
{
sender.SendString("Wrong number of arguments\n");
break;
}
sender.SendString("Set Wifi credentials\n");
// Save credentials Here
break;
// Send current ESP32 native memory
case "mem":
uint totalSize, totalFreeSize, largestBlock;
NativeMemory.GetMemoryInfo(NativeMemory.MemoryType.All, out totalSize, out totalFreeSize, out largestBlock);
sender.SendString($"Native memory - total:{totalSize} Free:{totalFreeSize} largest:{largestBlock}\n");
break;
// Reboot device
case "reboot":
sender.SendString("Rebooting now\n");
Thread.Sleep(100);
Power.RebootDevice();
break;
// Some help
case "help":
sender.SendString("Help\n");
sender.SendString("-------------------------------------------\n");
sender.SendString("'scan' - Scan WiFi networks\n");
sender.SendString("'mem' - Show native free memory\n");
sender.SendString("'reboot' - Reboot device\n");
sender.SendString("'wifi ssid password' - Set WiFI credentials\n");
sender.SendString("-------------------------------------------\n");
break;
}
}
}
public async Task ScanAsync()
{
if (_firstAdapter != null)
{
await _firstAdapter.ScanAsync();
DisplayNetworkReport(_firstAdapter.NetworkReport);
}
}
private async void Scan()
{
if (ActiveDevice)
{
await WifiDevice.ScanAsync();
}
else
{
return;
}
}
public static void Main()
{
Debug.WriteLine("Hello World :-)!");
try
{
int connectRetry = 0;
// Get the first WiFI Adapter
WiFiAdapter wifi = WiFiAdapter.FindAllAdapters()[0];
Debug.WriteLine("Getting wifi adaptor");
wifi.AvailableNetworksChanged += WifiAvailableNetworksChanged;
rescan:
wifi.ScanAsync();
Debug.WriteLine("Scanning...");
var timeout = DateTime.UtcNow.AddSeconds(10);
while (!_isConnected)
{
Thread.Sleep(100);
if (DateTime.UtcNow > timeout)
{
goto rescan;
}
}
NetworkHelpers.SetupAndConnectNetwork(false);
Debug.WriteLine("Waiting for network up and IP address...");
while (!NetworkHelpers.CheckIP())
{
Thread.Sleep(500);
connectRetry++;
if (connectRetry == 5)
{
connectRetry = 0;
goto rescan;
}
}
using (WebServer server = new WebServer(80, HttpProtocol.Http, new Type[] { typeof(ApiController) }))
{
server.Start();
Thread.Sleep(Timeout.Infinite);
}
}
catch (Exception ex)
{
Debug.WriteLine($"{ex}");
}
}
/// <summary>
/// Handles the <see cref="WiFiAdapter.AvailableNetworksChanged"/> event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The event arguments.</param>
private void WiFiAdapter_AvailableNetworksChanged(WiFiAdapter sender, object e)
{
Debug.WriteLine(string.Empty);
WiFiAvailableNetwork[] networks = sender.NetworkReport.AvailableNetworks;
Debug.WriteLine($"Network scan complete, found {networks.Length} networks");
foreach (var network in networks)
{
Debug.WriteLine(network.Ssid);
}
sender.ScanAsync();
}
public static void Main()
{
Debug.WriteLine("Hello from nanoFramework wifi!");
try
{
// Get the first WiFI Adapter
WiFiAdapter wifi = WiFiAdapter.FindAllAdapters()[0];
// Set up the AvailableNetworksChanged event to pick up when scan has completed
wifi.AvailableNetworksChanged += Wifi_AvailableNetworksChanged;
Debug.WriteLine("starting WiFi scan");
wifi.ScanAsync();
var remoteIp = IPAddress.Any;
var receivePort = 12345;
Debug.WriteLine("receive message");
using (var udpReceive = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
udpReceive.Bind(new IPEndPoint(remoteIp, receivePort));
var resBytes = new byte[1024];
while (true)
{
Debug.WriteLine("wait...");
var resSize = udpReceive.Receive(resBytes);
var receiveMsg = Encoding.UTF8.GetString(resBytes, 0, resSize);
Debug.WriteLine($"receiveData : {receiveMsg}");
if (receiveMsg == "exit")
{
break;
}
}
udpReceive.Close();
}
}
catch (Exception ex)
{
Debug.WriteLine("message:" + ex.Message);
Debug.WriteLine("stack:" + ex.StackTrace);
}
Thread.Sleep(Timeout.Infinite);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
try
{
await firstAdapter.ScanAsync();
}
catch (Exception err)
{
rootPage.NotifyUser(String.Format("Error scanning WiFi adapter: 0x{0:X}: {1}", err.HResult, err.Message), NotifyType.ErrorMessage);
return;
}
await DisplayNetworkReportAsync(firstAdapter.NetworkReport);
}
public async Task ScanNetworksAsync()
{
try
{
await _wifiAdapter.ScanAsync();
}
catch (Exception ex)
{
Status = WiFiSettingsStatus.Error;
Debug.WriteLine(ex.Message);
}
await InitializeNetworksAsync(_wifiAdapter.NetworkReport);
}
public async Task <WiFiAvailableNetwork> GetSpecificNetwork(WiFiAdapter adapter, string bssid, string ssid)
{
await adapter.ScanAsync();
foreach (var network in adapter.NetworkReport.AvailableNetworks)
{
if (network.Bssid.Equals(bssid) && network.Ssid.Equals(ssid))
{
return(network);
}
}
return(null);
}
private async void ScanButton_Click(object sender, RoutedEventArgs e)
{
await wifiAdapter.ScanAsync();
List <string> ls = new List <string>();
foreach (var network in wifiAdapter.NetworkReport.AvailableNetworks)
{
ls.Add(network.Ssid);
}
WiFiList.ItemsSource = ls;
connectpanel.Visibility = Visibility.Collapsed;
}
private async void Scan_Click(object sender, RoutedEventArgs e)
{
ScanButton.IsEnabled = false;
ScanButton.Content = "Scanning...";
networks.Clear();
await adapter.ScanAsync();
ScanButton.IsEnabled = true;
ScanButton.Content = "Scan networks";
foreach (var network in adapter.NetworkReport.AvailableNetworks)
{
networks.Add(new WiFiNetworkDisplay(network, adapter));
}
}
private async void OnRefreshRequested(object sender, RefreshRequestedEventArgs e)
{
if (!Allowed)
{
Toast.ShowError("不允许连接wifi，请确认已开启wifi，重新打开应用");
return;
}
await firstAdapter.ScanAsync();
LoadingVisibility = Visibility.Visible;
await DisplayNetworkReport(firstAdapter.NetworkReport);
e?.GetDeferral();
}
/// <summary>
/// Возвращает список доступных устройств
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <WiFiAvailableNetwork> > GetAvailableDevicesAsAPAsync()
{
bool initRes = await InitializeFirstAdapter();
if (initRes)
{
await _wifiAdapter.ScanAsync();
return(await Task <IEnumerable <WiFiAvailableNetwork> > .Factory.StartNew(() =>
{
return _wifiAdapter.NetworkReport.AvailableNetworks.Where(dev => dev.Ssid.IndexOf(Consts.ESP) != -1);
}));
}
return(new List <WiFiAvailableNetwork>());
}
public IAsyncOperation <OnboardingGetScanInfoResult> GetScanInfoAsync(AllJoynMessageInfo info)
{
return(Task.Run(async() =>
{
await _wlanAdapter.ScanAsync();
var availableNetworks = new List <OnboardingScanListItem>();
foreach (var network in _wlanAdapter.NetworkReport.AvailableNetworks)
{
var listItem = new OnboardingScanListItem {
Value1 = network.Ssid
};
switch (network.SecuritySettings.NetworkAuthenticationType)
{
case NetworkAuthenticationType.Open80211:
{
listItem.Value2 = (short)AuthType.Open;
break;
}
case NetworkAuthenticationType.Wpa:
{
listItem.Value2 = (short)AuthType.WPA_AUTO;
break;
}
default:
{
listItem.Value2 = (short)AuthType.Any;
break;
}
}
if (availableNetworks.Find(x => x.Value1 == listItem.Value1 && x.Value2 == listItem.Value2) == null)
{
availableNetworks.Add(listItem);
}
}
return OnboardingGetScanInfoResult.CreateSuccessResult(0, availableNetworks);
}).AsAsyncOperation());
}
public async Task GetAvailableNetWorksAsync()
{
try
{
if (adapter != null)
{
await adapter.ScanAsync();
}
}
catch (Exception err)
{
throw new WifiAdaperAccessDeniedException();
}
Networks = new List <WifiNetwork>();
foreach (var network in adapter.NetworkReport.AvailableNetworks)
{
Networks.Add(new WifiNetwork(network, adapter));
}
}
/// <summary>
/// This class initiates the GPIO pin output for relay control
/// <param name="gpio"> Parameter description for s goes here.</param>
/// </summary>
public async void Connack()
{
//raw.Text = hoe.ToString();
//hoe++;
if (!first)
{
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
first = true;
}
if (!connacking)
{
try
{
connacking = true;
try
{
await firstAdapter.ScanAsync();
}
catch { }
report = firstAdapter.NetworkReport;
foreach (var network in report.AvailableNetworks)
{
if (network.Bssid == "00:1e:2a:0c:6a:9a")
{
WiFiReconnectionKind reKind = WiFiReconnectionKind.Automatic;
PasswordCredential credential = new PasswordCredential();
credential.Password = "******";
WiFiConnectionResult results = await firstAdapter.ConnectAsync(
network, reKind, credential);
}
}
}
catch { }
connacking = false;
}
}
async void _watcher_Added(DeviceWatcher sender, DeviceInformation args)
{
WiFiAdapter device = await WiFiAdapter.FromIdAsync(args.Id);
if (device != null)
{
// add the device to the list (this will keep the object around
lock (this)
{
_deviceList.Add(device);
}
// register for changes
device.AvailableNetworksChanged += device_AvailableNetworksChanged;
// issue a scan
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
await device.ScanAsync().AsTask();
});
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
var access = await WiFiAdapter.RequestAccessAsync();
if (access == WiFiAccessStatus.Allowed)
{
DataContext = this;
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (result.Count >= 1)
{
wifiAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
}
}
await WiFiAdapter.FindAllAdaptersAsync();
while (true)
{
await wifiAdapter.ScanAsync();
await Task.Delay(5000);
List <string> ls = new List <string>();
List <string> sortedList = new List <string>();
foreach (var network in wifiAdapter.NetworkReport.AvailableNetworks)
{
var _dist = Math.Pow(10, 0.05 * (-20 * Math.Log10(network.ChannelCenterFrequencyInKilohertz / 1000) + 27.55 + Math.Abs(network.NetworkRssiInDecibelMilliwatts)));
ls.Add(Math.Round(_dist, 1) + "m " + " Name : " + network.Ssid + " , dB signal RSSID : " + network.NetworkRssiInDecibelMilliwatts);
}
sortedList = ls.OrderBy(s => double.Parse(s.Substring(0, s.IndexOf('m')))).ToList();
WiFiList.ItemsSource = sortedList;
//connectpanel.Visibility = Visibility.Collapsed;
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
PopupFailMessage.IsOpen = false;
try
{
var access = await WiFiAdapter.RequestAccessAsync();
if (access != WiFiAccessStatus.Allowed)
{
//rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage);
}
else
{
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (result.Count >= 1)
{
m_WifiAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
await m_WifiAdapter.ScanAsync();
DisplayNetworkReport(m_WifiAdapter.NetworkReport);
m_ScanButton.IsEnabled = true;
}
else
{
//rootPage.NotifyUser("No WiFi Adapters detected on this machine.", NotifyType.ErrorMessage);
}
}
}
catch (Exception ex)
{
PopupFailMessage.IsOpen = true;
//this.Frame.GoBack();
Message.Text = ex.ToString();
}
}
private async void BScan_Click(object sender, RoutedEventArgs e)
{
listBox1.Items.Clear();
areaNb++;
Areas.Add(areaNb, "area" + areaNb);
// RequestAccessAsync must have been called at least once by the app before using the API
// Calling it multiple times is fine but not necessary
// RequestAccessAsync must be called from the UI thread
var access = await WiFiAdapter.RequestAccessAsync();
if (access != WiFiAccessStatus.Allowed)
{
MesajFin.Text = "acces denied!";
}
else
{
MesajFin.Text = "acces allowed!";
if (wiFiAdapters == null)
{
wiFiAdapters = await WiFiAdapter.FindAllAdaptersAsync();
}
adapter = wiFiAdapters.First();
//ten scans to build the map
for (int cnt = 0; cnt < 10; cnt++)
{
await adapter.ScanAsync(); //scan
report = adapter.NetworkReport;
foreach (var network in report.AvailableNetworks)
{
// listBox1.Items.Add(network.Ssid + " " + network.NetworkRssiInDecibelMilliwatts + "dBm");
scanVals.Add(network.Ssid, network.NetworkRssiInDecibelMilliwatts.ToString());
}
}//end of ten scans
//next take the mean of the values obtained for each network
//and replace the stored values with only the mean
//we use an aux list to store the values for each network and to use Average() fct.
List<int> dbmValues; //aux list
foreach (String key in scanVals.AllKeys)
{
dbmValues = scanVals.GetValues(key).Select(int.Parse).ToList();
scanVals.Set(key, Math.Truncate(dbmValues.Average()).ToString());
// listBox1.Items.Add(key + " " + scanVals[key]);
}
AreaWifiMap = NvcToDictionary(scanVals); //convert to dictionary
scanVals.Clear();
WifiMap.Add(Areas[areaNb], AreaWifiMap); //add new entry for each scan *a dictionary of dicts
foreach (KeyValuePair<string, Dictionary<string, object>> kvp in WifiMap)
{
listBox1.Items.Add(kvp.Key + " >>>>> ");
foreach (KeyValuePair<string, object> kvp2 in kvp.Value)
{
listBox1.Items.Add(kvp2.Key + " " + kvp2.Value);
}
}
listBox1.Items.Add("::::::::::::::::::::::::::::::::::::::::");
// MesajFin.Text = String.Format("DSDSdss");
}
}
public async void GetNetworks()
{
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (result.Count >= 1)
{
firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
await firstAdapter.ScanAsync();
deviceNetwork = firstAdapter.NetworkReport.AvailableNetworks.FirstOrDefault(N => N.Ssid == selectedDevice.GivenName);
var qualifyingWifi = firstAdapter.NetworkReport.AvailableNetworks.Where(N => !N.Ssid.ToLower().StartsWith("ioespt-thing"));
foreach(var network in qualifyingWifi)
{
networks.Add(network);
}
selectedNetwork = networks.FirstOrDefault();
}
}