示例#1
1
        public async Task<WiFiScanResultTypes> LoadData() {
            Enabled_btnRefresh = false;

            ShowRunning();
            
            WifiNetworks = new ObservableCollection<WiFiAvailableNetwork>();

            var access = await WiFiAdapter.RequestAccessAsync();

            if (access != WiFiAccessStatus.Allowed) {
                Enabled_btnRefresh = true;
                
                HideRunning();

                return WiFiScanResultTypes.NO_ACCESS_TO_WIFI_CARD;
            }
            
            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
            
            if (result.Count > 0) {
                PrimaryAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
            } else {
                Enabled_btnRefresh = true;
                HideRunning();

                return WiFiScanResultTypes.NO_WIFI_CARD;
            }
            
            await PrimaryAdapter.ScanAsync();

            foreach (var network in PrimaryAdapter.NetworkReport.AvailableNetworks) {
                WifiNetworks.Add(network);
            }

            WifiNetworks = new ObservableCollection<WiFiAvailableNetwork>(WifiNetworks.OrderByDescending(a => a.SignalBars));

            Enabled_btnRefresh = true;

            HideRunning();

            return WiFiScanResultTypes.SUCCESS;
        }
示例#2
0
        private async void ScanForWiFiNetworksAsync()
        {
            if (m_selectedWiFiAdapterIndex >= 0)
            {
                m_wiFiAdapter = m_wiFiAdapterList[m_selectedWiFiAdapterIndex];
            }

            if (m_wiFiAdapter != null)
            {
                UpdateConnectivityStatusAsync();
                NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged;
                UpdateStatusAsync("Scanning for available WiFi networks...", NotifyType.StatusMessage);
                await m_wiFiAdapter.ScanAsync();

                m_onboarderNetworkList.Clear();
                if (m_wiFiAdapter.NetworkReport.AvailableNetworks.Count > 0)
                {
                    foreach (WiFiAvailableNetwork network in m_wiFiAdapter.NetworkReport.AvailableNetworks)
                    {
                        m_onboarderNetworkList.Add(network);
                    }
                    ConnectPanelVisibility = Visibility.Visible;
                    UpdateStatusAsync("Scan complete. Please select a network to connect.", NotifyType.StatusMessage);
                }
                else
                {
                    UpdateStatusAsync("Scan complete. No WiFi networks found.", NotifyType.ErrorMessage);
                }
            }
        }
示例#3
0
 public WiFiNetworkDisplay(WiFiAvailableNetwork availableNetwork, WiFiAdapter adapter)
 {
     AvailableNetwork = availableNetwork;
     this.adapter     = adapter;
     UpdateWiFiImage();
     UpdateConnectivityLevel();
 }
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            ResultCollection = new ObservableCollection <WiFiNetworkDisplay>();
            rootPage         = MainPage.Current;

            // 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)
            {
                rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage);
            }
            else
            {
                DataContext = this;

                var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

                if (result.Count >= 1)
                {
                    firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);

                    var button = new Button();
                    button.Content = string.Format("Scan");
                    button.Click  += Button_Click;
                    Buttons.Children.Add(button);
                }
                else
                {
                    rootPage.NotifyUser("No WiFi Adapters detected on this machine", NotifyType.ErrorMessage);
                }
            }
        }
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            ResultCollection = new ObservableCollection <WiFiNetworkDisplay>();
            rootPage         = MainPage.Current;

            // 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 result = await WiFiAdapter.RequestAccessAsync();

            if (result != WiFiAccessStatus.Allowed)
            {
                rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage);
            }
            else
            {
                DataContext = this;

                wiFiAdapters = await WiFiAdapter.FindAllAdaptersAsync();

                int index = 0;
                foreach (var adapter in wiFiAdapters)
                {
                    var button = new Button();
                    button.Tag     = index;
                    button.Content = String.Format("WiFi Adapter {0}", ++index);
                    button.Click  += Button_Click;
                    Buttons.Children.Add(button);
                }
            }
        }
示例#6
0
        // Call this method before accessing WiFiAdapters Dictionary
        private async Task UpdateAdapters()
        {
            Log.Enter();
            bool fInit = false;

            foreach (var adapter in WiFiAdapters)
            {
                if (adapter.Value == null)
                {
                    // New Adapter plugged-in which requires Initialization
                    fInit = true;
                }
            }

            if (fInit)
            {
                List <String> WiFiAdaptersID = new List <string>(WiFiAdapters.Keys);
                for (int i = 0; i < WiFiAdaptersID.Count; i++)
                {
                    string id = WiFiAdaptersID[i];
                    try
                    {
                        WiFiAdapters[id] = await WiFiAdapter.FromIdAsync(id);
                    }
                    catch (Exception)
                    {
                        WiFiAdapters.Remove(id);
                    }
                }
            }
            Log.Leave();
        }
