public static void SetupAndConnectNetwork()
{
wifi = WiFiAdapter.FindAllAdapters()[0];
WiFiConnectionResult wiFiConnectionResult = wifi.Connect(c_SSID, WiFiReconnectionKind.Automatic, c_AP_PASSWORD);
NetworkInterface[] nis = NetworkInterface.GetAllNetworkInterfaces();
if (nis.Length > 0)
{
NetworkInterface ni = nis[0];
ni.EnableAutomaticDns();
ni.EnableDhcp();
CheckIP();
if (!NetworkHelpers.IpAddressAvailable.WaitOne(5000, false))
{
throw new NotSupportedException("ERROR: IP address is not assigned to the network interface.");
}
}
else
{
throw new NotSupportedException("ERROR: there is no network interface configured.\r\nOpen the 'Edit Network Configuration' in Device Explorer and configure one.");
}
}
private void ConnectResult(WiFiConnectionResult result)
{
switch (result.ConnectionStatus)
{
case WiFiConnectionStatus.AccessRevoked:
Toast.ShowError("连接失败，因为已取消访问网络。");
break;
case WiFiConnectionStatus.InvalidCredential:
Toast.ShowError("连接失败，因为提供了无效的凭据");
break;
case WiFiConnectionStatus.NetworkNotAvailable:
Toast.ShowError("连接失败，因为网络不可用");
break;
case WiFiConnectionStatus.Success:
Toast.Show("连接成功");
break;
case WiFiConnectionStatus.Timeout:
Toast.ShowError("连接失败，因为连接尝试超时");
break;
case WiFiConnectionStatus.UnspecifiedFailure:
Toast.ShowError("连接失败，原因未列在此列表中");
break;
case WiFiConnectionStatus.UnsupportedAuthenticationProtocol:
Toast.ShowError("连接失败，因为不支持身份验证协议");
break;
}
}
private static void WifiAvailableNetworksChanged(WiFiAdapter sender, object e)
{
var wifiNetworks = sender.NetworkReport.AvailableNetworks;
foreach (var net in wifiNetworks)
{
Debug.WriteLine($"SSID: {net.Ssid}, strength: {net.SignalBars}");
if (net.Ssid == MySsid)
{
if (_isConnected)
{
sender.Disconnect();
_isConnected = false;
Thread.Sleep(3000);
}
// Connect to network
WiFiConnectionResult result = sender.Connect(net, WiFiReconnectionKind.Automatic, MyPassword);
// Display status
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
Debug.WriteLine($"Connected to Wifi network {net.Ssid}");
_isConnected = true;
break;
}
else
{
Debug.WriteLine($"Error {result.ConnectionStatus} connecting to 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");
}
}
}
}
private async void ConnectButton_Click(object sender, RoutedEventArgs e)
{
try
{
var selectedNetwork = m_WifiApCollectionListView.SelectedItem as WifiAvailableAP;
var credential = new PasswordCredential();
this.m_ConnectInfo.flyout.Hide();
credential.Password = m_ConnectInfo.passwordBox.Password;
this.ShowProgressRing();
WiFiConnectionResult result = await m_WifiAdapter.ConnectAsync(selectedNetwork.network, WiFiReconnectionKind.Automatic, credential);
this.CloseProgressRing();
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
this.Frame.GoBack();
}
//throw new NotImplementedException();
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
}
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>
/// 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>
/// Connects desired WiFi network specified by the input SSID.
/// </summary>
/// <param name="ssid">SSID of the desired WiFi network</param>
/// <param name="password">Password of the desired WiFI network</param>
public async Task <WiFiConnectionStatus> Connect(string ssid, string password)
{
rootPage.Log("NETWORK_MANAGER::Connecting to " + ssid + "...");
try
{
foreach (WiFiAvailableNetwork network in m_wiFiAdapter.NetworkReport.AvailableNetworks)
{
if (network.Ssid == ssid)
{
WiFiConnectionResult result = null;
if (network.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211)
{
result = await m_wiFiAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic);
}
else
{
PasswordCredential credential = new PasswordCredential();
credential.Password = password;
result = await m_wiFiAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic, credential);
}
rootPage.Log("NETWORK_MANAGER::Connection result: " + result.ConnectionStatus.ToString());
return(result.ConnectionStatus);
}
}
rootPage.Log("NETWORK_MANAGER::Connection result: Network not found.");
return(WiFiConnectionStatus.NetworkNotAvailable);
}
catch (Exception e)
{
rootPage.Log("NETWORK_MANAGER::[ERROR] Hr" + e.HResult + ": " + e.Message);
}
return(WiFiConnectionStatus.UnspecifiedFailure);
}
public async Task ConnectToAccessPoint(AccessPoint accessPoint)
{
var wifiAdapterList = await WiFiAdapter.FindAllAdaptersAsync();
var wifiList = from adapter in wifiAdapterList from network in adapter.NetworkReport.AvailableNetworks select Tuple.Create(adapter, network);
var apInfo = wifiList.Where(wifiInfo => wifiInfo.Item2.Ssid.Equals(accessPoint.Ssid)).First();
WiFiConnectionResult result = null;
if (apInfo != null)
{
var wifiNetwork = apInfo.Item2;
var wiFiAdapter = apInfo.Item1;
if (wifiNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211)
{
Debug.WriteLine(string.Format("Opening connection to: {0}", wifiNetwork.Ssid));
result = await wiFiAdapter.ConnectAsync(wifiNetwork, WiFiReconnectionKind.Manual);
}
else
{
PasswordCredential credential = new PasswordCredential();
credential.Password = "******";
Debug.WriteLine(string.Format("Opening connection to using credentials: {0} [{1}]", wifiNetwork.Ssid, credential.Password));
result = await wiFiAdapter.ConnectAsync(wifiNetwork, WiFiReconnectionKind.Manual, credential);
}
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
Debug.WriteLine(string.Format("Connected successfully to: {0}.{1}", wiFiAdapter.NetworkAdapter.NetworkAdapterId, wifiNetwork.Ssid));
_connectedWifiAdapter = wiFiAdapter;
await CreateStreamSocketClient(new HostName(SharedConstants.SOFT_AP_IP), SharedConstants.CONNECTION_PORT);
}
}
string connectionEventString = "Connected";
if (_ConnectedSocket == null)
{
Debug.WriteLine(string.Format("Connection failed: {0}", result != null ? result.ConnectionStatus.ToString() : "access point not found"));
connectionEventString = "FailedConnected";
}
if (AccessPointConnectedEvent != null)
{
AccessPointConnectedEvent(connectionEventString);
}
}
private async void ConnectToSoftAPAsync()
{
if (m_wiFiAdapter != null)
{
if (m_selectedSoftAPNetwork == null)
{
UpdateStatusAsync("Network not selected. Please select a network.", NotifyType.ErrorMessage);
}
else
{
UpdateStatusAsync(string.Format("Attempting to connect to {0}...", m_selectedSoftAPNetwork.Ssid), NotifyType.StatusMessage);
WiFiConnectionResult result = null;
if (m_selectedSoftAPNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211)
{
result = await m_wiFiAdapter.ConnectAsync(m_selectedSoftAPNetwork, WiFiReconnectionKind.Manual);
}
else
{
if (string.IsNullOrWhiteSpace(m_softAPPassword))
{
UpdateStatusAsync("No password entered.", NotifyType.ErrorMessage);
}
else
{
PasswordCredential credential = new PasswordCredential();
credential.Password = m_softAPPassword;
result = await m_wiFiAdapter.ConnectAsync(m_selectedSoftAPNetwork, WiFiReconnectionKind.Manual, credential);
}
ClearPasswords();
}
if (result != null)
{
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
UpdateStatusAsync(string.Format("Successfully connected to {0}.", m_selectedSoftAPNetwork.Ssid), NotifyType.StatusMessage);
ScanForOnboardingInterfaces();
}
else
{
UpdateStatusAsync(string.Format("Failed to connect to {0} with error: {1}.", m_selectedSoftAPNetwork.Ssid, result.ConnectionStatus), NotifyType.ErrorMessage);
}
}
}
}
}
public async Task <WifiConnectionStatus> ConnectToAccessPoint(AccessPoint accessPoint)
{
var wifiAdapterList = await WiFiAdapter.FindAllAdaptersAsync();
var wifiList = from adapter in wifiAdapterList from network in adapter.NetworkReport.AvailableNetworks select Tuple.Create(adapter, network);
var apInfo = wifiList.Where(wifiInfo => wifiInfo.Item2.Ssid.Equals(accessPoint.Ssid)).First();
WiFiConnectionResult result = null;
if (apInfo != null)
{
var wifiNetwork = apInfo.Item2;
var wiFiAdapter = apInfo.Item1;
if (wifiNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211)
{
Debug.WriteLine($"Opening connection to: {wifiNetwork.Ssid}");
result = await wiFiAdapter.ConnectAsync(wifiNetwork, WiFiReconnectionKind.Manual);
}
else
{
PasswordCredential credential = new PasswordCredential
{
Password = "******"// "Edison1234" //Need to be dynamic
};
Debug.WriteLine($"Opening connection to using credentials: {wifiNetwork.Ssid} [{credential.Password}]");
result = await wiFiAdapter.ConnectAsync(wifiNetwork, WiFiReconnectionKind.Manual, credential);
}
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
Debug.WriteLine($"Connected successfully to: {wiFiAdapter.NetworkAdapter.NetworkAdapterId}.{wifiNetwork.Ssid}");
_connectedWifiAdapter = wiFiAdapter;
return(WifiConnectionStatus.Connected);
}
else
{
Debug.WriteLine($"Connection failed: {(result != null ? result.ConnectionStatus.ToString() : "access point not found")}");
}
}
return(WifiConnectionStatus.FailedConnected);
}
/// <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;
}
}
public static async Task <string> TryConnectToWireless()
{
try
{
WiFiAdapter adapter = await WiFiSettings.Instance.Load();
await WiFiConnector.Instance.Init(adapter);
if (adapter != null)
{
//We have an adapter saved, try to connect
WiFiAvailableNetwork availableNetwork = await WiFiConnector.Instance.GetSpecificNetwork(
adapter,
WiFiSettings.Instance.Bssid,
WiFiSettings.Instance.Ssid);
var network = new WiFiNetworkDisplay(availableNetwork, adapter);
WiFiConnectionResult result = await WiFiConnector.Instance.ConnectAsync(
network,
WiFiSettings.Instance.ReconnectionKind,
WiFiSettings.Instance.Password);
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
Debug.WriteLine("Connect on startup to wireless network: " + network.Ssid);
return(GetAddresses());
}
else
{
Debug.WriteLine("Could not connect to wireless network on startup: " + network.Ssid);
}
}
}
catch (Exception e)
{
Debug.WriteLine("Could not connect to wireless network on startup: " + e);
}
return("Unknown");
}
/// <summary>
/// Connect to Wireless Network
/// </summary>
/// <param name="_network">Wireless Network Name (SSID)</param>
/// <param name="_password">Password Creditentials</param>
/// <returns></returns>
public async Task Connect(string _network, string _password, string id)
{
try
{
// Get WiFi Adapter from ID
this._wifi = await WiFiAdapter.FromIdAsync(id);
// Scan for Wireless Networks
await this._wifi.ScanAsync();
// Select Wireless Network
List <WiFiAvailableNetwork> _list = new List <WiFiAvailableNetwork>();
_list.AddRange(_wifi.NetworkReport.AvailableNetworks.ToList());
_nets = _list.FirstOrDefault(x => x.Ssid.Equals(_network));
// Enter Password Creditentials
var credential = new PasswordCredential()
{
Password = _password
};
// Wireless Connection Result
_conn = await _wifi.ConnectAsync(_nets, WiFiReconnectionKind.Automatic, credential);
// Connected Status
if (_conn.ConnectionStatus != WiFiConnectionStatus.Success)
{
_connected = false;
}
else
{
_connected = true;
}
}
catch
{
_connected = false;
}
}
private async void ConnectToNetwork_ButtonClick(object sender, RoutedEventArgs e)
{
VirtualKeyboard.Visibility = Visibility.Collapsed;
var selectedNetwork = ResultsListView.SelectedItem as WiFiNetworkDisplay;
if (selectedNetwork == null)
{
//await UIMessager.Instance.ShowMessageAndWaitForFeedback("Network empty", "Network has not been selected!", UIMessageButtons.OK, UIMessageType.Information);
return;
}
if (string.IsNullOrEmpty(NetworkPassword.Text))
{
//await UIMessager.Instance.ShowMessageAndWaitForFeedback("Password empty", "Password cannot be empty!", UIMessageButtons.OK, UIMessageType.Information);
return;
}
WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Manual;
//if (IsAutomaticReconnection) //always reconnect automatically
{
reconnectionKind = WiFiReconnectionKind.Automatic;
}
WiFiConnectionResult result = await WiFiConnector.Instance.ConnectAsync(selectedNetwork, reconnectionKind, NetworkPassword.Text);
if (result.ConnectionStatus == WiFiConnectionStatus.Success)
{
WiFiSettings.Instance.Save(reconnectionKind, selectedNetwork, WiFiConnector.Instance.DeviceId, NetworkPassword.Text);
//await UIMessager.Instance.ShowMessageAndWaitForFeedback("WiFi connected successfully!", string.Format("Successfully connected to {0}.", selectedNetwork.Ssid), UIMessageButtons.OK, UIMessageType.Information);
}
else
{
//await UIMessager.Instance.ShowMessageAndWaitForFeedback("WiFi connection error!",
// string.Format("Could not connect to {0}. Error: {1}", selectedNetwork.Ssid, result.ConnectionStatus),
// UIMessageButtons.OK, UIMessageType.Error);
}
}
private async void DoWifiConnect(object sender, RoutedEventArgs e, bool pushButtonConnect)
{
var selectedNetwork = ResultsListView.SelectedItem as WiFiNetworkDisplay;
if (selectedNetwork == null || firstAdapter == null)
{
rootPage.NotifyUser("Network not selected", NotifyType.ErrorMessage);
return;
}
var ssid = selectedNetwork.AvailableNetwork.Ssid;
if (string.IsNullOrEmpty(ssid))
{
if (string.IsNullOrEmpty(selectedNetwork.HiddenSsid))
{
rootPage.NotifyUser("Ssid required for connection to hidden network.", NotifyType.ErrorMessage);
return;
}
else
{
ssid = selectedNetwork.HiddenSsid;
}
}
WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Manual;
if (selectedNetwork.ConnectAutomatically)
{
reconnectionKind = WiFiReconnectionKind.Automatic;
}
Task <WiFiConnectionResult> didConnect = null;
WiFiConnectionResult result = null;
if (pushButtonConnect)
{
if (ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 5, 0))
{
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, null, string.Empty, WiFiConnectionMethod.WpsPushButton).AsTask();
}
}
else
{
PasswordCredential credential = new PasswordCredential();
if (selectedNetwork.IsEapAvailable && selectedNetwork.UsePassword)
{
if (!String.IsNullOrEmpty(selectedNetwork.Domain))
{
credential.Resource = selectedNetwork.Domain;
}
credential.UserName = selectedNetwork.UserName ?? "";
credential.Password = selectedNetwork.Password ?? "";
}
else if (!String.IsNullOrEmpty(selectedNetwork.Password))
{
credential.Password = selectedNetwork.Password;
}
if (selectedNetwork.IsHiddenNetwork)
{
// Hidden networks require the SSID to be supplied
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential, ssid).AsTask();
}
else
{
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential).AsTask();
}
}
SwitchToItemState(selectedNetwork, WifiConnectingState, false);
if (didConnect != null)
{
result = await didConnect;
}
if (result != null && result.ConnectionStatus == WiFiConnectionStatus.Success)
{
rootPage.NotifyUser(string.Format("Successfully connected to {0}.", selectedNetwork.Ssid), NotifyType.StatusMessage);
// refresh the webpage
webViewGrid.Visibility = Visibility.Visible;
toggleBrowserButton.Content = "Hide Browser Control";
refreshBrowserButton.Visibility = Visibility.Visible;
ResultCollection.Remove(selectedNetwork);
ResultCollection.Insert(0, selectedNetwork);
ResultsListView.SelectedItem = ResultsListView.Items[0];
ResultsListView.ScrollIntoView(ResultsListView.SelectedItem);
SwitchToItemState(selectedNetwork, WifiConnectedState, false);
}
else
{
// Entering the wrong password may cause connection attempts to timeout
// Disconnecting the adapter will return it to a non-busy state
if (result.ConnectionStatus == WiFiConnectionStatus.Timeout)
{
firstAdapter.Disconnect();
}
rootPage.NotifyUser(string.Format("Could not connect to {0}. Error: {1}", selectedNetwork.Ssid, (result != null ? result.ConnectionStatus : WiFiConnectionStatus.UnspecifiedFailure)), NotifyType.ErrorMessage);
SwitchToItemState(selectedNetwork, WifiConnectState, false);
}
// Since a connection attempt was made, update the connectivity level displayed for each
foreach (var network in ResultCollection)
{
var task = network.UpdateConnectivityLevelAsync();
}
}
/// <summary>Run asynchronous connection where ConnectionCompleted is raised on completion</summary>
/// <param name="deviceDataModel">The data model with information on the device</param>
public void ConnectAsync(WifiNetworkInfo dataModel)
{
this.DisconnectSynchronous(true);
Task.Run(async() => {
try {
this.log.InfoEntry("ConnectAsync");
this.log.Info("ConnectAsync", () => string.Format(
"Host:{0} Service:{1}", dataModel.RemoteHostName, dataModel.RemoteServiceName));
WiFiAvailableNetwork net = this.GetNetwork(dataModel.SSID);
if (net != null)
{
// Connect WIFI level
// TODO How to establish kind of authentication
switch (dataModel.AuthenticationType)
{
// Arduino authentication - requires password but no user name
case NetAuthenticationType.RSNA_PSK:
break;
}
WiFiConnectionResult result = null;
PasswordCredential cred = this.GetCredentials(dataModel);
if (cred == null)
{
result = await wifiAdapter.ConnectAsync(net, WiFiReconnectionKind.Automatic);
}
else
{
result = await wifiAdapter.ConnectAsync(net, WiFiReconnectionKind.Automatic, cred);
}
// If the password is bad you get a timeout rather than failed credentials
switch (result.ConnectionStatus)
{
case WiFiConnectionStatus.Success:
//ConnectionProfile profile = await this.wifiAdapter.NetworkAdapter.GetConnectedProfileAsync();
//this.log.Info("ConnectAsync", () => string.Format("Connected to:{0}", profile.ProfileName));
//if (profile.IsWlanConnectionProfile) {
//await this.DumpWifiAdapterInfo(wifiAdapter);
this.log.Info("ConnectAsync", () => string.Format("Connecting to {0}:{1}", dataModel.RemoteHostName, dataModel.RemoteServiceName));
//this.log.Info("ConnectAsync", () => string.Format(
// "Connecting to {0}:{1}:{2}", dataModel.RemoteHostName, dataModel.RemoteServiceName, dataModel.Password));
// Connect socket
await msgPump.ConnectAsync2(new SocketMsgPumpConnectData()
{
MaxReadBufferSize = 255,
RemoteHostName = dataModel.RemoteHostName,
ServiceName = dataModel.RemoteServiceName,
// TODO - determine protection level according to connection
ProtectionLevel = SocketProtectionLevel.PlainSocket,
});
break;
case WiFiConnectionStatus.UnspecifiedFailure:
case WiFiConnectionStatus.AccessRevoked:
case WiFiConnectionStatus.InvalidCredential:
case WiFiConnectionStatus.NetworkNotAvailable:
case WiFiConnectionStatus.Timeout:
case WiFiConnectionStatus.UnsupportedAuthenticationProtocol:
this.OnError?.Invoke(this, new WifiError(result.ConnectionStatus.Convert()));
break;
default:
this.OnError?.Invoke(this, new WifiError(WifiErrorCode.Unknown));
break;
}
}
else
{
this.OnError?.Invoke(this, new WifiError(WifiErrorCode.NetworkNotAvailable)
{
ExtraInfo = dataModel.SSID
});
}
}
catch (ErrReportException erE) {
this.OnError?.Invoke(this, new WifiError(WifiErrorCode.Unknown)
{
ExtraInfo = erE.Report.Msg
});
}
catch (Exception e) {
this.log.Exception(9999, "Connect Asyn Error", e);
this.OnError?.Invoke(this, new WifiError(WifiErrorCode.Unknown));
}
});
}
public async static Task <bool> ConnectToWifi(WifiSpot wifi)
{
IsConnected = false;
if (wifi == null)
{
return(false);
}
try
{
Debug.WriteLine("Connecting to : " + wifi.SSID);
var access = await WiFiAdapter.RequestAccessAsync();
WiFiAdapter firstAdapter;
switch (access)
{
case WiFiAccessStatus.DeniedBySystem:
Debug.WriteLine("[WIFI]: System blocking");
return(false);
case WiFiAccessStatus.DeniedByUser:
Debug.WriteLine("[WIFI]: User blocking");
return(false);
case WiFiAccessStatus.Unspecified:
Debug.WriteLine("[WIFI]: Unknow error");
return(false);
default:
break;
}
var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
if (result.Count <= 0)
{
return(false);
}
firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
await firstAdapter.ScanAsync();
var report = firstAdapter.NetworkReport;
foreach (var i in report.AvailableNetworks)
{
Debug.WriteLine(i.Ssid);
}
foreach (var network in report.AvailableNetworks)
{
if (network.Ssid.Contains(wifi.SSID))
{
WiFiConnectionResult connectionResult = null;
if (wifi.PswNeeded)
{
try
{
PasswordCredential pass = new PasswordCredential();
pass.Password = wifi.Psw;
connectionResult = await firstAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic, pass);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
else
{
connectionResult = await firstAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic);
}
if (connectionResult.ConnectionStatus == WiFiConnectionStatus.Success)
{
IsConnected = true;
}
else
{
IsConnected = false;
}
return(IsConnected);
}
}
return(false);
}
catch (Exception e)
{
Debug.WriteLine("[WIFI ERROR]: exception : " + e.ToString());
return(false);
}
}
private async void DoWifiConnect(object sender, RoutedEventArgs e, bool pushButtonConnect)
{
var selectedNetwork = ResultsListView.SelectedItem as WiFiNetworkDisplay;
if (selectedNetwork == null || firstAdapter == null)
{
rootPage.NotifyUser("Network not selected", NotifyType.ErrorMessage);
return;
}
WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Manual;
if (selectedNetwork.ConnectAutomatically)
{
reconnectionKind = WiFiReconnectionKind.Automatic;
}
Task <WiFiConnectionResult> didConnect = null;
WiFiConnectionResult result = null;
if (pushButtonConnect)
{
if (ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 5, 0))
{
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, null, String.Empty, WiFiConnectionMethod.WpsPushButton).AsTask <WiFiConnectionResult>();
}
}
else if (selectedNetwork.IsEapAvailable)
{
if (selectedNetwork.UsePassword)
{
var credential = new PasswordCredential();
if (!String.IsNullOrEmpty(selectedNetwork.Domain))
{
credential.Resource = selectedNetwork.Domain;
}
credential.UserName = selectedNetwork.UserName ?? "";
credential.Password = selectedNetwork.Password ?? "";
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential).AsTask <WiFiConnectionResult>();
}
else
{
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind).AsTask <WiFiConnectionResult>();
}
}
else if (selectedNetwork.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == Windows.Networking.Connectivity.NetworkAuthenticationType.Open80211 &&
selectedNetwork.AvailableNetwork.SecuritySettings.NetworkEncryptionType == NetworkEncryptionType.None)
{
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind).AsTask <WiFiConnectionResult>();
}
else
{
// Only the password potion of the credential need to be supplied
if (String.IsNullOrEmpty(selectedNetwork.Password))
{
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind).AsTask <WiFiConnectionResult>();
}
else
{
var credential = new PasswordCredential();
credential.Password = selectedNetwork.Password ?? "";
didConnect = firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential).AsTask <WiFiConnectionResult>();
}
}
SwitchToItemState(selectedNetwork, WifiConnectingState, false);
if (didConnect != null)
{
result = await didConnect;
}
if (result != null && result.ConnectionStatus == WiFiConnectionStatus.Success)
{
rootPage.NotifyUser(string.Format("Successfully connected to {0}.", selectedNetwork.Ssid), NotifyType.StatusMessage);
// refresh the webpage
webViewGrid.Visibility = Visibility.Visible;
toggleBrowserButton.Content = "Hide Browser Control";
refreshBrowserButton.Visibility = Visibility.Visible;
ResultCollection.Remove(selectedNetwork);
ResultCollection.Insert(0, selectedNetwork);
ResultsListView.SelectedItem = ResultsListView.Items[0];
ResultsListView.ScrollIntoView(ResultsListView.SelectedItem);
SwitchToItemState(selectedNetwork, WifiConnectedState, false);
}
else
{
rootPage.NotifyUser(string.Format("Could not connect to {0}. Error: {1}", selectedNetwork.Ssid, result.ConnectionStatus), NotifyType.ErrorMessage);
SwitchToItemState(selectedNetwork, WifiConnectState, false);
}
// Since a connection attempt was made, update the connectivity level displayed for each
foreach (var network in ResultCollection)
{
network.UpdateConnectivityLevel();
}
}
public async Task ConnectAsync()
{
if (SelectedWiFiNetwork == null)
{
OnError?.Invoke(this, new ArgumentException("Network not selected"));
return;
}
WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Manual;
if (SelectedWiFiNetwork.ConnectAutomatically)
{
reconnectionKind = WiFiReconnectionKind.Automatic;
}
Task <WiFiConnectionResult> didConnect = null;
WiFiConnectionResult result = null;
if (SelectedWiFiNetwork.IsEapAvailable)
{
if (SelectedWiFiNetwork.UsePassword)
{
var credential = new PasswordCredential();
if (!String.IsNullOrEmpty(SelectedWiFiNetwork.Domain))
{
credential.Resource = SelectedWiFiNetwork.Domain;
}
credential.UserName = SelectedWiFiNetwork.UserName ?? "";
credential.Password = SelectedWiFiNetwork.Password ?? "";
didConnect = _wifiAdapter.ConnectAsync(SelectedWiFiNetwork.AvailableNetwork, reconnectionKind, credential).AsTask();
}
else
{
didConnect = _wifiAdapter.ConnectAsync(SelectedWiFiNetwork.AvailableNetwork, reconnectionKind).AsTask();
}
}
else if (SelectedWiFiNetwork.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211 &&
SelectedWiFiNetwork.AvailableNetwork.SecuritySettings.NetworkEncryptionType == NetworkEncryptionType.None)
{
didConnect = _wifiAdapter.ConnectAsync(SelectedWiFiNetwork.AvailableNetwork, reconnectionKind).AsTask();
}
else
{
// Only the password potion of the credential need to be supplied
if (String.IsNullOrEmpty(SelectedWiFiNetwork.Password))
{
didConnect = _wifiAdapter.ConnectAsync(SelectedWiFiNetwork.AvailableNetwork, reconnectionKind).AsTask();
}
else
{
var credential = new PasswordCredential();
credential.Password = SelectedWiFiNetwork.Password ?? "";
didConnect = _wifiAdapter.ConnectAsync(SelectedWiFiNetwork.AvailableNetwork, reconnectionKind, credential).AsTask();
}
}
OnConnecting?.Invoke(this, EventArgs.Empty);
if (didConnect != null)
{
result = await didConnect;
}
if (result != null && result.ConnectionStatus == WiFiConnectionStatus.Success)
{
WiFiNetworks.Remove(SelectedWiFiNetwork);
WiFiNetworks.Insert(0, SelectedWiFiNetwork);
OnSelect?.Invoke(this, EventArgs.Empty);
OnConnected?.Invoke(this, EventArgs.Empty);
}
else
{
OnError?.Invoke(this, new Exception("Could not connect to network"));
OnDisconnected?.Invoke(this, EventArgs.Empty);
}
// Since a connection attempt was made, update the connectivity level displayed for each
foreach (var network in WiFiNetworks)
{
await network.UpdateConnectivityLevel();
}
}
