Example #1
0
        public string GetIpAddress()
        {
            var wifiManager = WifiManager.FromContext(Application.Context);

            WifiInfo info = wifiManager.ConnectionInfo;

            return(wifiManager.IsWifiEnabled ? new IPAddress(info.IpAddress).ToString() : null);
        }
Example #2
0
 public Wifi()
 {
     Mvx.IoCProvider.CallbackWhenRegistered <IMvxAndroidGlobals>(() =>
     {
         var globals = Mvx.IoCProvider.Resolve <IMvxAndroidGlobals>();
         _manager    = WifiManager.FromContext(globals.ApplicationContext);
     });
 }
Example #3
0
        public int GetWifiSpeed()
        {
            var wifiManager = WifiManager.FromContext(Application.Context);

            WifiInfo info = wifiManager.ConnectionInfo;

            return(info.LinkSpeed);
        }
        private void ShowWifiPrompt()
        {
            var wifiManager = WifiManager.FromContext(this);
            var builder     = new AlertDialog.Builder(this);

            builder.SetTitle(Resource.String.wifi_reminder_title);
            builder.SetMessage(Resource.String.wifi_reminder_message);
            builder.SetPositiveButton(Resource.String.wifi_enable_now, (sender, args) => wifiManager.SetWifiEnabled(true));
            builder.SetNegativeButton(Resource.String.wifi_enable_later, (sender, args) => { });

            builder.Show();
        }
        public override void OnCreate()
        {
            base.OnCreate();

            this.disposable = new CompositeDisposable();

            this.wakeLock = PowerManager.FromContext(this).NewWakeLock(WakeLockFlags.Partial, "espera-wake-lock");
            this.wifiLock = WifiManager.FromContext(this).CreateWifiLock(WifiMode.Full, "espera-wifi-lock");

            NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected).Where(x => x)
            .Subscribe(x => this.NotifyNetworkMessengerConnected())
            .DisposeWith(this.disposable);

            NetworkMessenger.Instance.Disconnected.Subscribe(x => this.NotifyNetworkMessengerDisconnected())
            .DisposeWith(this.disposable);

            var userSettings = Locator.Current.GetService <UserSettings>();

            NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected).SampleAndCombineLatest(userSettings
                                                                                              .WhenAnyValue(x => x.Port).DistinctUntilChanged(), (connected, _) => connected)
            .Where(x => x)
            .Subscribe(x => NetworkMessenger.Instance.Disconnect())
            .DisposeWith(this.disposable);

            AndroidVolumeRequests.Instance.VolumeDown.CombineLatest(NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected),
                                                                    NetworkMessenger.Instance.WhenAnyValue(x => x.AccessPermission),
                                                                    (_, connected, permission) => connected && permission == NetworkAccessPermission.Admin)
            .Where(x => x)
            .SelectMany(_ => NetworkMessenger.Instance.GetVolume().ToObservable().SwallowNetworkExceptions())
            .Where(currentVolume => currentVolume > 0)
            .Select(currentVolume => Math.Max(currentVolume - 0.1f, 0))
            .Select(volume => NetworkMessenger.Instance.SetVolume(volume).ToObservable().SwallowNetworkExceptions())
            .Concat()
            .Subscribe()
            .DisposeWith(this.disposable);

            AndroidVolumeRequests.Instance.VolumeUp.CombineLatest(NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected),
                                                                  NetworkMessenger.Instance.WhenAnyValue(x => x.AccessPermission),
                                                                  (_, connected, permission) => connected && permission == NetworkAccessPermission.Admin)
            .Where(x => x)
            .SelectMany(_ => NetworkMessenger.Instance.GetVolume().ToObservable().SwallowNetworkExceptions())
            .Where(currentVolume => currentVolume < 1)
            .Select(currentVolume => Math.Min(currentVolume + 0.1f, 1))
            .Select(volume => NetworkMessenger.Instance.SetVolume(volume).ToObservable().SwallowNetworkExceptions())
            .Concat()
            .Subscribe()
            .DisposeWith(this.disposable);

            var androidSettings = Locator.Current.GetService <AndroidSettings>();

            NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected).CombineLatest(androidSettings.WhenAnyValue(x => x.SaveEnergy), (connected, saveEnergy) =>
            {
                if (connected && !saveEnergy)
                {
                    this.wakeLock.Acquire();
                    this.wifiLock.Acquire();
                }

                else if (!connected)
                {
                    this.ReleaseWakeLocks();
                }

                return(Unit.Default);
            })
            .Subscribe()
            .DisposeWith(this.disposable);
        }