示例#7
0
 private static void ConnectWlan(string ssid, string password)
 {
     try
     {
         IAsyncOperation <IReadOnlyList <WiFiAdapter> > operation1 = WiFiAdapter.FindAllAdaptersAsync();
         var adapters = operation1.GetResults();
         var adapter  = adapters.FirstOrDefault();
         var ignore   = adapter.ScanAsync();
         foreach (var network in adapter.NetworkReport.AvailableNetworks)
         {
             if (network.Ssid.Equals(ssid))
             {
                 PasswordCredential passwordCredential = new PasswordCredential();
                 passwordCredential.Password = password;
                 var operation2 = adapter.ConnectAsync(network, WiFiReconnectionKind.Automatic, passwordCredential);
                 operation2.AsTask().Wait();
                 var result = operation2.GetResults();
                 if (result.ConnectionStatus != WiFiConnectionStatus.Success)
                 {
                     throw new Exception("Connect WiFi failed! Reason: " + result.ConnectionStatus.ToString());
                 }
             }
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
示例#8
0
        public static async Task <bool> TryConnectWlan()
        {
            resetEvent = new AutoResetEvent(false);
            try
            {
                var access = await WiFiAdapter.RequestAccessAsync();

                if (access == WiFiAccessStatus.Allowed)
                {
                    TurnOnWiFi();
                    StartWiFiHotspot();

                    var result = resetEvent.WaitOne(120000);

                    DisposeWiFiPublisher();
                    return(result);
                }

                return(false);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
示例#9
0
        /// <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");
                    }
                }
            }
        }
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            ResultCollection = new ObservableCollection<WiFiNetworkDisplay>();
            rootPage = MainPage.Current;

            // 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)
            {
                rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage);
            }
            else
            {
                DataContext = this;

                var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
                if (result.Count >= 1)
                {
                    firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
                    RegisterButton.IsEnabled = true;
                }
                else
                {
                    rootPage.NotifyUser("No WiFi Adapters detected on this machine", NotifyType.ErrorMessage);
                }
            }
        }
示例#11
0
 private static void AddWindowsHandlers(this IServiceCollection services)
 {
     services.AddSingleton(async s => (await WiFiAdapter.FindAllAdaptersAsync()).First());
     services.AddSingleton <ISignalReader <WiFiNetworkReport>, WindowsSignalReader>();
     services.AddSingleton <ISignalParser <WiFiNetworkReport>, WindowsSignalParser>();
     services.AddHostedService <SignalService <WiFiNetworkReport> >();
 }
示例#12
0
        public async Task <int> Initialize()
        {
            if (m_wiFiAdapter == null)
            {
                //Request access of WiFi adapter.
                WiFiAccessStatus accessStatus = await WiFiAdapter.RequestAccessAsync();

                if (accessStatus != WiFiAccessStatus.Allowed)
                {
                    rootPage.Log("NETWORK_MANAGER::[ERROR]ScanForWiFiAdapterAsync: WiFi access denied.");
                }
                else
                {
                    //Find WiFi adatper
                    m_wiFiAdapterList = await WiFiAdapter.FindAllAdaptersAsync();

                    rootPage.Log("NETWORK_MANAGER::Found " + m_wiFiAdapterList.Count + " wifi adapter.");
                    while (m_wiFiAdapterList.Count < 1)
                    {
                        await System.Threading.Tasks.Task.Delay(3000);

                        m_wiFiAdapterList = await WiFiAdapter.FindAllAdaptersAsync();

                        rootPage.Log("NETWORK_MANAGER::Found " + m_wiFiAdapterList.Count + " wifi adapter.");
                    }

                    //Get the first WiFi adatper from the list.
                    //TODO: Edit this part if the system has more than one WiFi adatpers.
                    m_wiFiAdapter = m_wiFiAdapterList[0];
                }
                return(-1);
            }
            return(0);
        }
示例#13
0
        public async void Scan()
        {
            var access = await WiFiAdapter.RequestAccessAsync();
            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
            if (result.Count >= 1)
            {
                 nwAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
                await nwAdapter.ScanAsync();

                sp.Children.Clear();
                foreach (var item in nwAdapter.NetworkReport.AvailableNetworks)
                {
                    StackPanel s = new StackPanel();
                    s.Orientation = Orientation.Horizontal;
                    Button b = new Button();
                    TextBlock t = new TextBlock();
                    t.Text = $"{item.NetworkRssiInDecibelMilliwatts} {item.ChannelCenterFrequencyInKilohertz} {item.IsWiFiDirect} {item.NetworkKind} {item.SecuritySettings.NetworkAuthenticationType} {item.SecuritySettings.NetworkAuthenticationType} {item.SignalBars} {item.Uptime}";
                    b.Content += item.Ssid;
                    
                    b.Click += B_Click;
                    s.Children.Add(b);
                    s.Children.Add(t);
                    sp.Children.Add(s);

                }
            }
        }
