/// <summary> /// On create simply detect some of our managers /// </summary> public override void OnCreate() { base.OnCreate(); //Find our audio and notificaton managers audioManager = (AudioManager)GetSystemService(AudioService); wifiManager = (WifiManager)GetSystemService(WifiService); remoteComponentName = new ComponentName(PackageName, new RemoteControlBroadcastReceiver().ComponentName); }
/// <summary> /// On create simply detect some of our managers /// </summary> public override void OnCreate() { base.OnCreate(); //Find our audio and notificaton managers AudioManager = (AudioManager) GetSystemService(AudioService); wifiManager = (WifiManager) GetSystemService(WifiService); }
private static void EnsureDifferentNetworksNotActive(WifiManager wifiManager, WifiConfiguration network) { var differentActiveNetwork = wifiManager.ConfiguredNetworks .Where(x => x.Ssid != network.Ssid) .FirstOrDefault(x => x.StatusField == WifiStatus.Current); if (differentActiveNetwork != null) throw new InvalidOperationException($"Different network {differentActiveNetwork.Ssid} is active"); }
public Wifi() { Mvx.CallbackWhenRegistered<IMvxAndroidGlobals>(x => { _manager = x.ApplicationContext.GetSystemService(Context.WifiService) .JavaCast<WifiManager>(); }); }
/// <summary> Get existing matching network </summary> private static WifiConfiguration GetConfiguredNetwork(WifiManager wifiManager, Ssid ssid) { var existingNetwork = wifiManager.ConfiguredNetworks .FirstOrDefault(x => x.Ssid == ssid.Quoted); Logger.Verbose(existingNetwork != null ? $"Found existing network {ssid}" : $"Existing network {ssid} not found"); if (existingNetwork == null) throw new InvalidOperationException($"Network {ssid} not configured"); return existingNetwork; }
public override void OnCreate () { base.OnCreate (); _episodeProgressUpdateTimer = new Timer ( o => UpdateEpisodeCurrentTimeIfPlaying(), null, 0, EPISODE_CURRENT_TIME_UPDATE_INTERVAL ); // Find our audio and notificaton managers _audioManager = (AudioManager)GetSystemService (AudioService); _wifiManager = (WifiManager)GetSystemService (WifiService); }
public cTestInet(Context c) { m_Contexto = c; m_ConexionINet = false; m_TipoConexion = enumTipoConexion.SINCONEXION; m_NombreConexion = string.Empty; m_VelocidadSubidaReal = 0d; m_VelocidadSubidaTeorica = 0d; m_VelocidadBajadaReal = 0d; m_VelocidadBajadaTeorica = 0d; m_GsmSignalStrengthListener = new GsmSignalStrengthListener(); m_GsmSignalStrengthListener.SignalStrengthChanged += HandleSignalStrengthChanged; m_TelefonoManager = (TelephonyManager) m_Contexto.GetSystemService(Context.TelephonyService); m_TelefonoManager.Listen(m_GsmSignalStrengthListener, PhoneStateListenerFlags.SignalStrengths); m_ConnectivityManager = (ConnectivityManager) m_Contexto.GetSystemService(Context.ConnectivityService); m_WifiManager = (WifiManager) m_Contexto.GetSystemService(Context.WifiService); }
private static void Reconnect(WifiManager wifiManager) { if (!wifiManager.Reconnect()) throw new InvalidOperationException("Reconnection failed"); }
/// <summary> /// Dispose /// </summary> /// <param name="disposing"></param> public override void Dispose(bool disposing) { if (!disposed) { if (disposing) { if (receiver != null) Application.Context.UnregisterReceiver(receiver); ConnectivityChangeBroadcastReceiver.ConnectionChanged = null; if (wifiManager != null) { wifiManager.Dispose(); wifiManager = null; } if (connectivityManager != null) { connectivityManager.Dispose(); connectivityManager = null; } } disposed = true; } base.Dispose(disposing); }
private void finallyConnect(string networkPass, string networkSSID) { try { using (Android.Net.Wifi.WifiManager wifi = (Android.Net.Wifi.WifiManager)ApplicationContext.GetSystemService(Context.WifiService)) { if (wifi != null && wifi.IsWifiEnabled) { using (WifiConfiguration wifiConfig = new WifiConfiguration()) { wifiConfig.Ssid = "\"" + networkSSID + "\""; //string.Format("\"%s\"", networkSSID); wifiConfig.PreSharedKey = "\"" + networkPass + "\""; // string.Format("\"%s\"", networkPass); int netId = wifi.AddNetwork(wifiConfig); wifi.Disconnect(); wifi.EnableNetwork(netId, true); wifi.Reconnect(); using (WifiConfiguration conf = new WifiConfiguration()) { conf.Ssid = "\"" + networkSSID + "\""; conf.PreSharedKey = "\"" + networkPass + "\""; wifi.AddNetwork(conf); } } } } } catch { } }
public IPAddress GetBroadcastAddress(WifiManager wifi) { var dhcp = wifi.DhcpInfo; var broadcast = (dhcp.IpAddress & dhcp.Netmask) | ~dhcp.Netmask; var quads = new byte[4]; for (var k = 0; k < 4; k++) quads[k] = (byte)((broadcast >> k * 8) & 0xFF); return new IPAddress(quads); }
public NetworkInterface() { var context = Application.Context.ApplicationContext; wifi = (WifiManager)context.GetSystemService(Context.WifiService); }
/* * Create Method * Fires when the activity is started */ protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); //setting the main layout Main.xml SetContentView(Resource.Layout.Main); //Getting telephony and wifi information from the system service telephonyManager = (TelephonyManager)this.GetSystemService(Context.TelephonyService); wifiManager= (WifiManager)this.GetSystemService(Service.WifiService); //Declaring the command ubttons var cmd_SensorStatus = FindViewById<Button> (Resource.Id.sensorStatusButton); var cmd_Calculate = FindViewById<Button> (Resource.Id.cmdCalculate); //Adding text view by id _deviceIdTextView = FindViewById<TextView> (Resource.Id.textDeviceID); batteryStatusTextView = FindViewById<TextView> (Resource.Id.textBatteryStatus); batteryLevelTextView = FindViewById<TextView> (Resource.Id.textBatteryLevel); batteryVoltageTextView = FindViewById<TextView> (Resource.Id.textBatteryVoltage); batteryTemperatureTextView = FindViewById<TextView> (Resource.Id.textBatteryTemperature); batteryTechnologyTextView = FindViewById<TextView> (Resource.Id.textBatteryTechnology); _IpTextView = FindViewById<TextView> (Resource.Id.textIP); //Adding text to the text views from device information _deviceIdTextView.Text = telephonyManager.DeviceId.ToString (); //Registering battery related information registerBatteryLevelReceiver(); device_ID = _deviceIdTextView.Text; device_Info = Build.Manufacturer.ToString ()+ " " + Build.Model.ToString (); batteryStatusTextView.Text = battery_status; batteryLevelTextView.Text = battery_level.ToString(); batteryVoltageTextView.Text = battery_voltage.ToString(); batteryTemperatureTextView.Text = battery_temperature.ToString(); batteryTechnologyTextView.Text = battery_Technology; //locationInfo = telephonyManager.CellLocation.ToString (); //Getting localip address int ip = wifiManager.ConnectionInfo.IpAddress; _IpTextView.Text = string.Format("{0}.{1}.{2}.{3}",(ip & 0xff),(ip >> 8 & 0xff),(ip >> 16 & 0xff),(ip >> 24 & 0xff)); //Adding even listeners buttons cmd_SensorStatus.Click += (object sender, EventArgs e) => {sensorStatusButtonClick();}; cmd_Calculate.Click += (object sender, EventArgs e) => {calculateButtonClick();}; }
protected override void OnResume() { try { string status = "WIFI NETWORKS: "; string SSID = ""; using (Android.Net.Wifi.WifiManager wifi = (Android.Net.Wifi.WifiManager)ApplicationContext.GetSystemService(Context.WifiService)) { if (wifi != null) { if (wifi.IsWifiEnabled) { using (WifiInfo wifiInfo = wifi.ConnectionInfo) { if (wifiInfo != null) { using (NetworkInfo.DetailedState state = WifiInfo.GetDetailedStateOf(wifiInfo.SupplicantState)) { if (state == NetworkInfo.DetailedState.Connected || state == NetworkInfo.DetailedState.ObtainingIpaddr) { SSID = wifiInfo.SSID; } } } } } else { wifi.SetWifiEnabled(true); } using (ConnectivityManager cm = (ConnectivityManager)GetSystemService(Context.ConnectivityService)) { if (cm != null) { using (NetworkInfo activeNetwork = cm.ActiveNetworkInfo) { if (activeNetwork != null && activeNetwork.IsConnected) { SSID = SSID.Replace("\"", ""); status = ": CONNECTED TO INTERNET. Select a network from the list below to modify or establish a connection."; status = SSID + status; } else { if (activeNetwork == null) { status = "WIFI NETWORKS: "; } else { if (!string.IsNullOrEmpty(SSID)) { status = " OBTAINING IP ADDRESS..."; status = SSID + status; } else { status = "WIFI NETWORKS: ATTEMPTING CONNECTION..."; } } } } } } IList\\ wifiScanList = wifi.ScanResults; if (wifiScanList != null) { wifis = new string[wifiScanList.Count]; for (int i = 0; i \ { wifis[i] = ((wifiScanList[i]).ToString()); } filtered = new List\\(); filtered.Add(status); int counter = 0; foreach (string eachWifi in wifis) { var rx = new string[] { "," }; string[] temp = eachWifi.Split(rx, StringSplitOptions.None); string lval = temp[0].Substring(5).Trim(); if (!string.IsNullOrEmpty(lval) && lval.Length \>\ 3) { filtered.Add(lval); counter++; } } } } } ListAdapter = new MyListAdapter(this); } catch (Exception) { } base.OnResume(); }
private void connectToWifi(string wifiSSID) { String SSID = ""; bool connected = false; bool hasEverConnected = false; int NetworkId = 0; try { using (Android.Net.Wifi.WifiManager wifi = (Android.Net.Wifi.WifiManager)context.ApplicationContext.GetSystemService(Context.WifiService)) { if (wifi != null && wifi.IsWifiEnabled) { using (WifiInfo wifiInfo = wifi.ConnectionInfo) { if (wifiInfo != null) { using (NetworkInfo.DetailedState state = WifiInfo.GetDetailedStateOf(wifiInfo.SupplicantState)) { if (state == NetworkInfo.DetailedState.Connected || state == NetworkInfo.DetailedState.ObtainingIpaddr) { SSID = wifiInfo.SSID.Replace("\"", "").Trim(); SSID = SSID.Replace(" ", ""); if (SSID == wifiSSID.Trim().Replace(" ", "")) { connected = true; } } } } } IList\\ wifiScanList = wifi.ConfiguredNetworks; for (int i = 0; i \ { if (((wifiScanList[i]).ToString()).Contains("hasEverConnected: true")) { String cw = wifiScanList[i].Ssid.Replace("\"", "").Trim(); cw = cw.Replace(" ", ""); if (cw == wifiSSID.Trim().Replace(" ", "")) { NetworkId = wifiScanList[i].NetworkId; hasEverConnected = true; break; } } } } } } catch (Exception e) { } var nxact = new Intent(Application.Context, typeof(ConnectActivity)); nxact.PutExtra("SSID", wifiSSID); nxact.PutExtra("connected", connected); nxact.PutExtra("hasEverConnected", hasEverConnected); nxact.PutExtra("NetworkId", NetworkId); context.StartActivity(nxact); activity.Finish(); }
/// <summary> /// Polls the network state, setting the flags appropriately. /// </summary> private void PollNetworkState() { if (this.connectivityManager == null) { this.connectivityManager = this.GetSystemService(ConnectivityService).JavaCast<ConnectivityManager>(); } if (this.wifiManager == null) { this.wifiManager = this.GetSystemService(WifiService).JavaCast<WifiManager>(); } if (this.connectivityManager == null) { Log.Debug(Tag,"LVLDL couldn't get connectivity manager to poll network state"); } else { NetworkInfo activeInfo = this.connectivityManager.ActiveNetworkInfo; this.UpdateNetworkState(activeInfo); } }
public WifiReceiver(WifiManager manager) { _wifiManager = manager; }
private static void EnsureNetworkReachable(WifiManager wifiManager, Ssid ssid) { if (wifiManager.ScanResults.All(x => x.Ssid != ssid.Original)) throw new InvalidOperationException($"Network {ssid} is unreachable"); }
public IPAddress GetBroadcastAddress(WifiManager wifi) { DhcpInfo dhcp; try { dhcp = wifi.DhcpInfo; } catch (Java.Lang.SecurityException e) { Debug.WriteLine("Could not obtain Wifi information: {0}. Did you enable ACCESS_WIFI_STATE permission in your app manifest?", e.Message); return null; } var broadcast = (dhcp.IpAddress & dhcp.Netmask) | ~dhcp.Netmask; var quads = new byte[4]; for (var k = 0; k < 4; k++) quads[k] = (byte)((broadcast >> k * 8) & 0xFF); return new IPAddress(quads); }
protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); RequestWindowFeature(WindowFeatures.NoTitle); SetContentView(Resource.Layout.nconnect); Bundle extras = Intent?.Extras; if (extras == null) { Finish(); return; } string SSID = extras.GetString("SSID", ""); bool connected = extras.GetBoolean("connected", false); bool hasEverConnected = extras.GetBoolean("hasEverConnected", false); int NetworkId = extras.GetInt("NetworkId", 0); if (string.IsNullOrEmpty(SSID)) { Finish(); return; } Button ok = (Button)FindViewById(Resource.Id.okButton); Button forgetButton = (Button)FindViewById(Resource.Id.forgetButton); TextView pass = (TextView)FindViewById(Resource.Id.textviewPassword); if (!hasEverConnected) { forgetButton.Text = "RETURN"; } if (connected) { ok.Text = "(CONNECTED)"; ok.SetBackgroundResource(Resource.Color.black); ok.Enabled = false; } if (hasEverConnected || connected) { pass.Text = "***********"; pass.Enabled = false; } else { LoadBClicks(); } ok.Click += delegate { if (hasEverConnected) { try { using (Android.Net.Wifi.WifiManager wifi = (Android.Net.Wifi.WifiManager)ApplicationContext.GetSystemService(Context.WifiService)) { if (wifi != null && wifi.IsWifiEnabled) { wifi.Disconnect(); wifi.EnableNetwork(NetworkId, true); wifi.Reconnect(); } } } catch { } } else { finallyConnect(pass.Text, SSID); } Finish(); }; forgetButton.Click += delegate { try { using (Android.Net.Wifi.WifiManager wifi = (Android.Net.Wifi.WifiManager)ApplicationContext.GetSystemService(Context.WifiService)) { if (wifi != null && wifi.IsWifiEnabled) { if (hasEverConnected) { wifi.RemoveNetwork(NetworkId); } } } } catch { } Finish(); }; }
private static bool IsConnectedToNetwork(WifiManager wifiManager, Ssid ssid) { return wifiManager.IsWifiEnabled && wifiManager.ConnectionInfo != null && wifiManager.ConnectionInfo.SSID == ssid.Quoted; }
private static void EnsureWifiEnabled(WifiManager wifiManager) { if (!wifiManager.IsWifiEnabled) throw new InvalidOperationException("Wifi is disabled"); }
private static bool IsCompletelyConnected(WifiManager wifiManager, WifiConfiguration network) { return wifiManager.WifiState == WifiState.Enabled && wifiManager.ConnectionInfo.SSID == network.Ssid && wifiManager.ConnectionInfo.SupplicantState == SupplicantState.Completed && wifiManager.DhcpInfo.IpAddress > 0; }
public int ActivateNetwork(int networkCode) { if (networkCode == 0) { //Turn on mobile data return 0; } else if (networkCode == 1) { wifi = (WifiManager)GetSystemService (WifiService); wifi.SetWifiEnabled (true); return 1; } return -1; }
private static void ActivateNetwork(WifiManager wifiManager, WifiConfiguration network) { if (!wifiManager.EnableNetwork(network.NetworkId, true)) throw new InvalidOperationException($"Can't enable network {network.Ssid}"); }
/// <summary> /// OnCreate() detects some of our managers /// </summary> public override void OnCreate() { Log.Debug(TAG, "StreamingService.OnCreate()"); base.OnCreate(); audioManager = (AudioManager)GetSystemService(AudioService); wifiManager = (WifiManager)GetSystemService(WifiService); headphonesUnpluggedReceiver = new MusicBroadcastReceiver(); if (Android.OS.Build.VERSION.SdkInt >= BuildVersionCodes.Lollipop) { mediaSession = new MediaSession(this, "KVMRMediaSession"); mediaCallback = new MediaSessionCallback(); mediaCallback.OnPlayImpl = () => { if (IsPlaying) { Log.Debug(TAG, "MediaCallback stop playing"); Stop(); MessagingCenter.Send<PlayerStoppedMessage>(new PlayerStoppedMessage(), "PlayerStopped"); } else { Log.Debug(TAG, "MediaCallback start playing. source: " + source ?? "null"); Play(source); MessagingCenter.Send(new RemoteControlPlayMessage(), "RemoteControlPlay"); } }; mediaSession.SetCallback(mediaCallback); mediaSession.SetFlags(MediaSessionFlags.HandlesMediaButtons | MediaSessionFlags.HandlesTransportControls); PlaybackState state = new PlaybackState.Builder() .SetActions(PlaybackState.ActionPlay | PlaybackState.ActionPlayPause | PlaybackState.ActionPause | PlaybackState.ActionStop) .Build(); mediaSession.SetPlaybackState(state); mediaSession.Active = true; } }
private static async Task<ConnectionResult> WaitUntilConnectedAsync(WifiManager wifiManager, WifiConfiguration network, TimeSpan checkInterval, TimeSpan timeout) { // TODO: Get notified when network is active instead of looping and sleeping if (timeout != TimeSpan.Zero) { if (checkInterval == TimeSpan.Zero) { if (timeout.TotalMilliseconds > 0) await Task.Delay(timeout); } else { var startTime = DateTime.Now; while (DateTime.Now - startTime < timeout) { if (IsCompletelyConnected(wifiManager, network)) return ConnectionResult.Connected; await Task.Delay(TimeSpan.FromMilliseconds(100)); } } } if (IsCompletelyConnected(wifiManager, network)) return ConnectionResult.Connected; return ConnectionResult.NotYetConnected; }