Exemple #1
0
        public async Task <string> SuggestNetwork()
        {
            string suggestionStatus = "";

            PermissionStatus status = await CrossPermissions.Current.CheckPermissionStatusAsync <LocationPermission>();

            if (status != PermissionStatus.Granted)
            {
                status = await CrossPermissions.Current.RequestPermissionAsync <LocationPermission>();
            }

            if (status == PermissionStatus.Granted)
            {
                // Get a handle to the Wifi
                var wifiMgr      = (WifiManager)context.GetSystemService(Context.WifiService);
                var wifiReceiver = new WifiReceiver(wifiMgr);

                await Task.Run(() =>
                {
                    // Start a suggestion and register the Broadcast receiver to get response
                    context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ActionWifiNetworkSuggestionPostConnection));
                    suggestionStatus = wifiReceiver.AddNetworkSuggestion();
                });
            }
            return(suggestionStatus);
        }
Exemple #2
0
        public async Task <List <WiFiInfo> > GetAvailableWifis(bool?GetSignalStrenth = false)
        {
            List <WiFiInfo> Wifis = null;

            PermissionStatus status = await CrossPermissions.Current.CheckPermissionStatusAsync <LocationPermission>();

            if (status != PermissionStatus.Granted)
            {
                status = await CrossPermissions.Current.RequestPermissionAsync <LocationPermission>();
            }

            if (status == PermissionStatus.Granted)
            {
                // Get a handle to the Wifi
                var wifiMgr      = (WifiManager)context.GetSystemService(Context.WifiService);
                var wifiReceiver = new WifiReceiver(wifiMgr);

                await Task.Run(() =>
                {
                    // Start a scan and register the Broadcast receiver to get the list of Wifi Networks
                    context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
                    Wifis = wifiReceiver.Scan();
                });
            }

            return(Wifis);
        }
        public void List()
        {
            WifiReceiver wifiReceiver = new WifiReceiver(Available);

            _context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
            _wifiManager.StartScan();
        }
        private void StartWifi()
        {
            _wifiScanning = true;

            var wifiManager = (WifiManager)GetSystemService(WifiService);

            _wasWifiEnabled = wifiManager.IsWifiEnabled;

            if (!wifiManager.IsWifiEnabled)
            {
                wifiManager.SetWifiEnabled(true);
            }

            _wifiReceiver = new WifiReceiver(wifiManager)
            {
                WifiScanned = () =>
                {
                    wifiManager.StartScan();

                    if (!_wifiScanning)
                    {
                        try { UnregisterReceiver(_wifiReceiver); }
                        catch { }
                    }
                }
            };
            RegisterReceiver(_wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
            wifiManager.StartScan();
        }
Exemple #5
0
        public static void Register()
        {
            wifi = (WifiManager)Android.App.Application.Context.GetSystemService(Context.WifiService);

            // Start a scan and register the Broadcast receiver to get the list of Wifi Networks
            wifiReceiver = new WifiReceiver();
            Android.App.Application.Context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
            wifi.StartScan();
        }
Exemple #6
0
        public void StartScanWiFi()
        {
            wifiReceiver = new WifiReceiver();
            IntentFilter intent = new IntentFilter(WifiManager.ScanResultsAvailableAction);

            intent.AddAction(WifiManager.NetworkStateChangedAction);

            Android.App.Application.Context.RegisterReceiver(wifiReceiver, intent);
            wifiManager.StartScan();
        }
 public static void InitWifiScan(Context ctx)
 {
     try
     {
         myWifiManager  = (WifiManager)ctx.GetSystemService(Context.WifiService);
         myWifiReceiver = new WifiReceiver();
     }
     catch (Exception ex)
     {
         AndroidLevelLogger.e(TAG, ex);
     }
 }
Exemple #8
0
        public async Task <IEnumerable <WifiSignal> > GetWifiSignals(CancellationToken cancellationToken = default)
        {
            IEnumerable <WifiSignal> signals = new List <WifiSignal>();
            var wifiReceiver = new WifiReceiver(_wifiManager);
            var intentFilter = new IntentFilter(WifiManager.ScanResultsAvailableAction);

            await Task.Run(() =>
            {
                _context.RegisterReceiver(wifiReceiver, intentFilter);
                signals = wifiReceiver.Scan();
            }, cancellationToken);

            return(signals);
        }
Exemple #9
0
        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);
            // Set our view from the "main" layout resource
            SetContentView(Resource.Layout.activity_main);

            if (!(ContextCompat.CheckSelfPermission(this, locationPermission) == (int)Permission.Granted))
            {
                ActivityCompat.RequestPermissions(this, new String[] { locationPermission, locationfinePermission, bluetoothPermission, bluetoothadminPermission, wifiPermission, changewifiPermission }, requestPermissions);
            }

            bluetoothAdapter.Enable();

            bluetoothAdapter.StartDiscovery();

            BluetoothDeviceReceiver bluetoothDeviceReceiver = new BluetoothDeviceReceiver();

            RegisterReceiver(bluetoothDeviceReceiver, new IntentFilter(BluetoothDevice.ActionFound));

            WifiManager wifiManager = (WifiManager)Android.App.Application.Context.GetSystemService(Android.Content.Context.WifiService);

            wifiManager.StartScan();

            WifiReceiver wifiReceiver = new WifiReceiver();

            RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));

            /*var networks = wifiManager.ConfiguredNetworks;
             * string wifi = "";
             *
             * for (int i = 0; i < networks.Count; i++)
             * {
             *  wifi = wifi + networks[i].Ssid + "\r\n";
             *  DisplayTextWifi(wifi);
             * }*/


            /*string networkSSID = "WIFI-GUEST";
             * string networkPass = "";
             *
             * WifiConfiguration wifiConfig = new WifiConfiguration();
             * wifiConfig.Ssid = string.Format("\"{0}\"", networkSSID);
             * wifiConfig.PreSharedKey = string.Format("\"{0}\"", networkPass);
             *
             * int netId = wifiManager.AddNetwork(wifiConfig);
             * wifiManager.Disconnect();
             * wifiManager.EnableNetwork(netId, true);
             * wifiManager.Reconnect();*/
        }