示例#14
0
        public static void Main()
        {
            try
            {
                // Get the first WiFI Adapter
                WiFiAdapter wifi = WiFiAdapter.FindAllAdapters()[0];

                // Set up the AvailableNetworksChanged event to pick up when scan has completed
                wifi.AvailableNetworksChanged += Wifi_AvailableNetworksChanged;

                // Loop forever scanning every 30 seconds
                while (true)
                {
                    Debug.WriteLine("starting WiFi scan");
                    wifi.ScanAsync();

                    Thread.Sleep(30000);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("message:" + ex.Message);
                Debug.WriteLine("stack:" + ex.StackTrace);
            }

            Thread.Sleep(Timeout.Infinite);
        }
示例#15
0
        public static async Task <IEnumerable <WiFiNetworkInfo> > GetNetworksAsync(WiFiAdapter adapter)
        {
            List <WiFiNetworkInfo> wifiNetworks = new List <WiFiNetworkInfo>();

            await adapter.ScanAsync();

            foreach (var network in adapter.NetworkReport.AvailableNetworks)
            {
                wifiNetworks.Add(new WiFiNetworkInfo()
                {
                    BSSID = network.Bssid,
                    SSID  = network.Ssid,
                    ChannelCenterFrequencyInKilohertz = network.ChannelCenterFrequencyInKilohertz,
                    SignalBars   = network.SignalBars,
                    IsWiFiDirect = network.IsWiFiDirect,
                    NetworkRssiInDecibelMilliwatts = network.NetworkRssiInDecibelMilliwatts,
                    PhyKind            = network.PhyKind,
                    NetworkKind        = network.NetworkKind,
                    AuthenticationType = network.SecuritySettings.NetworkAuthenticationType,
                    EncryptionType     = network.SecuritySettings.NetworkEncryptionType,
                    BeaconInterval     = network.BeaconInterval,
                    Uptime             = network.Uptime
                });
            }

            return(wifiNetworks);
        }
    private async void Scan()
    {
        if (IsReady)
        {
            IsReady = false;
            uint signal = 0;
#if !UNITY_EDITOR
            var result = await WiFiAdapter.FindAllAdaptersAsync();

            if (result.Count >= 1)
            {
                var firstAdapter = result[0];
                await firstAdapter.ScanAsync();

                GenerateNetworkReport(firstAdapter.NetworkReport);
                if (!string.IsNullOrEmpty(Ssid))
                {
                    signal = GetNetworkSignal(firstAdapter.NetworkReport, Ssid);
                }
            }
#endif
            IsReady = true;
            Signal  = signal;
        }
    }
示例#17
0
        public async Task <IEnumerable <WifiNetwork> > GetWifiAsync()
        {
            _wifis          = new List <WifiNetwork>();
            _wifisOriginals = new List <WiFiNetworkDisplay>();

            var access = await WiFiAdapter.RequestAccessAsync();

            if (access != WiFiAccessStatus.Allowed)
            {
                //rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage);
            }
            else
            {
                var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

                if (result.Count >= 1)
                {
                    _firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);

                    await ScanAsync();

                    return(_wifis.OrderByDescending(w => w.SignalBars));
                }
                else
                {
                    //No WiFi Adapters detected on this machine
                }
            }

            return(null);
        }
示例#18
0
        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");
                    }
                }
            }
        }
示例#19
0
        public static async Task <string> GetSsid()
        {
            var profile = NetworkInformation.GetInternetConnectionProfile();

            if (profile != null && profile.IsWlanConnectionProfile)
            {
                return(profile.WlanConnectionProfileDetails.GetConnectedSsid());
            }

            var access = await WiFiAdapter.RequestAccessAsync();

            if (access == WiFiAccessStatus.Allowed)
            {
                var adapters = await WiFiAdapter.FindAllAdaptersAsync();

                foreach (var adapter in adapters)
                {
                    var connectedProfile = await adapter.NetworkAdapter.GetConnectedProfileAsync();

                    if (connectedProfile != null)
                    {
                        return(connectedProfile.ProfileName);
                    }
                }
            }
            return(string.Empty);
        }
示例#20
0
        private async Task <Tuple <Windows.Devices.WiFi.WiFiConnectionStatus, string> > ConnectWifiAndGetPassword(string ssid)
        {
            var access = await WiFiAdapter.RequestAccessAsync();

            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

            if (result.Count >= 1)
            {
                var nwAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);

                await nwAdapter.ScanAsync();

                //because spelling errors
                var nw = nwAdapter.NetworkReport.AvailableNetworks.Where(network => network.Ssid.Contains(ssid));
                if (nw.Count() > 0)
                {
                    var suitAP = nw.First();
                    var pass   = SsidToPassword(suitAP.Ssid);
                    var conn   = await nwAdapter.ConnectAsync(suitAP, WiFiReconnectionKind.Automatic, new Windows.Security.Credentials.PasswordCredential("none", "none", pass));

                    return(new Tuple <WiFiConnectionStatus, string>(conn.ConnectionStatus, pass));
                }
            }

            return(new Tuple <WiFiConnectionStatus, string>(WiFiConnectionStatus.NetworkNotAvailable, ""));
        }
