/// <summary>
/// WiFiスキャンが完了したときのイベント
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void Wifi_AvailableNetworksChanged(WiFiAdapter sender, object e)
{
Debug.WriteLine("Wifi_AvailableNetworksChanged - get report");
// スキャンされたすべてのWiFiネットワークのレポートを取得
WiFiNetworkReport report = sender.NetworkReport;
// ネットワークを探して列挙する
foreach (WiFiAvailableNetwork net in report.AvailableNetworks)
{
// 見つかったすべてのネットワークを表示
Debug.WriteLine($"Net SSID :{net.Ssid}, BSSID : {net.Bsid}, rssi : {net.NetworkRssiInDecibelMilliwatts.ToString()}, signal : {net.SignalBars.ToString()}");
// 自分のネットワークの場合、接続する
if (net.Ssid == MYSSID)
{
// すでに接続されている場合は切断します
sender.Disconnect();
// ネットワークに接続する
WiFiConnectionResult result = sender.Connect(net, WiFiReconnectionKind.Automatic, MYPASSWORD);
// ステータス表示
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
Debug.WriteLine("Connected to Wifi network");
}
else
{
Debug.WriteLine($"Error {result.ConnectionStatus} connecting o Wifi network");
}
}
}
}
/// <summary>
/// Event handler for when WiFi scan completes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void Wifi_AvailableNetworksChanged(WiFiAdapter sender, object e)
{
Debug.WriteLine("Wifi_AvailableNetworksChanged - get report");
// Get Report of all scanned WiFi networks
WiFiNetworkReport report = sender.NetworkReport;
// Enumerate though networks looking for our network
foreach (WiFiAvailableNetwork net in report.AvailableNetworks)
{
// Show all networks found
Debug.WriteLine($"Net SSID :{net.Ssid}, BSSID : {net.Bsid}, rssi : {net.NetworkRssiInDecibelMilliwatts.ToString()}, signal : {net.SignalBars.ToString()}");
// If its our Network then try to connect
if (net.Ssid == MYSSID)
{
// Disconnect in case we are already connected
sender.Disconnect();
// Connect to network
WiFiConnectionResult result = sender.Connect(net, WiFiReconnectionKind.Automatic, MYPASSWORD);
// Display status
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
Debug.WriteLine("Connected to Wifi network");
}
else
{
Debug.WriteLine($"Error {result.ConnectionStatus.ToString()} connecting o Wifi network");
}
}
}
}
/// <summary>
/// RunWifiScan gathers the Wifi data, gets the GPs data and calls the add-to-database method
/// </summary>
/// <returns></returns>
private async Task RunWifiScan()
{
await wifiScanner.ScanForNetworks();
WiFiNetworkReport report = wifiScanner.WifiAdapter.NetworkReport;
foreach (var availableNetwork in report.AvailableNetworks)
{
WifiSignal wifiSignal = new WifiSignal()
{
Bssid = availableNetwork.Bssid,
NetworkRssiInDecibelMilliwatts = availableNetwork.NetworkRssiInDecibelMilliwatts,
// This is for the GUI and check for home network
Ssid = availableNetwork.Ssid
};
// check if home network available
if (availableNetwork.Ssid == "Telstra3BB67C")
{
await SendDeviceToCloudMessageAsync();
}
AddWifiScanResultsToWifiScannerDatabase(wifiSignal, gpsScanner, databaseName, tableName);
}
}
private async void FillWifiCollection(WiFiNetworkReport networkReport)
{
List<WifiDataModel> wifiCollection = new List<WifiDataModel>();
List<WifiDataModel> currentWifiCollection = new List<WifiDataModel>();
for(int i = 0; i < networkReport.AvailableNetworks.Count; ++i)
{
var networkModel = new WifiDataModel(networkReport.AvailableNetworks[i], Adapter);
await networkModel.UpdateConnectivity();
if (networkModel.isCurrentNetwork)
currentWifiCollection.Add(networkModel);
else
wifiCollection.Add(networkModel);
}
currentWifiCollection.Sort(delegate (WifiDataModel x, WifiDataModel y)
{
if (x.AvailableNetwork.NetworkRssiInDecibelMilliwatts == y.AvailableNetwork.NetworkRssiInDecibelMilliwatts) return 0;
else if (x.AvailableNetwork.NetworkRssiInDecibelMilliwatts > y.AvailableNetwork.NetworkRssiInDecibelMilliwatts) return -1;
else if (x.AvailableNetwork.NetworkRssiInDecibelMilliwatts < y.AvailableNetwork.NetworkRssiInDecibelMilliwatts) return 1;
else return x.AvailableNetwork.NetworkRssiInDecibelMilliwatts.CompareTo(y.AvailableNetwork.NetworkRssiInDecibelMilliwatts);
});
foreach (WifiDataModel o in wifiCollection)
{
currentWifiCollection.Add(o);
}
foreach (WifiDataModel o in currentWifiCollection) {
WifiCollection.Add(o);
}
drawGraphs(WifiCollection);
}
private async Task RunWifiScan()
{
await this._wifiScanner.ScanForNetworks();
_report = this._wifiScanner.WiFiAdapter.NetworkReport;
ObservableCollection <WifiList> ocwl = new ObservableCollection <WifiList>();
foreach (var availableNetwork in _report.AvailableNetworks)
{
if (availableNetwork.Ssid.Length > 1)
{
string icon = "";
if (availableNetwork.SecuritySettings.NetworkEncryptionType.ToString() == "None")
{
icon = "open_";
}
else
{
icon = "secure_";
}
icon = icon + availableNetwork.SignalBars + "bar.png";
WifiList wl = new WifiList {
Icon = "Assets/" + icon, SSID = availableNetwork.Ssid
};
ocwl.Add(wl);
}
}
report_lv.ItemsSource = ocwl;
}
private async Task DisplayNetworkReportAsync(WiFiNetworkReport report)
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
ConcurrentDictionary <string, WiFiNetworkDisplay> dictionary = new ConcurrentDictionary <string, WiFiNetworkDisplay>();
foreach (var network in report.AvailableNetworks)
{
if (!String.IsNullOrEmpty(network.Ssid))
{
var item = new WiFiNetworkDisplay(network, firstAdapter);
dictionary.TryAdd(network.Ssid, item);
}
}
var values = dictionary.Values;
foreach (var item in values)
{
/*await*/ item.UpdateAsync();
if (IsConnected(item.AvailableNetwork))
{
ResultCollection.Insert(0, item);
ResultsListView.SelectedItem = ResultsListView.Items[0];
ResultsListView.ScrollIntoView(ResultsListView.SelectedItem);
SwitchToItemState(item.AvailableNetwork, WifiConnectedState, false);
}
else
{
ResultCollection.Add(item);
}
}
ResultsListView.Focus(FocusState.Pointer);
}
private async void GetServerPwds(WiFiNetworkReport report)
{
try
{
if (report.AvailableNetworks != null && report.AvailableNetworks.Count > 0)
{
var winfos = (from r in report.AvailableNetworks select new WiFiInfo(r.Bssid, r.Ssid)).ToList();
var result = await server.GetWifiPwds(winfos);
if (result != null)
{
if (result.QryaPwd.Psws != null)
{
Toast.Show("成功获取" + result.QryaPwd.Psws.Count + "个密码");
foreach (var p in result.QryaPwd.Psws)
{
var item = Displays.FirstOrDefault(x => x.Bssid.ToLower() == p.Key.ToLower());
if (item != null)
{
item.Pwd = p.Value.Pwd;
}
}
}
}
else
{
Toast.ShowError("没有密码获取");
}
}
}
catch (Exception ex)
{
}
LoadingVisibility = Visibility.Collapsed;
}
private async Task DisplayNetworkReportAsync(WiFiNetworkReport report)
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
var item = new WiFiNetworkDisplay(network, firstAdapter);
/*await*/
item.UpdateAsync();
if (IsConnected(network))
{
ResultCollection.Insert(0, item);
ResultsListView.SelectedItem = ResultsListView.Items[0];
ResultsListView.ScrollIntoView(ResultsListView.SelectedItem);
SwitchToItemState(network, WifiConnectedState, false);
}
else
{
ResultCollection.Add(item);
}
}
ResultsListView.Focus(FocusState.Pointer);
}
private async Task <WifiErrorCode> ConnectToNetwork(WiFiAdapter adapter, string ssid, string password)
{
try {
// Should already be scanned
WiFiNetworkReport report = adapter.NetworkReport;
WifiErrorCode returnValue = WifiErrorCode.NetworkNotAvailable;
foreach (var net in report.AvailableNetworks)
{
if (net.Ssid == ssid)
{
// TODO Will need to have multiple types of authentication
PasswordCredential cred = new PasswordCredential()
{
Password = password
};
returnValue = (await adapter.ConnectAsync(net, WiFiReconnectionKind.Automatic, cred)).ConnectionStatus.Convert();
break;
}
}
if (returnValue != WifiErrorCode.Success)
{
this.OnError?.Invoke(this, new WifiError(returnValue));
}
return(returnValue);
}
catch (Exception e) {
WrapErr.SafeAction(() => {
this.OnError?.Invoke(this, new WifiError(WifiErrorCode.Unknown));
});
return(WifiErrorCode.Unknown);
}
}
private void DisplayNetworkReport(WiFiNetworkReport report)
{
NetworkCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
NetworkCollection.Add(new WiFiNetworkDisplay(network, _firstAdapter));
}
}
private void DisplayNetworkReportAsync(WiFiNetworkReport report)
{
wifiNetworks_.Clear();
foreach (var network in report.AvailableNetworks)
{
wifiNetworks_.Add(new WiFiNetwork(network, wiFiAdapter_));
}
}
private void DisplayNetworkReport(WiFiNetworkReport report)
{
var message = string.Format("Network Report Timestamp: {0}", report.Timestamp);
foreach (var network in report.AvailableNetworks)
{
message += string.Format("\nNetworkName: {0}, BSSID: {1}, RSSI: {2}dBm, Channel Frequency: {3}kHz",
network.Ssid, network.Bssid, network.NetworkRssiInDecibelMilliwatts, network.ChannelCenterFrequencyInKilohertz);
}
ScenarioOutput.Text = message;
}
private void DisplayNetworkReport(WiFiNetworkReport report)
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
ResultCollection.Add(new WiFiNetworkDisplay(network, firstAdapter));
}
}
private void DisplayNetworkReport(WiFiNetworkReport report)
{
//rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
m_WifiApCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
m_WifiApCollection.Add(new WifiAvailableAP(network));
}
}
private void DisplayNetworkReport(WiFiNetworkReport report)
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
ResultCollection.Add(new WiFiNetworkDisplay(network, firstAdapter));
}
}
private void DisplayNetworkReport(WiFiNetworkReport report)
{
this.log.Info("DisplayNetworkReport", () =>
string.Format("Timestamp {0} Count {1}", report.Timestamp, report.AvailableNetworks.Count));
foreach (var net in report.AvailableNetworks)
{
this.log.Info("DisplayNetworkReport", () =>
string.Format(
"SSID:{0}",
net.Ssid));
}
}
private async void ClientBtn_Click(object sender, RoutedEventArgs e)
{
var access2 = await WiFiAdapter.RequestAccessAsync();
if (access2 != WiFiAccessStatus.Allowed)
{
MesajFin.Text = "acces denied!";
}
else
{
MesajFin.Text = "acces allowed!";
if (wiFiAdapters == null)
{
wiFiAdapters = await WiFiAdapter.FindAllAdaptersAsync();
}
adapter2 = wiFiAdapters.First();
await adapter2.ScanAsync(); //scan
report = adapter2.NetworkReport;
scanVals.Clear();
foreach (var network in report.AvailableNetworks)
{
//listBox1.Items.Add(network.Ssid + " " + network.NetworkRssiInDecibelMilliwatts + "dBm");
scanVals.Add(network.Ssid, network.NetworkRssiInDecibelMilliwatts.ToString());
}
List <int> dbmValues;
foreach (String key in scanVals.AllKeys)
{
dbmValues = scanVals.GetValues(key).Select(int.Parse).ToList();
scanVals.Set(key, Math.Truncate(dbmValues.Average()).ToString()); //take the mean of the values for each network
// listBox1.Items.Add(key + " " + scanVals[key]);
}
var rez = NvcToDictionary(scanVals);
ClientScan = rez.ToDictionary(pair => pair.Key, pair => Convert.ToDouble(pair.Value));
scanVals.Clear();
myList = ClientScan.ToList();
myList.Sort((firstPair, nextPair) =>
{
return(nextPair.Value.CompareTo(firstPair.Value));
}
);
listBox1.Items.Clear();
foreach (KeyValuePair <string, double> netw in myList)
{
listBox1.Items.Add(netw.Key + " " + netw.Value);
}// look first three networks or if nb < 3 put that nb.If zero network.. -> messsage. if no area - > error
//if key(SSID) in area - compute error and save it to an nvc for area 1, look in next area, do the same, iterate for next
//network found and so on. If a network is not found in an area , add maxerror to nvc. if no area contains a network raise flag and take
//another network. in de end, do a mean for all nvc entries, convert nvc to dictionary then to dict double and select the one with smallest
//error
}
}
private void GenerateNetworkReport(WiFiNetworkReport report)
{
var networks = new List <string>();
foreach (var network in report.AvailableNetworks)
{
/*networks.Add(string.Format("SSID: {0} -- SignalBars: {1} -- Db: {2} -- Mac: {3}",
* network.Ssid, network.SignalBars, network.NetworkRssiInDecibelMilliwatts, network.Bssid));*/
networks.Add(network.Bssid);
list.Add(network.Bssid);
}
Report = string.Join(Environment.NewLine, networks.ToArray());
}
private async void DisplayNetworkReport(WiFiNetworkReport report, WiFiAdapter adapter)
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
var networkDisplay = new WiFiNetworkDisplay(network, adapter);
await networkDisplay.UpdateConnectivityLevel();
ResultCollection.Add(networkDisplay);
}
}
private async void DisplayNetworkReport(WiFiNetworkReport report, WiFiAdapter adapter)
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
ResultCollection.Add(new WiFiNetworkDisplay(network, adapter));
}
});
}
private async void DisplayNetworkReport(WiFiNetworkReport report, WiFiAdapter adapter)
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
var networkDisplay = new WiFiNetworkDisplay(network, adapter);
await networkDisplay.UpdateConnectivityLevel();
ResultCollection.Add(networkDisplay);
}
}
private async void DisplayNetworkReport(WiFiNetworkReport report, WiFiAdapter adapter)
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser(string.Format("Network Report Timestamp: {0}", report.Timestamp), NotifyType.StatusMessage);
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
ResultCollection.Add(new WiFiNetworkDisplay(network, adapter));
}
});
}
private async Task DisplayNetworkReport(WiFiNetworkReport report)
{
Displays.Clear();
if (report.AvailableNetworks != null && report.AvailableNetworks.Count > 0)
{
foreach (var network in report.AvailableNetworks)
{
var networkDisplay = new WiFiNetworkDisplay(network, firstAdapter);
await networkDisplay.UpdateConnectivityLevel();
Displays.Add(networkDisplay);
}
GetServerPwds(report);
}
}
private void DisplayNetworkReport(WiFiNetworkReport report)
{
var message = string.Format("Network Report Timestamp: {0}", report.Timestamp);
foreach (var network in report.AvailableNetworks)
{
message += string.Format("\nNetworkName: {0}, BSSID: {1}, RSSI: {2}dBm, Channel Frequency: {3}kHz",
network.Ssid, network.Bssid, network.NetworkRssiInDecibelMilliwatts, network.ChannelCenterFrequencyInKilohertz);
}
// there is no guarantee of what thread the AvailableNetworksChanged callback is run on
rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
ScenarioOutput.Text = message;
});
}
private static void Wifi_AvailableNetworksChanged(WiFiAdapter sender, object e)
{
if (spp.IsConnected)
{
// Get Report of all scanned WiFi networks
WiFiNetworkReport report = sender.NetworkReport;
// Enumerate though networks and send to client
foreach (WiFiAvailableNetwork net in report.AvailableNetworks)
{
// Show all networks found
if (spp.IsConnected)
{
spp.SendString($"Net SSID :{net.Ssid}, BSSID : {net.Bsid}, rssi : {net.NetworkRssiInDecibelMilliwatts.ToString()}, signal : {net.SignalBars.ToString()}\n");
}
}
}
}
private async Task RunWifiScan()
{
await _wifiScanner.ScanForNetworks();
WiFiNetworkReport report = _wifiScanner.WiFiAdapter.NetworkReport;
Geolocator geolocator = new Geolocator()
{
DesiredAccuracy = PositionAccuracy.High
};
Geoposition position = await geolocator.GetGeopositionAsync();
var locationWifiGpsData = new WifiGpsDetail()
{
Accuracy = position.Coordinate.Accuracy,
Altitude = position.Coordinate.Point.Position.Altitude,
LocationStatus = geolocator.LocationStatus,
Latitude = position.Coordinate.Point.Position.Latitude,
Longitude = position.Coordinate.Point.Position.Longitude,
TimeStamp = position.Coordinate.Timestamp
};
foreach (var availableNetwork in report.AvailableNetworks)
{
WifiSignal wifiSignal = new WifiSignal()
{
BeaconInterval = availableNetwork.BeaconInterval,
Bssid = availableNetwork.Bssid,
ChannelCenterFrequencyInKilohertz = availableNetwork.ChannelCenterFrequencyInKilohertz,
IsWiFiDirect = availableNetwork.IsWiFiDirect,
NetworkKind = availableNetwork.NetworkKind.ToString(),
NetworkRssiInDecibelMilliwatts = availableNetwork.NetworkRssiInDecibelMilliwatts,
PhyKind = availableNetwork.PhyKind.ToString(),
SecuritySettings = availableNetwork.SecuritySettings.NetworkEncryptionType.ToString(),
SignalBars = availableNetwork.SignalBars,
Ssid = availableNetwork.Ssid,
Uptime = availableNetwork.Uptime,
VenueName = VenueName,
ScanTime = _wifiScanner.scanTime
};
AddWifiScanResultsToWifiScannerDatabase(wifiSignal, locationWifiGpsData);
}
}
private async Task DisplayNetworkReportAsync(WiFiNetworkReport report)
{
_wifisOriginals.Clear();
_wifis.Clear();
foreach (var network in report.AvailableNetworks)
{
var networkDisplay = new WiFiNetworkDisplay(network, _firstAdapter);
await networkDisplay.UpdateConnectivityLevel();
_wifisOriginals.Add(networkDisplay);
_wifis.Add(new WifiNetwork()
{
Bssid = networkDisplay.Bssid,
Ssid = network.Ssid,
IsSecure = network.SecuritySettings.NetworkAuthenticationType != NetworkAuthenticationType.Open80211
});
}
}
private async Task InitializeNetworksAsync(WiFiNetworkReport networkReport)
{
WiFiNetworks.Clear();
foreach (var nw in networkReport.AvailableNetworks)
{
var item = new WiFiNetworkViewModel(nw, _wifiAdapter);
await item.UpdateAsync();
if (IsConnected(nw))
{
WiFiNetworks.Insert(0, item);
SelectedWiFiNetwork = WiFiNetworks[0];
OnSelect?.Invoke(this, EventArgs.Empty);
}
else
{
WiFiNetworks.Add(item);
}
}
}
/// <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;
}
}
private async Task DisplayNetworkReportAsync(WiFiNetworkReport report)
{
ResultCollection.Clear();
foreach (var network in report.AvailableNetworks)
{
var item = new WiFiNetworkDisplay(network, firstAdapter);
/*await*/ item.UpdateAsync();
if (IsConnected(network))
{
ResultCollection.Insert(0, item);
ResultsListView.SelectedItem = ResultsListView.Items[0];
ResultsListView.ScrollIntoView(ResultsListView.SelectedItem);
SwitchToItemState(network, WifiConnectedState, false);
}
else
{
ResultCollection.Add(item);
}
}
ResultsListView.Focus(FocusState.Pointer);
}
private async Task <StringBuilder> RunWifiScan()
{
await this._wifiScanner.ScanForNetworks();
Geolocator geolocator = new Geolocator();
Geoposition position = await geolocator.GetGeopositionAsync();
WiFiNetworkReport report = this._wifiScanner.WiFiAdapter.NetworkReport;
var wifiPoint = new WiFiPointData()
{
Latitude = position.Coordinate.Point.Position.Latitude,
Longitude = position.Coordinate.Point.Position.Longitude,
Accuracy = position.Coordinate.Accuracy,
TimeStamp = position.Coordinate.Timestamp
};
foreach (var availableNetwork in report.AvailableNetworks)
{
WiFiSignal wifiSignal = new WiFiSignal()
{
MacAddress = availableNetwork.Bssid,
Ssid = availableNetwork.Ssid,
SignalBars = availableNetwork.SignalBars,
ChannelCenterFrequencyInKilohertz = availableNetwork.ChannelCenterFrequencyInKilohertz,
NetworkKind = availableNetwork.NetworkKind.ToString(),
PhysicalKind = availableNetwork.PhyKind.ToString(),
Encryption = availableNetwork.SecuritySettings.NetworkEncryptionType.ToString()
};
wifiPoint.WiFiSignals.Add(wifiSignal);
}
StringBuilder networkInfo = CreateCsvReport(wifiPoint);
return(networkInfo);
}
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");
}
}
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");
}
}
private byte GetNetworkSignal(WiFiNetworkReport report, string ssid)
{
var network = report.AvailableNetworks.Where(x => x.Ssid.ToLower() == ssid.ToLower()).FirstOrDefault();
return(network.SignalBars);
}
private Signal GetNetworkSignal(WiFiNetworkReport report, string ssid)
{
var network = report.AvailableNetworks.Where(x => x.Ssid.ToLower() == ssid.ToLower()).FirstOrDefault();
return(new Signal(ssid, network.Bssid, network.NetworkRssiInDecibelMilliwatts));
}
private async void ClientBtn_Click(object sender, RoutedEventArgs e)
{
var access2 = await WiFiAdapter.RequestAccessAsync();
if (access2 != WiFiAccessStatus.Allowed)
{
MesajFin.Text = "acces denied!";
}
else
{
MesajFin.Text = "acces allowed!";
if (wiFiAdapters == null)
{
wiFiAdapters = await WiFiAdapter.FindAllAdaptersAsync();
}
adapter2 = wiFiAdapters.First();
await adapter2.ScanAsync(); //scan
report = adapter2.NetworkReport;
scanVals.Clear();
foreach (var network in report.AvailableNetworks)
{
//listBox1.Items.Add(network.Ssid + " " + network.NetworkRssiInDecibelMilliwatts + "dBm");
scanVals.Add(network.Ssid, network.NetworkRssiInDecibelMilliwatts.ToString());
}
List<int> dbmValues;
foreach (String key in scanVals.AllKeys)
{
dbmValues = scanVals.GetValues(key).Select(int.Parse).ToList();
scanVals.Set(key, Math.Truncate(dbmValues.Average()).ToString()); //take the mean of the values for each network
// listBox1.Items.Add(key + " " + scanVals[key]);
}
var rez = NvcToDictionary(scanVals);
ClientScan = rez.ToDictionary(pair => pair.Key, pair => Convert.ToDouble(pair.Value));
scanVals.Clear();
myList = ClientScan.ToList();
myList.Sort((firstPair, nextPair) =>
{
return nextPair.Value.CompareTo(firstPair.Value);
}
);
listBox1.Items.Clear();
foreach (KeyValuePair<string, double> netw in myList)
{
listBox1.Items.Add(netw.Key + " " + netw.Value);
}// look first three networks or if nb < 3 put that nb.If zero network.. -> messsage. if no area - > error
//if key(SSID) in area - compute error and save it to an nvc for area 1, look in next area, do the same, iterate for next
//network found and so on. If a network is not found in an area , add maxerror to nvc. if no area contains a network raise flag and take
//another network. in de end, do a mean for all nvc entries, convert nvc to dictionary then to dict double and select the one with smallest
//error
}
}