Exemple #10
0
        public static void GetWifiNetworks(Context context, Action <List <string> > wifis)
        {
            WiFiNetworks = new List <string>();

            // Get a handle to the Wifi
            wifi = (WifiManager)context.GetSystemService(Context.WifiService);

            // Start a scan and register the Broadcast receiver to get the list of Wifi Networks
            var wifiReceiver = new WifiReceiver((list) =>
            {
                wifis(list);
            });

            context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
            wifi.StartScan();
        }
        /// <summary>
        /// ScanForNetworks
        /// </summary>
        /// <returns></returns>
        private async Task ScanForNetworks()
        {
            await Task.Run(() =>
            {
                if (NetworkManager == null)
                {
                    NetworkManager = (WifiManager)CrossCurrentActivity.Current.Activity.GetSystemService(Context.WifiService);
                }

                NetworkReceiver           = new WifiReceiver(NetworkManager);
                IntentFilter intentFilter = new IntentFilter();
                intentFilter.AddAction(WifiManager.ScanResultsAvailableAction);
                CrossCurrentActivity.Current.Activity.RegisterReceiver(NetworkReceiver, intentFilter);
                NetworkManager.StartScan();
            });
        }
        public void getNetworks()
        {
            _done = false;
            var context = Android.App.Application.Context;

            if (context == null)
            {
                return;
            }

            wifi = (WifiManager)context.GetSystemService(Context.WifiService);
            if (!wifi.IsWifiEnabled)
            {
                wifi.SetWifiEnabled(true);
            }
            wifiReceiver = new WifiReceiver();
            context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
            wifi.StartScan();
        }
Exemple #13
0
        public async Task FindAccessPoints(ObservableCollection <AccessPoint> availableAccessPoints)
        {
            availableAccessPoints.Clear();

            var wifiManager = Android.App.Application.Context.GetSystemService(Context.WifiService) as WifiManager;

            if (wifiManager.IsWifiEnabled)
            {
                if (_WifiReceiver == null)
                {
                    _WifiReceiver = new WifiReceiver(this, availableAccessPoints);
                }
                Android.App.Application.Context.RegisterReceiver(_WifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
                wifiManager.StartScan();
            }
            else if (AccessPointsEnumeratedEvent != null)
            {
                AccessPointsEnumeratedEvent("Enumerated");
            }
        }
Exemple #14
0
        public async Task <IEnumerable <string> > GetAvailableNetworksAsync()
        {
            IEnumerable <string> availableNetworks = null;

            // Get a handle to the Wifi
            var wifiMgr      = (WifiManager)context.GetSystemService(Context.WifiService);
            var wifiReceiver = new WifiReceiver(wifiMgr);

            await Task.Run(() =>
            {
                // Start a scan and register the Broadcast receiver to get the list of Wifi Networks
                context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
                availableNetworks = wifiReceiver.Scan();
            });

            if (availableNetworks.Count() > 0)
            {
                //App.ListChanged?.Invoke(availableNetworks.ToList());
            }
            return(availableNetworks);
        }
        private void GetWifiNetworks()
        {
            wiFiNetworks = new List <WiFiNetwork>();

            // Get a handle to the Wifi
            wifi = (WifiManager)context.GetSystemService(Context.WifiService);

            // check wifi is not disabled
            if (wifi.WifiState != WifiState.Enabled)
            {
                Android.Widget.Toast.MakeText(this, "WiFi disabled, enabling wifi network...", Android.Widget.ToastLength.Short).Show();
                wifi.SetWifiEnabled(true);
                Task.Delay(3000);
            }

            // Start a scan and register the Broadcast receiver to get the list of Wifi Networks
            var wifiReceiver = new WifiReceiver();
            var wifiSignal   = new WiFiSignalChanged();

            context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction)); // list of networks changed
            //context.RegisterReceiver(wifiSignal, new IntentFilter(WifiManager.RssiChangedAction)); // signal strength changed
            wifi.StartScan();
        }