示例#21
0
        /// <summary>
        /// Отправить устройству параметры для подключения к роутеру
        /// </summary>
        /// <param name="connectionParams"></param>
        /// <returns></returns>
        public async Task <bool> SendConnectionParamsToDeviceAsAP(IConnectionParams connectionParams)
        {
            return(await Task.Run(async() =>
            {
                List <CommandParameter> content = new List <CommandParameter>
                {
                    new CommandParameter("ssid", connectionParams.Ssid),
                    new CommandParameter("password", connectionParams.Password)
                };

                //TODO: изменить на устройстве код приёма параметров подключения
                Communicator communicator = new Communicator();
                OperationResult result = await communicator.SendToDevice(_ip, CommandNames.ConnectionParams, content);

                if (!result.Success)
                {
                    ConnectorByWiFi connector = new ConnectorByWiFi();
                    WiFiAdapter wiFiAdapter = await connector.GetWiFiAdapter();
                    if (wiFiAdapter.NetworkAdapter.NetworkItem.GetNetworkTypes() == Windows.Networking.Connectivity.NetworkTypes.None)
                    {
                        result.Success = await connector.Reconnect();
                    }
                }

                return result.Success;
            }));
        }
示例#22
0
        private async Task <List <string> > GetWirelessSuits()
        {
            var access = await WiFiAdapter.RequestAccessAsync();

            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

            if (result.Count >= 1)
            {
                var nwAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);

                await nwAdapter.ScanAsync();

                //because spelling errors
                var nw = nwAdapter.NetworkReport.AvailableNetworks.Where(network => network.Ssid.Contains("NSVR") || network.Ssid.Contains("NVSR:"));

                return(nw.Select(suit => suit.Ssid).ToList());
                //if (nw.Count() > 0)
                //{
                //	var suitAP = nw.First();
                //	var pass = SsidToPassword(suitAP.Ssid);
                //	var conn = await nwAdapter.ConnectAsync(suitAP, WiFiReconnectionKind.Automatic, new Windows.Security.Credentials.PasswordCredential("none", "none", pass));

                //	return new Tuple<WiFiConnectionStatus, string>(conn.ConnectionStatus, pass);

                //}
            }

            return(new List <string>());
        }
示例#23
0
        private async Task RefreshWiFiNetworkName()
        {
            string wiFiName = "No WiFi !";

            if (_wifiAdapter == null)
            {
                _wifiAdapter = await FetchWiFiAdapter();
            }

            if (_wifiAdapter != null)
            {
                var connectedProfile = await _wifiAdapter.NetworkAdapter.GetConnectedProfileAsync();

                if (connectedProfile != null)
                {
                    wiFiName = connectedProfile.ProfileName;
                }
            }
            ;

            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
            {
                wifiNetworkButton.Content = wiFiName;
                if (wiFiName.ToLower() != "#racing")
                {
                    wifiNetworkButton.Background = _tomatoBrush;
                    wifiNetworkButton.Foreground = _whiteBrush;
                }
                else
                {
                    wifiNetworkButton.Background = _transparentBrush;
                    wifiNetworkButton.Foreground = _lightGreenBrush;
                }
            });
        }
示例#24
0
        public async Task <bool> StartAsync()
        {
            // only one start allowed on the object
            lock (this)
            {
                if (_started)
                {
                    return(false);
                }

                _started = true;
            }

            if (await WiFiAdapter.RequestAccessAsync() != WiFiAccessStatus.Allowed)
            {
                return(false);
            }

            _started = true;

            // enumerate and monitor WiFi devices in the system
            string deviceSelector = WiFiAdapter.GetDeviceSelector();

            _watcher          = Windows.Devices.Enumeration.DeviceInformation.CreateWatcher(deviceSelector);
            _watcher.Added   += _watcher_Added;
            _watcher.Removed += _watcher_Removed;

            _watcher.Start();

            return(true);
        }
示例#25
0
        private async void ScanForWiFiAdaptersAsync()
        {
            if (m_wiFiAdapter == null)
            {
                UpdateStatusAsync("Requesting WiFi access...", NotifyType.StatusMessage);
                WiFiAccessStatus accessStatus = await WiFiAdapter.RequestAccessAsync();

                if (accessStatus != WiFiAccessStatus.Allowed)
                {
                    UpdateStatusAsync("WiFi access denied.", NotifyType.ErrorMessage);
                }
                else
                {
                    m_wiFiAdapterList = await WiFiAdapter.FindAllAdaptersAsync();

                    if (m_wiFiAdapterList.Count > 0)
                    {
                        for (int i = 0; i < m_wiFiAdapterList.Count; i++)
                        {
                            m_wiFiAdapterDisplayNames.Add(string.Format("Adapter {0}", (i + 1)));
                        }
                        WiFiAdapterListVisibility = Visibility.Visible;
                        UpdateStatusAsync("Please select a WiFi adapter.", NotifyType.StatusMessage);
                    }
                    else
                    {
                        UpdateStatusAsync("No WiFi adapters detected on this machine.", NotifyType.ErrorMessage);
                    }
                }
            }
        }
