public void OnAvailableWifiButtonClick(object sender, System.EventArgs e)
{
if (!Utils.HasPermission(ApplicationContext, Utils.ePermission.WifiPermission))
{
Toast.MakeText(ApplicationContext, "Application requires permission to Wi-Fi.", ToastLength.Long).Show();
RequestPermissions(Utils.RequiredWifiPermissions, 0);
}
else
{
if (!wifiManager.IsWifiEnabled)
{
Toast.MakeText(ApplicationContext, "Turning WiFi ON...", ToastLength.Long).Show();
wifiManager.SetWifiEnabled(true);
}
if (!Utils.HasPermission(ApplicationContext, Utils.ePermission.LocationPermission))
{
var GetPermissions = Utils.GetPermissions();
}
else
{
if (wifiReceiver == null)
{
wifiReceiver = new WifiReceiver(wifiManager, wifiList, ApplicationContext, passwordText, connectButton);
}
textMessage.Visibility = ViewStates.Invisible;
Toast.MakeText(ApplicationContext, "Searching for Wi-fi...", ToastLength.Long).Show();
RegisterReceiver(wifiReceiver, new IntentFilter(WifiManager.ScanResultsAvailableAction));
wifiManager.StartScan();
}
}
}
//public void CreateAutoHotspot()
//{
// try
// {
// //if (!_wifiManager.IsWifiEnabled)
// //{
// // OnError?.Invoke(new Exception("Wireless network adapter is disabled"));
// // return;
// //}
// // if WiFi is on, turn it off
// if (IsHotspotEnabled)
// {
// _wifiManager.SetWifiEnabled(false);
// }
// Device.BeginInvokeOnMainThread(() => {
// //_wifimanager.AddOrUpdatePasspointConfiguration(p);
// //var callback = new WifiManager.LocalOnlyHotspotCallback();
// _wifiManager.StartLocalOnlyHotspot(null,
// new Handler((m) =>
// {
// var d = m;
// }));
// });
// //Method setWifiApEnabledMethod = _wifimanager.Class.GetMethod("setWifiApEnabled", wificonfiguration.Class, Java.Lang.Boolean.Type);
// //setWifiApEnabledMethod.Invoke(_wifimanager, wificonfiguration, !IsHotspotEnabled);
// OnLog?.Invoke("LocalOnlyHostSpot has been requested");
// }
// catch (Exception ex)
// {
// OnError?.Invoke(new Exception("HotspotCreator can not create a hotspot network", ex));
// }
//}
public void CreateHotspot(string ssid, string preSharedPassword)
{
WifiConfiguration wificonfiguration = GetWifiApConfiguration();
//wificonfiguration = new WifiConfiguration();
wificonfiguration.HiddenSSID = false;
wificonfiguration.Ssid = ssid;
wificonfiguration.Bssid = ssid;
wificonfiguration.PreSharedKey = preSharedPassword;
SetWifiApConfiguration(wificonfiguration);
//wificonfiguration.
try
{
// if WiFi is on, turn it off
if (IsHotspotEnabled)
{
_wifiManager.SetWifiEnabled(false);
}
//var setWifiApEnabledMethod = _wifimanager.Class.GetMethod("setWifiApEnabled", wificonfiguration.Class, Java.Lang.Boolean.Type);
var setWifiApEnabledMethod = _wifiManager.Class.GetMethods().FirstOrDefault(m => m.Name == "setWifiApEnabled");
setWifiApEnabledMethod.Invoke(_wifiManager, wificonfiguration, true);
OnLog?.Invoke("HostSpot has been created");
}
catch (Exception ex)
{
OnError?.Invoke(new Exception("HotspotCreator can not create a hotspot network", ex));
}
}
private async void HatchingButtonClick(object sender, EventArgs e)
{
cts = new CancellationTokenSource();
if (startButton.Text == GetString(Resource.String.start))
{
try
{
Task myTask = StartHatchingAsync(cts.Token);
startButton.Text = GetString(Resource.String.stop);
startButton.SetBackgroundColor(Android.Graphics.Color.Red);
await myTask;
}
catch (OperationCanceledException)
{
startButton.Text = GetString(Resource.String.start);
startButton.SetBackgroundColor(Android.Graphics.Color.Green);
}
}
else if (startButton.Text == GetString(Resource.String.stop) && cts != null)
{
cts.Cancel();
wm.SetWifiEnabled(true);
startButton.Text = GetString(Resource.String.start);
startButton.SetBackgroundColor(Android.Graphics.Color.Green);
}
}
public static void ToggleWiFi(bool OnOff)
{
if (OnOff)
{
WifiMan.SetWifiEnabled(true);
}
else
{
WifiMan.SetWifiEnabled(false);
}
}
public IEnumerable <string> GetSsids()
{
if (LastScanRequest.AddSeconds(SCAN_COOLDOWN) < DateTime.Now)
{
if (WifiManager.IsWifiEnabled == false)
{
WifiManager.SetWifiEnabled(true);
}
WifiManager.StartScan();
LastScanRequest = DateTime.Now.AddSeconds(SCAN_COOLDOWN);
}
return(WifiManager.ScanResults.Select(f => f.Ssid));
}
public string TurnOnWifi()
{
string isTurned = string.Empty;
if (wifiManager.IsWifiEnabled)
{
isTurned = "WIFI UŽ JE ZAPNUTÉ";
}
else
{
wifiManager.SetWifiEnabled(true);
isTurned = "WIFI JE ZAPNUTÉ";
}
return(isTurned);
}
public override bool OnOptionsItemSelected(IMenuItem item)
{
Toast.MakeText(this, "Action selected: " + item.TitleFormatted, ToastLength.Short).Show();
switch (item.ItemId)
{
case Resource.Id.menu_refresh:
UpdateHeartView();
WifiManager wm = (WifiManager)GetSystemService(Context.WifiService);
wm.SetWifiEnabled(!wm.IsWifiEnabled);
break;
case Resource.Id.menu_reset:
CreateAlert(
"Reset Data",
"Are you sure you want to reset all tracking data?",
"Yes",
(object sender, DialogClickEventArgs args) => { tsumTsumDatabaseManager.ClearDatabase(); UpdateHeartView(); },
"No",
(object sender, DialogClickEventArgs args) => { } // Deliberately empty!
);
break;
case Resource.Id.menu_settings:
StartActivity(new Intent(this, Java.Lang.Class.FromType(typeof(SettingsActivity))));
break;
}
return(base.OnOptionsItemSelected(item));
}
public async void ChceckNetwork() // sprawdzanie mozliwosci ONLINE i ew wejscie w ustawienia
{
await Task.Delay(400);
ZmienKolor();
if (!isOnline)
{
AlertDialog.Builder build = new AlertDialog.Builder(this);
AlertDialog alerNet = build.Create();
alerNet.SetCancelable(false);
alerNet.SetTitle("Warning!");
alerNet.SetMessage("Internet jest wymagany");
alerNet.SetButton("Włacz wifi", (s, ev) =>
{
wifiManager = (WifiManager)GetSystemService(WifiService);
wifiManager.SetWifiEnabled(true);
});
alerNet.SetButton2("Włacz dane komorkowe", (s, ev) =>
{
var intent = new Intent(Android.Provider.Settings.ActionSettings);
StartActivity(intent);
});
alerNet.Show();
}
}
protected override void OnCreate(Bundle bundle)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
//--android specific
WifiManager wifiManager = (WifiManager)GetSystemService(WifiService);
if (!wifiManager.IsWifiEnabled)
{
//attept to turn on wifi // dependant on wifi state change and internet in manifest file
wifiManager.SetWifiEnabled(true);
}
this.Window.SetFlags(WindowManagerFlags.KeepScreenOn, WindowManagerFlags.KeepScreenOn);// dependant on wake lock in manifest file
//--
// Xamarin.Forms.DependencyService.Register<MainActivity>();
//--
global::Xamarin.Forms.Forms.Init(this, bundle);
Xamarin.FormsGoogleMaps.Init(this, bundle); // initialize for Xamarin.Forms.GoogleMaps
LoadApplication(new App());
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.wifilayout);
scanbtn = FindViewById <Button>(Resource.Id.button1);
lstview = FindViewById <ListView>(Resource.Id.listView1);
wifimanager = (WifiManager)GetSystemService(Context.WifiService);
var permissionCheck = ContextCompat.CheckSelfPermission(this, Manifest.Permission.AccessWifiState);
if (permissionCheck != (int)Permission.Granted)
{
ActivityCompat.RequestPermissions(this, new String[] { Manifest.Permission.ChangeWifiState }, REQUEST_READ_PHONE_STATE);
}
else
{
//TODO
}
if (wifimanager.IsWifiEnabled == false)
{
Toast.MakeText(this, "WiFi is disabled.Enabling it", ToastLength.Long).Show();
wifimanager.SetWifiEnabled(true);
}
scanbtn.Click += delegate
{
wifiscan();
};
}
public void OnCreateNetworkButtonClick(object sender, System.EventArgs e)
{
if (localHotspot == null)
{
if (!Utils.HasPermission(ApplicationContext, Utils.ePermission.HotSpotPermission))
{
Toast.MakeText(ApplicationContext, "Application requires some HotSpotPermissions!.", ToastLength.Long).Show();
RequestPermissions(Utils.RequiredHotSpotPermissions, 0);
return;
}
if (!Utils.HasPermission(ApplicationContext, Utils.ePermission.LocationPermission))
{
var GetPermissions = Utils.GetPermissions();
}
else
{
buttonCreateHotspot.Visibility = ViewStates.Invisible;
textMessage.Text = Utils.PleaseWaitMessage;
if (wifiManager.IsWifiEnabled)
{
wifiManager.SetWifiEnabled(false);
}
localHotspot = new LocalHotspot(ApplicationContext);
localHotspot.SetNetworkState(true);
}
}
else
{
localHotspot.SetNetworkState(false);
localHotspot = null;
}
}
public void Scan()
{
while (true)
{
try
{
if (!wifiManager.IsWifiEnabled)
{
wifiManager.SetWifiEnabled(true);
}
if (wifiManager.WifiState != Android.Net.WifiState.Enabled)
{
throw new Exception("Please enable wi-fi.");
}
wifiManager.StartScan();
}
catch (Exception e)
{
// Console.WriteLine(e.Message);
}
finally
{
Task.Delay(500).Wait();
}
}
}
protected override void OnDestroy()
{
base.OnDestroy();
if (wifiManager.IsWifiEnabled)
{
wifiManager.SetWifiEnabled(false);
}
}
/// <summary>
/// Включение Wi-Fi
/// </summary>
private void TurnOnWiFi()
{
WifiManager wifiManager = (WifiManager)Android.App.Application.Context.GetSystemService(Context.WifiService);
if (!wifiManager.IsWifiEnabled)
{
// Active Wi-Fi connection.
wifiManager.SetWifiEnabled(true);
}
}
private void checkInternetConnection()
{
ConnectivityManager connectivityManager = (ConnectivityManager)GetSystemService(ConnectivityService);
wifiManager = (WifiManager)this.GetSystemService(Context.WifiService);
bool wifiEnabled = wifiManager.IsWifiEnabled;
if (!wifiEnabled)
{
Toast.MakeText(this, "Turning on wifi", ToastLength.Short).Show();
wifiManager.SetWifiEnabled(true);
}
}
private static bool TryTurnOnWifi(Context context)
{
WifiManager wifiManager = (WifiManager)context.GetSystemService(Context.WifiService);
if (wifiManager == null)
{
return(false);
}
if (!wifiManager.IsWifiEnabled)
{
wifiManager.SetWifiEnabled(true);
}
return(wifiManager.IsWifiEnabled);
}
public int CheckWIFI()
{
WifiManager wifi = (WifiManager)context.GetSystemService(Context.WifiService);
if (wifi != null)
{
if (wifi.WifiState == Android.Net.WifiState.Disabled)
{
wifi.SetWifiEnabled(true);
}
if (wifi.WifiState == Android.Net.WifiState.Enabling)
{
return(1);
}
else if (wifi.WifiState != Android.Net.WifiState.Enabled)
{
return(0);
}
}
else
{
return(0);
}
ConnectivityManager conn = (ConnectivityManager)context.GetSystemService(Context.ConnectivityService);
if (conn != null)
{
NetworkInfo networkInfo = conn.ActiveNetworkInfo;
if (networkInfo == null)
{
return(0);
}
if (networkInfo.GetState() == NetworkInfo.State.Connecting)
{
return(1);
}
else if (networkInfo.GetState() != NetworkInfo.State.Connected)
{
return(0);
}
}
else
{
return(0);
}
return(2);
}
private Task <bool> EnableWifi()
{
var source = new TaskCompletionSource <bool>();
if (!_manager.IsWifiEnabled)
{
_manager.SetWifiEnabled(true);
WaitForWifiEnabled().ContinueWith(_ => source.SetResult(true));
}
else
{
source.SetResult(true);
}
return(source.Task);
}
protected override void OnCreate(Bundle savedInstanceState)
{
OnCreateBase(savedInstanceState);
CreateNotificationChannel();
_wifiManager = (WifiManager)GetSystemService(WifiService);
if (_wifiManager.IsWifiEnabled == false)
{
_wifiManager.SetWifiEnabled(true);
}
_receiverWifi = new WifiScanReceiver(_wifiManager);
RegisterReceiver(_receiverWifi, new IntentFilter(WifiManager.ScanResultsAvailableAction));
_wifiManager.StartScan();
}
// private bool mIsConnected;
/// <summary>
/// Entry point for application. Initializes all widgets and sets the
/// font to them. Turns on wifi it is turned off.
/// Calls CreateApplicationFolder() and RefreshWifiList().
/// </summary>
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.Main);
// Create font
var font = Typeface.CreateFromAsset(Assets, "SourceSansPro-Light.ttf");
// Initialize widgets
mTvHeader = FindViewById <TextView>(Resource.Id.tvHeader);
mTvWifiName = FindViewById <TextView>(Resource.Id.tvWifiName);
mTvWifiMac = FindViewById <TextView>(Resource.Id.tvWifiMac);
mTvFooter = FindViewById <TextView>(Resource.Id.tvFooter);
mBtnConnect = FindViewById <Button>(Resource.Id.btnConnect);
mBtnShowLogs = FindViewById <Button>(Resource.Id.btnShowLogs);
mBtnHelp = FindViewById <Button>(Resource.Id.btnHelp);
// Set font to widgets
mTvHeader.Typeface = font;
mTvWifiName.Typeface = font;
mTvWifiMac.Typeface = font;
mTvFooter.Typeface = font;
mBtnConnect.Typeface = font;
mBtnShowLogs.Typeface = font;
mBtnHelp.Typeface = font;
// Disable Connect button while searching for connection
mBtnConnect.Enabled = false;
// Add events to buttons
mBtnConnect.Click += OnConnect;
mBtnShowLogs.Click += OnShowLogFiles;
mBtnHelp.Click += OnHelp;
mLastConnectedPeer = "";
// mIsConnected = false;
// Turn on wifi if it is turned off
WifiManager wm = GetSystemService(WifiService).JavaCast <WifiManager>();
if (wm.IsWifiEnabled == false)
{
wm.SetWifiEnabled(true);
}
CreateApplicationFolder();
RefreshWifiList();
}
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);
}
public void UpdateUI(Intent intent)
{
_locationText.Text = intent.GetStringExtra("Location");
_addressText.Text = intent.GetStringExtra("Address");
_remarksText.Text = intent.GetStringExtra("Remarks");
differance = intent.GetStringExtra("Differance");
var loactionDifferance = Convert.ToDouble(differance);
WifiManager objWifiManager = (WifiManager)GetSystemService(Context.WifiService);
if (objWifiManager.WifiState == Android.Net.WifiState.Enabled)
{
if (loactionDifferance > 0.02)
{
objWifiManager.SetWifiEnabled(false);
}
}
}
public bool TrySetState(bool enabled)
{
if (this.Enabled == enabled)
{
return(true);
}
try
{
// var wifiManager = Application.Context.GetSystemService(Context.WifiService) as WifiManager;
return(WifiManager != null && WifiManager.SetWifiEnabled(enabled));
}
catch (Exception exception)
{
this.ReportException(exception);
return(false);
}
}
/// <summary>
/// Sets the WiFi AP state.
/// </summary>
/// <returns><c>true</c>, if WiFi state was set, <c>false</c> otherwise.</returns>
/// <param name="wifiConfig">Wifi config.</param>
/// <param name="enabled">State enabled.</param>
public bool SetWifiApEnabled(WifiConfiguration wifiConfig, Java.Lang.Boolean enabled)
{
try
{
if (enabled == Java.Lang.Boolean.True)
{ // disable WiFi in any case
WifiManager.SetWifiEnabled(false);
}
var method = WifiManager.Class.GetMethod("setWifiApEnabled", wifiConfig.Class, enabled.Class);
return((Boolean)method.Invoke(WifiManager, wifiConfig, enabled));
}
catch (Exception e)
{
Log.Error(this.ToString(), e.Message);
return(false);
}
}
/// <summary>
/// Start AccessPoint mode with the specified configuration. If the radio is already running in AP mode, update
/// the new configuration
/// Note that starting in access point mode disables station mode operation
/// </summary>
/// <param name="wifiConfig">SSID, security and channel details as part of <see cref="WifiConfiguration"/></param>
/// <param name="enabled">If enabled</param>
/// <returns><code>true</code> if the operation succeeds, <code>false</code> otherwise</returns>
public bool SetWifiApEnabled(WifiConfiguration wifiConfig, bool enabled)
{
try
{
if (enabled) //disable wifi in any case
{
wifiManager.SetWifiEnabled(false);
}
Method method = wifiManager.Class.GetMethods().FirstOrDefault(m => m.Name == "setWifiApEnabled");
return((bool)method.Invoke(wifiManager, wifiConfig, enabled));
}
catch (System.Exception ex)
{
Log.Error(nameof(WifiApManager), "", ex);
return(false);
}
}
private void FindDev()
{
try
{
btn_Find.Enabled = false;
progr_bar.Visibility = ViewStates.Visible;
wifiManager = (WifiManager)Application.Context.GetSystemService(WifiService);
if (!wifiManager.IsWifiEnabled)
{
wifiManager.SetWifiEnabled(true);
}
wifiManager.StartScan();
for (int i = 0; i < wifiManager.ScanResults.Count; i++)
{
if (wifiManager.ScanResults[i].Ssid.ToString().Contains("SH_"))
{
Button exist = (Button)m_frame_control.FindViewWithTag(wifiManager.ScanResults[i].Ssid.ToString());
if (exist == null)
{
LinearLayout.LayoutParams leftMarginParams = new LinearLayout.LayoutParams(-1, -2);
Button btn1 = new Button(this);
btn1.Text = wifiManager.ScanResults[i].Ssid.ToString();
btn1.Tag = wifiManager.ScanResults[i].Ssid.ToString();
btn1.SetBackgroundResource(Resource.Drawable.btn_AddDev_selector);
btn1.SetTextColor(new Android.Graphics.Color(0xED, 0xED, 0xED));
btn1.Tag = wifiManager.ScanResults[i].Ssid.ToString();
btn1.Click += Btn1_Click;
m_frame_control.AddView(btn1, leftMarginParams);
}
}
}
progr_bar.Visibility = ViewStates.Invisible;
btn_Find.Enabled = true;
}
catch (Exception ex)
{
Toast.MakeText(this, ex.Message, ToastLength.Short);
}
}
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();
}
private void PerformScan()
{
//check if wifi is enabled
if (!wiMan.IsWifiEnabled)
{
var builder = new Android.App.AlertDialog.Builder(this);
builder.SetTitle("Change Wifi Adapter State");
builder.SetMessage("Do You want to turn on WIFI adapter?");
builder.SetPositiveButton("Yes", delegate
{
wiMan.SetWifiEnabled(true);
wiMan.StartScan();
});
builder.SetNegativeButton("No", delegate { });
builder.Show();
}
else
{
wiMan.StartScan();
}
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
lblOutput = FindViewById <TextView>(Resource.Id.LBLscan);
if (_wifi.IsWifiEnabled == false)
{
_wifi.SetWifiEnabled(true);
}
for (int p = 0; p < 100; p++)
{
Distances[p] = new double[4];
}
for (int p = 0; p < 100; p++)
{
Identities[p] = new string[2];
}
updateView();
}
public ConnectionState Start()
{
if (isWifiApEnabled())
{
return(ConnectionState.connected);
}
WifiManager.SetWifiEnabled(false);
try
{
WifiConfiguration netConfig = new WifiConfiguration();
netConfig.Ssid = WifiAndroidWrapper.networkSSID;
netConfig.PreSharedKey = WifiAndroidWrapper.networkPass;
netConfig.HiddenSSID = false;
netConfig.StatusField = Android.Net.Wifi.WifiStatus.Enabled;
netConfig.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Tkip);
netConfig.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Ccmp);
netConfig.AllowedKeyManagement.Set((int)Android.Net.Wifi.KeyManagementType.WpaPsk);
netConfig.AllowedPairwiseCiphers.Set((int)Android.Net.Wifi.PairwiseCipherType.Tkip);
netConfig.AllowedPairwiseCiphers.Set((int)Android.Net.Wifi.PairwiseCipherType.Ccmp);
netConfig.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Rsn);
netConfig.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Wpa);
setWifiApEnabled(netConfig, true);
while (!(Boolean)isWifiApEnabled())
{
}
;
var status = getWifiApState();
}
catch (Exception)
{
}
return(ConnectionState.connecting);
}