Exemple #16
0
 public NetworkInfoProvider(Context context)
 {
     _context     = context;
     WifiReceiver = new WifiReceiver();
     WifiReceiver.ScanFinished += WifiReceiver_ScanFinished;
 }
Exemple #17
0
        private void GetWifiNetworks()
        {
            if (!IsScanning)
            {
                if (RefreshTime < 10)
                {
                    Toast.MakeText(Android.App.Application.Context, "You have to set refresh time first!", ToastLength.Short).Show();
                }
                else
                {
                    IsScanning = true;
                    Toast.MakeText(Android.App.Application.Context, "Scanning has been started!", ToastLength.Short).Show();

                    var locator = CrossGeolocator.Current;
                    locator.DesiredAccuracy = 5;

                    var startTimeSpan  = TimeSpan.Zero;
                    var periodTimeSpan = TimeSpan.FromSeconds(RefreshTime);

                    timer = new Timer(async(e) =>
                    {
                        ListOfWifiNetworks.Clear();

                        wifiManager = (WifiManager)context.GetSystemService(Context.WifiService);
                        await locator.StartListeningAsync(TimeSpan.FromSeconds(1), 0.01, false, null);
                        var position = await locator.GetPositionAsync(TimeSpan.FromSeconds(20), null, true);

                        if (wifiManager.ConnectionInfo.NetworkId != -1 && wifiManager.ConnectionInfo.SSID != "UNKNOWNSSID")
                        {
                            CurrentWifiNetworkName   = wifiManager.ConnectionInfo.SSID;
                            CurrentWifiNetworkIP     = wifiManager.ConnectionInfo.IpAddress;
                            CurrentWifiNetworkIPText = Android.Text.Format.Formatter.FormatIpAddress(CurrentWifiNetworkIP);
                            CurrentWifiNetworkSpeed  = wifiManager.ConnectionInfo.LinkSpeed;
                        }
                        else
                        {
                            CurrentWifiNetworkName   = "-";
                            CurrentWifiNetworkIPText = "-";
                            CurrentWifiNetworkSpeed  = 0;
                        }

                        Latitude  = position.Latitude;
                        Longitude = position.Longitude;

                        wifiReceiver = new WifiReceiver();
                        context.RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
                        IsBusy = true;

                        wifiManager.StartScan();
                        CollectionofNetworksArrived.WaitOne();
                        context.UnregisterReceiver(wifiReceiver);
                        if (ListOfWifiNetworks.Count > 0)
                        {
                            DetectedWifiNetworks.Clear();
                            foreach (var item in ListOfWifiNetworks)
                            {
                                DetectedWifiNetworks.Add(item);
                            }
                        }
                        CollectionofNetworksArrived.Reset();
                        IsBusy = false;
                        if (AutoSaveToDatabase)
                        {
                            Device.BeginInvokeOnMainThread(async() =>
                            {
                                await SaveListToDatabase();
                            });
                        }
                        if (AutoSaveToFile)
                        {
                            Device.BeginInvokeOnMainThread(() =>
                            {
                                SaveListToFile();
                            });
                        }
                        NumberOfDetectedAccessPoints = DetectedWifiNetworks.Count;
                        await locator.StopListeningAsync();
                    }, null, startTimeSpan, periodTimeSpan);
                }
            }
            else
            {
                Toast.MakeText(Android.App.Application.Context, "Scanning has already started!", ToastLength.Short).Show();
            }
        }