示例#26
0
        private async Task <bool> UpdateInfoAsync()
        {
            if ((await TestAccessAsync()) == false)
            {
                return(false);
            }

            networkNameToInfo = new Dictionary <WiFiAvailableNetwork, WiFiAdapter>();

            var adapters = WiFiAdapter.FindAllAdaptersAsync();

            foreach (var adapter in await adapters)
            {
                await adapter.ScanAsync();

                if (adapter.NetworkReport == null)
                {
                    continue;
                }

                foreach (var network in adapter.NetworkReport.AvailableNetworks)
                {
                    if (!HasSsid(networkNameToInfo, network.Ssid))
                    {
                        networkNameToInfo[network] = adapter;
                    }
                }
            }

            return(true);
        }
示例#27
0
        public static IAsyncAction WaitForWiFiConnection()
        {
            return(AsyncInfo.Run(async(cancel) =>
            {
                if (!await EnableWiFi())
                {
                    return;
                }

                var accessAllowed = await WiFiAdapter.RequestAccessAsync();
                if (accessAllowed == WiFiAccessStatus.Allowed)
                {
                    var adapterList = await DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
                    var wifiAdapter = await WiFiAdapter.FromIdAsync(adapterList[0].Id);

                    for (var i = 0; i < 5; i++)
                    {
                        cancel.ThrowIfCancellationRequested();
                        await wifiAdapter.ScanAsync();
                        await Task.Delay(100);
                        if (await wifiAdapter.NetworkAdapter.GetConnectedProfileAsync() != null)
                        {
                            break;
                        }
                    }
                }
            }));
        }
示例#28
0
        public async Task <ResultCommandAvailableNetworks> GetAvailableNetworkListHandler()
        {
            try
            {
                var wifiAdapterList = await WiFiAdapter.FindAllAdaptersAsync();

                List <AvailableNetwork> networks = new List <AvailableNetwork>();

                foreach (var adapter in wifiAdapterList)
                {
                    try
                    {
                        var availableNetworks = await PortalApiHelper.GetAvailableNetworks(adapter.NetworkAdapter.NetworkAdapterId);

                        if (availableNetworks != null && availableNetworks.AvailableNetworks != null)
                        {
                            networks.AddRange(availableNetworks.AvailableNetworks);
                        }
                    }
                    catch (Exception) { }
                }

                var sortedNetworks = networks.OrderBy(x => x.SSID).Distinct().ToList();

                return(new ResultCommandAvailableNetworks()
                {
                    Networks = sortedNetworks, IsSuccess = true
                });
            }
            catch (Exception e)
            {
                DebugHelper.LogError($"Error GetAvailableNetworkListHandler: {e.Message}.");
                return(ResultCommand.CreateFailedCommand <ResultCommandAvailableNetworks>($"Error GetAvailableNetworkListHandler: {e.Message}."));
            }
        }
示例#29
0
        public async Task extract_access_point_names()
        {
            /*
             * // Credits: https://stackoverflow.com/questions/40645146/how-can-i-get-the-currently-connected-wifi-ssid-and-signal-strength-in-dotnet-co
             * // WARNING: Not cross-platform. Only avaliable on Windows. Old (2014).
             * var networks = NetworkListManager.GetNetworks(NetworkConnectivityLevels.All);
             * foreach (var network in networks)
             * {
             *  var sConnected = ((network.IsConnected == true) ? " (connected)" : " (disconnected)");
             *  Console.WriteLine("Network : " + network.Name + " - Category : " + network.Category.ToString() + sConnected);
             *  access_point_names.Add(network.Name);
             * }
             */
            // Credits: https://stackoverflow.com/questions/496568/how-do-i-get-the-available-wifi-aps-and-their-signal-strength-in-net?rq=1
            var adapters = await WiFiAdapter.FindAllAdaptersAsync();

            foreach (var adapter in adapters)
            {
                foreach (var network in adapter.NetworkReport.AvailableNetworks)
                {
                    Console.WriteLine($"ssid: {network.Ssid}" + " | " + $"signal strength: {network.SignalBars}");
                    access_point_names.Add(network.Ssid);
                }
            }
        }
