private async void btnConnect_Click(object sender, RoutedEventArgs e) { var access = await WiFiAdapter.RequestAccessAsync(); var wifiAdapterResults = await DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector()); WiFiAdapter wa = await WiFiAdapter.FromIdAsync(wifiAdapterResults[0].Id); WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Automatic; WiFiConnectionResult result; foreach (var availableNetwork in _report.AvailableNetworks) { if (availableNetwork.Ssid == _selectedSSID) { if (txtPassword.Text.Length > 1) { var credential = new PasswordCredential(); credential.Password = txtPassword.Text; result = await wa.ConnectAsync(availableNetwork, reconnectionKind, credential); } else { result = await wa.ConnectAsync(availableNetwork, reconnectionKind); } } } }
private async void WifiApCollectionList_SelectionChanged(object sender, SelectionChangedEventArgs e) { WifiAvailableAP selectedNetwork = e.AddedItems[0] as WifiAvailableAP; if (selectedNetwork == null || m_WifiAdapter == null) { //rootPage.NotifyUser("Network not selcted", NotifyType.ErrorMessage); return; } WiFiConnectionResult result; if (selectedNetwork.network.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211) { this.ShowProgressRing(); result = await m_WifiAdapter.ConnectAsync(selectedNetwork.network, WiFiReconnectionKind.Automatic); this.CloseProgressRing(); if (result.ConnectionStatus == WiFiConnectionStatus.Success) { this.Frame.GoBack(); } } else { m_ConnectInfo.Show(); } }
/// <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 <WiFiConnectionResult> ConnectAsync(WiFiNetworkDisplay network, WiFiReconnectionKind reconnectionKind, string password) { WiFiConnectionResult result; ReconnectionKind = reconnectionKind; if (network.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == Windows.Networking.Connectivity.NetworkAuthenticationType.Open80211) { result = await _firstAdapter.ConnectAsync(network.AvailableNetwork, reconnectionKind); } else { // Only the password potion of the credential need to be supplied var credential = new PasswordCredential { Password = password }; result = await _firstAdapter.ConnectAsync(network.AvailableNetwork, reconnectionKind, credential); } // Since a connection attempt was made, update the connectivity level displayed for each foreach (var net in NetworkCollection) { net.UpdateConnectivityLevel(); } return(result); }
private async void ConnectToNetwork(WiFiAvailableNetwork network) { lock (_stateLock) { _state = OnboardingState.ConfiguredValidating; } WiFiConnectionResult connectionResult; if (network.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211) { connectionResult = await _wlanAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic); } else { connectionResult = await _wlanAdapter.ConnectAsync(network, WiFiReconnectionKind.Automatic, new PasswordCredential { Password = _personalApPassword }); } lock (_stateLock) { if (connectionResult.ConnectionStatus == WiFiConnectionStatus.Success) { _error = OnboardingError.Validated; _errorMessage = null; _state = OnboardingState.ConfiguredValidated; } else { _state = OnboardingState.ConfiguredError; _errorMessage = connectionResult.ConnectionStatus.ToString(); switch (connectionResult.ConnectionStatus) { case WiFiConnectionStatus.AccessRevoked: case WiFiConnectionStatus.InvalidCredential: { _error = OnboardingError.Unauthorized; break; } case WiFiConnectionStatus.UnsupportedAuthenticationProtocol: { _error = OnboardingError.UnsupportedProtocol; break; } case WiFiConnectionStatus.NetworkNotAvailable: case WiFiConnectionStatus.Timeout: case WiFiConnectionStatus.UnspecifiedFailure: default: { _error = OnboardingError.ErrorMessage; break; } } } } }
private async void ConnectButton_Click(object sender, RoutedEventArgs e) { var selectedNetwork = ResultsListView.SelectedItem as WiFiNetworkDisplay; if (selectedNetwork == null || firstAdapter == null) { rootPage.NotifyUser("Network not selcted", NotifyType.ErrorMessage); return; } WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Manual; if (IsAutomaticReconnection.IsChecked.HasValue && IsAutomaticReconnection.IsChecked == true) { reconnectionKind = WiFiReconnectionKind.Automatic; } WiFiConnectionResult result; if (selectedNetwork.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == Windows.Networking.Connectivity.NetworkAuthenticationType.Open80211 && selectedNetwork.AvailableNetwork.SecuritySettings.NetworkEncryptionType == NetworkEncryptionType.None) { result = await firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind); } else { // Only the password potion of the credential need to be supplied var credential = new PasswordCredential(); credential.Password = NetworkKey.Password; result = await firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential); } if (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; } else { rootPage.NotifyUser(string.Format("Could not connect to {0}. Error: {1}", selectedNetwork.Ssid, result.ConnectionStatus), NotifyType.ErrorMessage); } // Since a connection attempt was made, update the connectivity level displayed for each foreach (var network in ResultCollection) { network.UpdateConnectivityLevel(); } }
private async void ConnectButton_Click(object sender, RoutedEventArgs e) { var selectedNetwork = ResultsListView.SelectedItem as WiFiNetworkDisplay; if (selectedNetwork == null || firstAdapter == null) { rootPage.NotifyUser("Network not selcted", NotifyType.ErrorMessage); return; } WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Manual; if (IsAutomaticReconnection.IsChecked.HasValue && IsAutomaticReconnection.IsChecked == true) { reconnectionKind = WiFiReconnectionKind.Automatic; } WiFiConnectionResult result; if (selectedNetwork.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211 && selectedNetwork.AvailableNetwork.SecuritySettings.NetworkEncryptionType == NetworkEncryptionType.None) { result = await firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind); } else { // Only the password portion of the credential need to be supplied var credential = new PasswordCredential(); // Make sure Credential.Password property is not set to an empty string. // Otherwise, a System.ArgumentException will be thrown. // The default empty password string will still be passed to the ConnectAsync method, // which should return an "InvalidCredential" error if (!string.IsNullOrEmpty(NetworkKey.Password)) { credential.Password = NetworkKey.Password; } result = await firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential); } if (result.ConnectionStatus == WiFiConnectionStatus.Success) { rootPage.NotifyUser(string.Format("Successfully connected to {0}.", selectedNetwork.Ssid), NotifyType.StatusMessage); } else { rootPage.NotifyUser(string.Format("Could not connect to {0}. Error: {1}", selectedNetwork.Ssid, result.ConnectionStatus), NotifyType.ErrorMessage); } }
private async void B_Click(object sender, RoutedEventArgs e) { Button b = (Button)sender; string ssid = b.Content as string; var nw = nwAdapter.NetworkReport.AvailableNetworks.Where(y => y.Ssid.ToLower() == ssid).FirstOrDefault(); await nwAdapter.ConnectAsync(nw, WiFiReconnectionKind.Automatic); }
/// <summary> /// Подключится к устройству /// </summary> /// <param name="wiFi">Устройсво как точка доступа</param> /// <param name="credential">Пароль</param> /// <returns></returns> public async Task <bool> ConnectToDeviceAsync(WiFiAvailableNetwork wiFi, PasswordCredential credential) { _currentWiFi = wiFi; _currentCredential = credential; WiFiConnectionResult conResult; bool initRes = await InitializeFirstAdapter(); if (initRes) { do { conResult = await _wifiAdapter.ConnectAsync(wiFi, WiFiReconnectionKind.Manual, credential); if (conResult.ConnectionStatus != WiFiConnectionStatus.Success) { System.Diagnostics.Debug.WriteLine("Connection failed!"); } else { System.Diagnostics.Debug.WriteLine("Connection success!"); } }while (conResult.ConnectionStatus != WiFiConnectionStatus.Success); return(true); } return(false); }
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); } }
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 async void OnItemClick(object sender, ItemClickEventArgs e) { var selectedNetwork = (WiFiNetworkDisplay)e.ClickedItem; WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Automatic; WiFiConnectionResult result; if (selectedNetwork.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211) { result = await firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind); ConnectResult(result); } else { if (selectedNetwork.ConnectivityLevel == "已连接") { firstAdapter.Disconnect(); await selectedNetwork.UpdateConnectivityLevel(); return; } if (selectedNetwork.Pwd.Length >= 8) { var credential = new PasswordCredential(); credential.Password = selectedNetwork.Pwd; result = await firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential); ConnectResult(result); } else { var message = new PwdControl(async(x) => { var credential = new PasswordCredential(); credential.Password = x; result = await firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential); ConnectResult(result); }); await message.ShowAsync(); } } }
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 ConnectWifiAsync(string bssid, string pwd) { var selectedNetwork = _wifisOriginals.First(w => w.Bssid == bssid); if (selectedNetwork == null || _firstAdapter == null) { //Network not selected" return; } WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Automatic; WiFiConnectionResult result; if (selectedNetwork.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211 && selectedNetwork.AvailableNetwork.SecuritySettings.NetworkEncryptionType == NetworkEncryptionType.None) { result = await _firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind); } else { // Only the password portion of the credential need to be supplied var credential = new PasswordCredential(); // Make sure Credential.Password property is not set to an empty string. // Otherwise, a System.ArgumentException will be thrown. // The default empty password string will still be passed to the ConnectAsync method, // which should return an "InvalidCredential" error //if (!string.IsNullOrEmpty(NetworkKey.Password)) //{ // credential.Password = NetworkKey.Password; //} result = await _firstAdapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential); } if (result.ConnectionStatus == WiFiConnectionStatus.Success) { //string.Format("Successfully connected to {0}.", selectedNetwork.Ssid) } else { //string.Format("Could not connect to {0}. Error: {1}", selectedNetwork.Ssid, result.ConnectionStatus) } }
public async void DoConnect() { if (selectedNetwork == null) { return; } Views.Busy.SetBusy(true, $"WiFi connecting to {deviceNetwork.Ssid}"); var connectionResult = await firstAdapter.ConnectAsync(deviceNetwork, WiFiReconnectionKind.Automatic); if (connectionResult.ConnectionStatus == WiFiConnectionStatus.Success) { try { HttpClient httpClient = new HttpClient(); var stringRes = await httpClient.GetStringAsync("http://192.168.4.1/"); var details = JsonConvert.DeserializeObject <DeviceDetails>(stringRes); selectedDevice.DeviceDetails.Status = DeviceStatus.Missing; selectedDevice.DeviceDetails.ConnectedTo = "None"; selectedDevice.DeviceDetails.ChipId = details.ChipId; selectedDevice.DeviceDetails.FirmwareName = details.FirmwareName; selectedDevice.DeviceDetails.FirmwareVersion = details.FirmwareVersion; selectedDevice.DeviceDetails.ModuleType = details.ModuleType; WifiConfig wifi = new WifiConfig() { ssid = ((WiFiAvailableNetwork)selectedNetwork).Ssid, password = password }; StringContent sc = new StringContent(JsonConvert.SerializeObject(wifi)); await httpClient.PostAsync("http://192.168.4.1/wifisettings", sc); //DataService db = new DataService(); //db.InsertNewDevice(newRegisteredDevice); } catch (Exception) { } } else { } Views.Busy.SetBusy(false); showProvisioningDetails = Visibility.Collapsed; showDeviceDetails = Visibility.Visible; }
public async Task <string> ConnectAsync(WiFiAvailableNetwork selectedNetwork, string networkPassword) { var credentials = new PasswordCredential() { UserName = "******", Password = networkPassword }; var status = await _adapter.ConnectAsync(selectedNetwork, WiFiReconnectionKind.Automatic, credentials); return(status.ConnectionStatus.ToString()); }
private async void ConnectButton_Click(object sender, RoutedEventArgs e) { WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Manual; if (ConnectAutomatically.IsChecked.HasValue && ConnectAutomatically.IsChecked.Value) { reconnectionKind = WiFiReconnectionKind.Automatic; } if (availableNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211) { await wifiAdapter.ConnectAsync(availableNetwork, reconnectionKind); } else { var credential = new PasswordCredential(); if (!string.IsNullOrEmpty(securityKey.Password)) { credential.Password = securityKey.Password; } await wifiAdapter.ConnectAsync(availableNetwork, reconnectionKind, credential); } }
/// <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 public Task ConnectToTelloWifi() { await InitializeFirstAdapter(); WiFiAdapter.Disconnect(); await ScanForNetworks(); var report = WiFiAdapter.NetworkReport; var telloNetwork = report.AvailableNetworks.First(availableNetwork => availableNetwork.Ssid.Equals(TelloSSID)); var connectionResult = await WiFiAdapter.ConnectAsync(telloNetwork, WiFiReconnectionKind.Manual); if (connectionResult.ConnectionStatus == WiFiConnectionStatus.Success) { Debug.WriteLine("Connected to Tello network with success"); } else { Debug.WriteLine("Failed to connect to Tello network : " + connectionResult.ConnectionStatus.ToString()); } }
/// <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; } }
public async Task ConnectToWifi() { try { if ((adapterStatus = await GetWifiAdaptors()) == AdaptersStatus.hasAdapters) { await wifiAdapter.ScanAsync(); var network = wifiAdapter.NetworkReport.AvailableNetworks.Where(y => y.Ssid == SSID).FirstOrDefault(); var credential = new PasswordCredential { Password = this.Password }; WiFiReconnectionKind reconnectionKind = WiFiReconnectionKind.Automatic; await wifiAdapter.ConnectAsync(network, reconnectionKind, credential); } } catch (Exception ex) { Debug.WriteLine("ConnectToWifi() Exception: " + ex.Message); throw; } }
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(); } }
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(); } }
private void Send(object sender, object e) #endif { timeTick = SEND_INTERVAL; if (client.Messages() == 0) return; #if _CREATE_WIFI_CONNECTION SetStatus("RequestAccessAsync"); var access = await WiFiAdapter.RequestAccessAsync(); if (access == WiFiAccessStatus.Allowed) { var wifiDevices = await DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector()); if (wifiDevices?.Count > 0) { wifi = await WiFiAdapter.FromIdAsync(wifiDevices[0].Id); await WriteStatus(true); await client.SaveQueueAsync(); SetStatus("ScanAsync"); IAsyncAction a = wifi?.ScanAsync(); await a; await WriteStatus(false); if (a.Status == AsyncStatus.Completed && wifi?.NetworkReport?.AvailableNetworks?.Count > 0) { foreach (var network in wifi.NetworkReport.AvailableNetworks) { bool found = false; uint wlan = 0; for (uint i = 0; i < Access.Networks; i++) { if (network.Ssid == Access.SSID(i)) { wlan = i; found = true; break; } } if (found) { var passwordCredential = new PasswordCredential(); passwordCredential.Password = Access.WIFI_Password(wlan); SetStatus("ConnectAsync"); var result = await wifi.ConnectAsync(network, WiFiReconnectionKind.Automatic, passwordCredential); if (result.ConnectionStatus.Equals(WiFiConnectionStatus.Success)) { #endif try { AsyncActionCompletedHandler handler = (IAsyncAction asyncInfo, AsyncStatus asyncStatus) => { var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => { switch (asyncStatus) { case AsyncStatus.Completed: errorText.Text = client.Sent() + " Messages sent"; SetStatus("OK"); networkError = 0; break; case AsyncStatus.Canceled: case AsyncStatus.Error: errorText.Text = "Send: " + asyncInfo.ErrorCode; SetStatus("Error"); break; } if (rebootPending) reboot = true; #if _CREATE_WIFI_CONNECTION wifi.Disconnect(); wifi = null; #endif }); }; SetStatus("Sending messages"); client.SendMessagesAsync(handler); } catch (Exception ex) { Error("Send: " + ex.ToString() + " " + ex.Message + " " + ex.HResult); } #if _CREATE_WIFI_CONNECTION } else NoConnection(false, result.ConnectionStatus.ToString()); return; } } NoConnection(rebootPending || (++networkError == 5), Access.Ssid + " not found."); } else NoConnection(rebootPending || (++networkError == 5), "No wifi networks found " + a.Status.ToString()); } else NoConnection(true, "No wifi adapter found"); } else NoConnection(true, "Wifi access denied" + access.ToString()); #endif }
private async Task <WiFiConnectionStatus> ConnectToNetwork(WiFiAdapter adapter, WiFiAvailableNetwork network) { lock (_stateLock) { _state = OnboardingState.ConfiguredValidating; } string resultPassword = ""; WiFiConnectionResult connectionResult; // For all open networks (when no PSK was provided) connect without a password // Note, that in test, we have seen some WEP networks identify themselves as Open even though // they required a PSK, so use the PSK as a determining factor if ((network.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211) && string.IsNullOrEmpty(_personalApPassword)) { connectionResult = await adapter.ConnectAsync(network, WiFiReconnectionKind.Automatic); } // Otherwise for all WEP/WPA/WPA2 networks convert the PSK back from a hex-ized format back to a passphrase, if necessary, // and onboard this device to the requested network. else { PasswordCredential pwd = new PasswordCredential(); resultPassword = ConvertHexToPassPhrase(network.SecuritySettings.NetworkAuthenticationType, _personalApPassword); pwd.Password = resultPassword; connectionResult = await adapter.ConnectAsync(network, WiFiReconnectionKind.Automatic, pwd); } lock (_stateLock) { if (connectionResult.ConnectionStatus == WiFiConnectionStatus.Success) { _error = OnboardingError.Validated; _errorMessage = null; _state = OnboardingState.ConfiguredValidated; } else { _state = OnboardingState.ConfiguredError; _errorMessage = connectionResult.ConnectionStatus.ToString(); switch (connectionResult.ConnectionStatus) { case WiFiConnectionStatus.AccessRevoked: case WiFiConnectionStatus.InvalidCredential: { _error = OnboardingError.Unauthorized; break; } case WiFiConnectionStatus.UnsupportedAuthenticationProtocol: { _error = OnboardingError.UnsupportedProtocol; break; } case WiFiConnectionStatus.NetworkNotAvailable: case WiFiConnectionStatus.Timeout: case WiFiConnectionStatus.UnspecifiedFailure: default: { _error = OnboardingError.ErrorMessage; break; } } } } #if DEBUG var folder = Windows.Storage.ApplicationData.Current.LocalFolder; var file = await folder.CreateFileAsync("ConnectionResult.Txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); string myout = "ConnectionResult= " + connectionResult.ConnectionStatus.ToString() + "\r\n"; myout += "Type=" + network.SecuritySettings.NetworkAuthenticationType.ToString() + "\r\n"; myout += "InputPassword= "******"\r\n"; myout += "ResultPassword= "******"\r\n"; await Windows.Storage.FileIO.WriteTextAsync(file, myout); #endif return(connectionResult.ConnectionStatus); }
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(); } }
private async void ConfirmButton_Click(object sender, RoutedEventArgs e) { string Pass = WiFiList[WiFiControl.SelectedIndex].Password; if (Pass != "" && Pass.Length >= 8) { WiFiList[WiFiControl.SelectedIndex].HideMessage(); (WiFiControl.ContainerFromItem(WiFiControl.SelectedItem) as ListViewItem).ContentTemplate = WiFiConnectingState; WiFiInfo Info = WiFiList[WiFiControl.SelectedIndex]; PasswordCredential Credential = new PasswordCredential { Password = Info.Password }; var ConnectResult = await WiFi.ConnectAsync(Info.GetWiFiAvailableNetwork(), Info.AutoConnect?WiFiReconnectionKind.Automatic : WiFiReconnectionKind.Manual, Credential); if (ConnectResult.ConnectionStatus == WiFiConnectionStatus.Success) { foreach (var WiFiInfo in from WiFiInfo in WiFiList where WiFiInfo.IsConnected == true select WiFiInfo) { WiFiInfo.ChangeConnectionStateAsync(false); } Info.HideMessage(); Info.ChangeConnectionStateAsync(true, true); (WiFiControl.ContainerFromItem(WiFiControl.SelectedItem) as ListViewItem).ContentTemplate = WiFiConnectedState; bool IsExist = false; foreach (var WiFiInfo in from WiFiInfo in StoragedWiFiInfoCollection where WiFiInfo.SSID == Info.Name select WiFiInfo) { if (WiFiInfo.Password != Info.Password) { await SQLite.GetInstance().UpdateWiFiDataAsync(Info.Name, Info.Password); } else if (WiFiInfo.Password == Info.Password) { IsExist = true; } if (WiFiInfo.AutoConnect != Info.AutoConnect) { await SQLite.GetInstance().UpdateWiFiDataAsync(Info.Name, Info.AutoConnect); } break; } if (!IsExist) { IsExist = false; StoragedWiFiInfoCollection.Add(new WiFiInDataBase(Info.Name, Info.Password, Info.AutoConnect ? "True" : "False")); await SQLite.GetInstance().SetWiFiDataAsync(Info.Name, Info.Password, Info.AutoConnect); } } else { WiFi.Disconnect(); (WiFiControl.ContainerFromItem(WiFiControl.SelectedItem) as ListViewItem).ContentTemplate = WiFiErrorState; Info.ShowMessage("连接失败"); } //连接完成后重新开始搜索 WiFiScanTimer.Tick += WiFiScanTimer_Tick; WiFiScanTimer.Start(); } else { WiFiList[WiFiControl.SelectedIndex].ShowMessage("密码必须非空且大于8位"); } }
private async void Connect_Click(object sender, RoutedEventArgs e) { var selectedNetwork = ResultsListView.SelectedItem as WiFiNetworkDisplay; if (selectedNetwork == null || adapter == null) { ConnectionStatusText.Text = "No network selected"; return; } WiFiReconnectionKind reconnectionKind = IsAutomaticReconnection.IsChecked.GetValueOrDefault() ? WiFiReconnectionKind.Automatic : WiFiReconnectionKind.Manual; WiFiConnectionResult result; if (selectedNetwork.AvailableNetwork.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211 && selectedNetwork.AvailableNetwork.SecuritySettings.NetworkEncryptionType == NetworkEncryptionType.None) { result = await adapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind); } else { // Only the password potion of the credential need to be supplied var credential = new PasswordCredential(); try { credential.Password = NetworkKey.Password; } catch (ArgumentException) { ConnectionStatusText.Text = "Password is invalid."; return; } result = await adapter.ConnectAsync(selectedNetwork.AvailableNetwork, reconnectionKind, credential); } var requiresWebview = false; if (result.ConnectionStatus == WiFiConnectionStatus.Success) { var connectedProfile = await adapter.NetworkAdapter.GetConnectedProfileAsync(); var level = connectedProfile.GetNetworkConnectivityLevel(); if (level == NetworkConnectivityLevel.ConstrainedInternetAccess || level == NetworkConnectivityLevel.LocalAccess) { ConnectionStatusText.Text = string.Format("Limited access on {0}.", selectedNetwork.Ssid); requiresWebview = true; } else { ConnectionStatusText.Text = string.Format("Successfully connected to {0}.", selectedNetwork.Ssid); } } else { ConnectionStatusText.Text = string.Format("Could not connect to {0}. Error: {1}", selectedNetwork.Ssid, result.ConnectionStatus); } webView.Visibility = requiresWebview ? Visibility.Visible : Visibility.Collapsed; // Since a connection attempt was made, update the connectivity level displayed for each foreach (var network in networks) { network.UpdateConnectivityLevel(); } }
async void device_AvailableNetworksChanged(WiFiAdapter sender, object args) { if (isEnter) { return; } isEnter = true; if (hasAutoPassResult) { return; } WiFiNetworkReport networkReport = sender.NetworkReport; await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() => { txtStatus.Visibility = Visibility.Collapsed; listWiFi.Items.Clear(); int remainingCount = App.WifiName.Count; //uint sigstrengthPassCnt = 0; //look for the requested network foreach (WiFiAvailableNetwork network in networkReport.AvailableNetworks) { // Remove duplicated SSID String strSsid = network.Ssid; if (!String.IsNullOrEmpty(strSsid)) { foreach (Customer item in listWiFi.Items) { if (item.Ssid.ToUpper() == network.Ssid.ToUpper()) { strSsid = String.Empty; break; } } } if (strSsid == string.Empty) { continue; } // Try to connect network if <ConnectionName> setting exists in SFTConfig.xml if (!isConnection && (network.Ssid.ToUpper() == App.WifiNameConnection.ToUpper())) { var connectioResult = await sender.ConnectAsync(network, WiFiReconnectionKind.Automatic); if (connectioResult.ConnectionStatus == WiFiConnectionStatus.Success) { isConnection = true; App.LogComment(network.Ssid + " : Connection OK!"); sender.Disconnect(); } } // Set signal strength image string image = String.Format(CultureInfo.CurrentCulture, "/Assets/Wifi{0}", (Application.Current.RequestedTheme == ApplicationTheme.Dark) ? "Dark" : "Light"); int signalStrength = network.SignalBars; if (signalStrength > 4) { signalStrength = 4; } if (signalStrength < 1) { signalStrength = 1; } signalStrength--; image += signalStrength.ToString(CultureInfo.CurrentCulture) + ".png"; // Set Authentication Type String authType = App.LoadString("Secure"); switch (network.SecuritySettings.NetworkAuthenticationType) { case NetworkAuthenticationType.Open80211: authType = App.LoadString("Open"); break; case NetworkAuthenticationType.None: authType = App.LoadString("Open"); break; case NetworkAuthenticationType.Unknown: authType = App.LoadString("Open"); break; } // convert from rssi to quality: https://msdn.microsoft.com/en-us/library/windows/desktop/ms706828(v=vs.85).aspx int quality = (Math.Min(Math.Max((int)network.NetworkRssiInDecibelMilliwatts, -100), -50) + 100) * 2; // mark 2.4G and 5G APs in the list string details = authType + ", " + App.LoadString("Signal") + " " + quality + "%" + ", " + PhyTypes[(int)network.PhyKind]; // Add a scanned network to list box listWiFi.Items.Add(new Customer(network.Ssid, details, image)); // App.LogComment("Available network: " + network.Ssid + ", " + authType + ", Bars=" + network.SignalBars.ToString(CultureInfo.CurrentCulture)); App.LogComment("Available network: " + network.Ssid + ", " + details + ", Bars=" + network.SignalBars.ToString(CultureInfo.CurrentCulture)); // Auto pass: check how many AP passed signal strength threshold value //if (curConfig.SigStrength_ThresholdCount > 0) //{ // if (network.SignalBars >= curConfig.SigStrength_ThresholdSigBar) // sigstrengthPassCnt++; //} // Auto pass if WiFi test meet auto pass critera: found all WiFi predefined name list if (remainingCount > 0) { bool isAboveThreshold = false; int qualityInPercentage = 0; if (curConfig.SigStrength_ThresholdSigQuality > 0) { qualityInPercentage = (Math.Min(Math.Max((int)network.NetworkRssiInDecibelMilliwatts, -100), -50) + 100) * 2; if (App.WifiName.Contains(network.Ssid) && qualityInPercentage >= curConfig.SigStrength_ThresholdSigQuality) { isAboveThreshold = true; } } else if (curConfig.SigStrength_ThresholdSigBar > 0) { if (App.WifiName.Contains(network.Ssid) && network.SignalBars >= curConfig.SigStrength_ThresholdSigBar) { remainingCount--; } } if (isAboveThreshold) { remainingCount--; App.LogComment(network.Ssid + " Found; Rssi=" + network.NetworkRssiInDecibelMilliwatts + "dBm(%" + qualityInPercentage + "), SigBar=" + network.SignalBars + "; PhyType=" + network.PhyKind); } } } // Enter Auto-Pass/Auto-Faill condition if one of <AvailableName>, <ConnectionName>, or <Threshold> setting exists in SFTConfig.xml if (App.WifiName.Count > 0 || !String.IsNullOrEmpty(App.WifiNameConnection) // || curConfig.SigStrength_ThresholdCount > 0 ) { hasAutoPassResult = true; // App.LogComment("Require " + curConfig.SigStrength_ThresholdCount + " AP that has SignalBar >= " + curConfig.SigStrength_ThresholdSigBar + ": Found " + sigstrengthPassCnt); if (remainingCount == 0 && isConnection) // && sigstrengthPassCnt >= curConfig.SigStrength_ThresholdCount) { App.ResultControl("btnPass", this.Name); } else { App.ResultControl("btnFail", this.Name); } } isEnter = false; }); }
private async void ConnectToNetwork(WiFiAdapter adapter, WiFiAvailableNetwork network) { lock (_stateLock) { _state = OnboardingState.ConfiguredValidating; } WiFiConnectionResult connectionResult; if (network.SecuritySettings.NetworkAuthenticationType == NetworkAuthenticationType.Open80211) { connectionResult = await adapter.ConnectAsync(network, WiFiReconnectionKind.Automatic); } else { connectionResult = await adapter.ConnectAsync(network, WiFiReconnectionKind.Automatic, new PasswordCredential { Password = _personalApPassword }); } lock (_stateLock) { if (connectionResult.ConnectionStatus == WiFiConnectionStatus.Success) { _error = OnboardingError.Validated; _errorMessage = null; _state = OnboardingState.ConfiguredValidated; } else { _state = OnboardingState.ConfiguredError; _errorMessage = connectionResult.ConnectionStatus.ToString(); switch (connectionResult.ConnectionStatus) { case WiFiConnectionStatus.AccessRevoked: case WiFiConnectionStatus.InvalidCredential: { _error = OnboardingError.Unauthorized; break; } case WiFiConnectionStatus.UnsupportedAuthenticationProtocol: { _error = OnboardingError.UnsupportedProtocol; break; } case WiFiConnectionStatus.NetworkNotAvailable: case WiFiConnectionStatus.Timeout: case WiFiConnectionStatus.UnspecifiedFailure: default: { _error = OnboardingError.ErrorMessage; break; } } } } }