示例#30
0
        public byte WiFiAdapterStatusAsync()
        {
            var t_Task = Task.Run(async delegate
            {
                vReturn = 0x40;
                ConnectionProfile connections = NetworkInformation.GetInternetConnectionProfile();
                bool internet = connections != null && connections.GetNetworkConnectivityLevel() == NetworkConnectivityLevel.InternetAccess;
                if (internet)
                {
                    vReturn = 0x04;
                }                       // internet available
                else
                {
                    // no internet -> check for adapter
                    var result = await DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
                    if (!(result.Count >= 1))
                    {
                        vReturn = 0x01;
                    }                                                // No WiFi Adapter available
                    else
                    {
                        vReturn = 0x02;
                    }
                }
            });

            t_Task.Wait();
            return(vReturn);
        }
        private async Task InitializeFirstAdapter()
        {
            var access = await WiFiAdapter.RequestAccessAsync();

            if (access != WiFiAccessStatus.Allowed)
            {
                throw new Exception("WiFiAccessStatus not allowed");
            }
            else
            {
                var wifiAdapterResults =
                    await DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

                if (wifiAdapterResults.Count >= 1)
                {
                    this.WiFiAdapter =
                        await WiFiAdapter.FromIdAsync(wifiAdapterResults[0].Id);
                }
                else
                {
                    throw new Exception("WiFi Adapter not found.");
                }
            }

            if (this.WiFiAdapter != null)
            {
                await this.WiFiAdapter.ScanAsync();
            }
        }
        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.");
            }
        }
示例#33
0
        /// <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");
                    }
                }
            }
        }
        private 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)
            {
                ResultCollection.Add(new WiFiNetworkDisplay(network, adapter));
            }
        }
        public async Task<bool> Initialise()
        {
            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

            if (result.Count >= 1)
            {
                firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
            }
            else
                return false;

            return true;
        }
示例#36
0
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            var access = await WiFiAdapter.RequestAccessAsync();
            if (access == WiFiAccessStatus.Allowed)
            {
                DataContext = this;

                var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
                if (result.Count >= 1)
                {
                    wifiAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
                }
            }
        }
        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));
                }
            });
        }
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            ResultCollection = new ObservableCollection<WiFiNetworkDisplay>();
            rootPage = MainPage.Current;

            // 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)
            {
                rootPage.NotifyUser("Access denied", NotifyType.ErrorMessage);
            }
            else
            {
                DataContext = this;

                var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
                if (result.Count >= 1)
                {
                    firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);

                    var scanButton = new Button();
                    scanButton.Content = string.Format("Scan");
                    scanButton.Click += ScanButton_Click;
                    Buttons.Children.Add(scanButton);

                    var disconnectButton = new Button();
                    disconnectButton.Content = string.Format("Disconnect");
                    disconnectButton.Click += DisconnectButton_Click; ;
                    Buttons.Children.Add(disconnectButton);

                    // Monitor network status changes
                    await UpdateConnectivityStatusAsync();
                    NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged;
                }
                else
                {
                    rootPage.NotifyUser("No WiFi Adapters detected on this machine", NotifyType.ErrorMessage);
                }
            }
        }
示例#39
0
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            var access = await WiFiAdapter.RequestAccessAsync();

            if (access == WiFiAccessStatus.Allowed)
            {
                DataContext = this;

                var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
                if (result.Count >= 1)
                {
                    wifiAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
                }
            }
            await WiFiAdapter.FindAllAdaptersAsync();
            while (true)
            {
                await wifiAdapter.ScanAsync();
               
                await Task.Delay(5000);
                    
                    List<string> ls = new List<string>();
                    List<string> sortedList = new List<string>();
                    foreach (var network in wifiAdapter.NetworkReport.AvailableNetworks)
                    {
                        var _dist = Math.Pow(10, 0.05 * (-20 * Math.Log10(network.ChannelCenterFrequencyInKilohertz / 1000) + 27.55 + Math.Abs(network.NetworkRssiInDecibelMilliwatts)));
                        ls.Add(Math.Round(_dist, 1) + "m " + " Name : " + network.Ssid + " , dB signal RSSID : " + network.NetworkRssiInDecibelMilliwatts);
                    }


                    sortedList = ls.OrderBy(s => double.Parse(s.Substring(0, s.IndexOf('m')))).ToList();

                    WiFiList.ItemsSource = sortedList;
                       
                //connectpanel.Visibility = Visibility.Collapsed;
            }
        }
示例#40
0
 private async void ScanForWifi()
 {
     var access = await WiFiAdapter.RequestAccessAsync();
     if (access != WiFiAccessStatus.Allowed)
     {
         System.Diagnostics.Debug.WriteLine("Access denied");
         return;
     }
     DataContext = this;
     var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
     if (result.Count > 0)
     {
         Adapter = await WiFiAdapter.FromIdAsync(result[0].Id);
         var connected = await Adapter.NetworkAdapter.GetConnectedProfileAsync();
     }
     else
     {
         System.Diagnostics.Debug.WriteLine("No WiFiAdapters detected");
         return;
     }
     await Adapter.ScanAsync();
     
     FillWifiCollection(Adapter.NetworkReport);
 }
示例#41
0
        private async void HandleAdapterAdded(DeviceWatcher sender, DeviceInformation information)
        {
            if (_wlanAdapterId == null)
            {
                _wlanAdapterId = information.Id;
                _wlanAdapter = await WiFiAdapter.FromIdAsync(_wlanAdapterId);

                lock (_stateLock)
                {
                    if (_state != OnboardingState.ConfiguredValidated)
                    {
                        _softAccessPoint.Start();
                    }
                }
                _onboardingProducer.Start();
                _iconProducer.Start();
            }
        }
示例#42
0
        private void HandleAdapterRemoved(DeviceWatcher sender, DeviceInformationUpdate information)
        {
            if (_wlanAdapterId != null && _wlanAdapterId == information.Id)
            {
                _softAccessPoint.Stop();
                _wlanAdapter = null;
                _wlanAdapterId = null;

                _onboardingProducer.Stop();
                _iconProducer.Stop();
            }
        }
示例#43
0
        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;
                            }
                    }
                }
            }
        }
示例#44
0
        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
        }
 public WiFiAdapterEvents(WiFiAdapter This)
 {
     this.This = This;
 }
示例#46
0
 public WifiDataModel(WiFiAvailableNetwork avNetwork, WiFiAdapter adapter)
 {
     AvailableNetwork = avNetwork;
     this.adapter = adapter;
 }
        private async void ScanForWiFiNetworksAsync()
        {
            if (m_selectedWiFiAdapterIndex >= 0)
            {
                m_wiFiAdapter = m_wiFiAdapterList[m_selectedWiFiAdapterIndex];
            }

            if (m_wiFiAdapter != null)
            {
                UpdateConnectivityStatusAsync();
                NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged;
                UpdateStatusAsync("Scanning for available WiFi networks...", NotifyType.StatusMessage);
                await m_wiFiAdapter.ScanAsync();
                m_onboarderNetworkList.Clear();
                if (m_wiFiAdapter.NetworkReport.AvailableNetworks.Count > 0)
                {
                    foreach (WiFiAvailableNetwork network in m_wiFiAdapter.NetworkReport.AvailableNetworks)
                    {
                        m_onboarderNetworkList.Add(network);
                    }
                    ConnectPanelVisibility = Visibility.Visible;
                    UpdateStatusAsync("Scan complete. Please select a network to connect.", NotifyType.StatusMessage);
                }
                else
                {
                    UpdateStatusAsync("Scan complete. No WiFi networks found.", NotifyType.ErrorMessage);
                }
            }
        }
示例#48
0
        public WiFiNetworkDisplay(WiFiAvailableNetwork availableNetwork, WiFiAdapter adapter)
        {
            AvailableNetwork = availableNetwork;
            this.adapter = adapter;

        }
示例#49
0
        protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            ResultCollection = new ObservableCollection<WiFiNetworkDisplay>();
            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());
            if (result.Count >= 1)
            {
                firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);
            }
            foreach (var network in firstAdapter.NetworkReport.AvailableNetworks)
            {
                var networkDisplay = new WiFiNetworkDisplay(network, firstAdapter);
                await networkDisplay.UpdateConnectivityLevel();
                ResultCollection.Add(networkDisplay);
            }

            // sfdgNetList.DataContext = WiFiScan.WiFiNetworkDisplay;
            sfdgNetList.AllowSorting = true;
            sfdgNetList.AllowFiltering = true;
            sfdgNetList.RowHeight = 13;
   


            sfdgNetList.HeaderRowHeight = 30;
            sfdgNetList.AutoGenerateColumns = false;
            sfdgNetList.ItemsSource = ResultCollection;
            sfdgNetList.ColumnSizer = Syncfusion.UI.Xaml.Grid.GridLengthUnitType.Auto;
            sfdgNetList.Columns.Add(new GridTextColumn() { HeaderText = "SSID", MappingName = "Ssid" });
            sfdgNetList.Columns.Add(new GridTextColumn() { HeaderText = "BSSID", MappingName = "Bssid" });
            sfdgNetList.Columns.Add(new GridTextColumn() { HeaderText = "Channel", MappingName = "Channel" });
            sfdgNetList.Columns.Add(new GridTextColumn() { HeaderText = "RSSI", MappingName = "Rssi" });
            sfdgNetList.Columns.Add(new GridTextColumn() { HeaderText = "Security", MappingName = "SecuritySettings" });


            //Chart Stuff
            sfChartNetView24.Header = "Wi-Fi Networks";
            NumericalAxis primaryAxis = new Syncfusion.UI.Xaml.Charts.NumericalAxis();
            primaryAxis.Minimum = 0;
            primaryAxis.Maximum = 14;
            primaryAxis.Interval = 1;

            primaryAxis.Header = "Channels";

            sfChartNetView24.PrimaryAxis = primaryAxis;
            NumericalAxis SecondaryNumericalAxis = new Syncfusion.UI.Xaml.Charts.NumericalAxis();
            SecondaryNumericalAxis.Header = "Signal Strength";
            SecondaryNumericalAxis.Minimum = -100;
            SecondaryNumericalAxis.Maximum = -15;
            SecondaryNumericalAxis.Interval = 10;
            sfChartNetView24.SecondaryAxis = SecondaryNumericalAxis;

            ChartSeriesInput = new ObservableCollection<ChartHelperBssidNodeSeries>();
            ChartSeriesInput = HelperFunctions.ChartHelper(ResultCollection);

            foreach (ChartHelperBssidNodeSeries c in ChartSeriesInput)
            {

                SplineSeries mySeries = new SplineSeries();
                mySeries.ItemsSource = c.Series;
                mySeries.Label = "Home";
                mySeries.XBindingPath = "Channel";
                mySeries.YBindingPath = "Rssi";
                mySeries.StrokeThickness = 2;
                //mySeries.EnableAnimation = true;
                //mySeries.AnimationDuration = System.TimeSpan.FromSeconds(.2);
                sfChartNetView24.Series.Add(mySeries);

            }

            //Chart Stuff
            sfChartNetView52.Header = "Wi-Fi Networks";
            NumericalAxis primaryAxis52 = new Syncfusion.UI.Xaml.Charts.NumericalAxis();
            primaryAxis52.Minimum = 36;
            primaryAxis52.Maximum = 165;
            primaryAxis52.Interval = 2;
            primaryAxis52.IsTextScaleFactorEnabled = true;
            primaryAxis52.LabelsIntersectAction = AxisLabelsIntersectAction.Hide;
            primaryAxis.Header = "Channels";

            sfChartNetView52.PrimaryAxis = primaryAxis52;
            NumericalAxis SecondaryNumericalAxis52 = new Syncfusion.UI.Xaml.Charts.NumericalAxis();
            SecondaryNumericalAxis52.Header = "Signal Strength";
            SecondaryNumericalAxis52.Minimum = -100;
            SecondaryNumericalAxis52.Maximum = -15;
            SecondaryNumericalAxis52.Interval = 10;
            sfChartNetView24.SecondaryAxis = SecondaryNumericalAxis52;

            ChartSeriesInput = new ObservableCollection<ChartHelperBssidNodeSeries>();
            ChartSeriesInput = HelperFunctions.ChartHelper(ResultCollection);

            foreach (ChartHelperBssidNodeSeries c in ChartSeriesInput)
            {

                SplineSeries mySeries = new SplineSeries();
                mySeries.ItemsSource = c.Series;
                mySeries.Label = "Home";
                mySeries.XBindingPath = "Channel";
                mySeries.YBindingPath = "Rssi";
                mySeries.StrokeThickness = 2;
                //mySeries.EnableAnimation = true;
                //mySeries.AnimationDuration = System.TimeSpan.FromSeconds(.2);
                sfChartNetView52.Series.Add(mySeries);

            }

        }
        public async void GetNetworks()
        {
            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

            if (result.Count >= 1)
            {
                firstAdapter = await WiFiAdapter.FromIdAsync(result[0].Id);

                await firstAdapter.ScanAsync();

                deviceNetwork = firstAdapter.NetworkReport.AvailableNetworks.FirstOrDefault(N => N.Ssid == selectedDevice.GivenName); 

                var qualifyingWifi = firstAdapter.NetworkReport.AvailableNetworks.Where(N => !N.Ssid.ToLower().StartsWith("ioespt-thing"));

                foreach(var network in qualifyingWifi)
                {
                    networks.Add(network);
                }

                selectedNetwork = networks.FirstOrDefault();
            }
        }
 private void FirstAdapter_AvailableNetworksChanged(WiFiAdapter sender, object args)
 {
     DisplayNetworkReport(sender.NetworkReport, sender);
 }
        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");
            }
        }
示例#53
0
        public async Task<bool> ScanNetworks() {
            ShowProgress = Visibility.Visible;

            var access = await WiFiAdapter.RequestAccessAsync();

            if (access != WiFiAccessStatus.Allowed) {
                return false;
            }

            var result = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(WiFiAdapter.GetDeviceSelector());

            if (result.Count > 0) {
                _adapter = await WiFiAdapter.FromIdAsync(result[0].Id);
            }

            await _adapter.ScanAsync();

            foreach (var network in _adapter.NetworkReport.AvailableNetworks)  {
                Networks.Add(network);
            }

            Networks = new ObservableCollection<WiFiAvailableNetwork>(Networks.OrderByDescending(a => a.SignalBars));

            var storedNetworks = _setting.GetSetting<WifiNetworkSelectionItem>(SETTINGS.NETWORKS);

            if (storedNetworks != null) {
                SelectedNetworks = storedNetworks.Networks;
            }

            ShowProgress = Visibility.Collapsed;

            return true;
        }
 public WiFiNetworkDisplay(WiFiAvailableNetwork availableNetwork, WiFiAdapter adapter)
 {
     AvailableNetwork = availableNetwork;
     this.adapter = adapter;
     UpdateWiFiImage();
     UpdateConnectivityLevel();
 }