public bool ConnectCam()
{
if (IsConnectedCam)
{
return(true);
}
WifiManager.StartScan();
var result = WifiManager?.ScanResults?.FirstOrDefault(r => r.Ssid.Contains(CamSsid));
if (result == null)
{
return(false);
}
var config = WifiManager.ConfiguredNetworks.FirstOrDefault(c => c.Ssid.Contains(CamSsid));
if (config == null)
{
return(false);
}
return(WifiManager.EnableNetwork(config.NetworkId, true));
}
public String connectToWifi(String ssid, String wifiPassword)
{
string result;
WifiConfiguration wifiConfiguration = new WifiConfiguration();
wifiConfiguration.Ssid = string.Format("\"{0}\"", ssid);
wifiConfiguration.PreSharedKey = string.Format("\"{0}\"", wifiPassword);
wifiManager.RemoveNetwork(wifiManager.ConnectionInfo.NetworkId);
this.removeConfigById(wifiManager.ConnectionInfo.NetworkId);
this.removeConfig(string.Format("\"{0}\"", ssid));
this.removeConfig(ssid);
//var wifiManager = (WifiManager)Android.App.Application.Context
// .GetSystemService(Context.WifiService);
string old_ssid = string.Format("\"{0}\"", wifiManager.ConnectionInfo.SSID);
old = wifiManager.ConfiguredNetworks.FirstOrDefault(n => n.Ssid == old_ssid);
int netId = wifiManager.AddNetwork(wifiConfiguration);
wifiManager.Disconnect();
wifiManager.EnableNetwork(netId, true);
wifiManager.Reconnect();
result = wifiManager.ConnectionInfo.SSID;
return(result);
}
public static void ConnectToNework(string SSID, string Key)
{
var WifiConfig = new WifiConfiguration();
WifiConfig.Ssid = string.Format("\"{0}\"", SSID);
WifiConfig.PreSharedKey = string.Format("\"{0}\"", Key);
ToggleWiFi(true);
int NetID;
var Network = WifiMan.ConfiguredNetworks.FirstOrDefault(cn => cn.Ssid == SSID);
if (Network != null)
{
NetID = Network.NetworkId;
}
else
{
NetID = WifiMan.AddNetwork(WifiConfig);
WifiMan.SaveConfiguration();
}
WifiMan.UpdateNetwork(WifiConfig);
var CurrCon = WifiMan.ConnectionInfo;
if (CurrCon != null && CurrCon.NetworkId != NetID)
{
WifiMan.Disconnect();
WifiMan.EnableNetwork(NetID, true);
WifiMan.Reconnect();
}
}
private void OnConnetti4ButtonClicked(object sender, EventArgs e)
{
Models.Device device = (Models.Device)BindingContext;
WifiConfiguration conf = new WifiConfiguration();
WifiManager wifiManager = (WifiManager)Android.App.Application.Context
.GetSystemService(Context.WifiService);
conf.Ssid = string.Format("\"{0}\"", device.Ssid);
conf.PreSharedKey = string.Format("\"{0}\"", device.WifiPwd);
IList <WifiConfiguration> wifiConfigurationList = wifiManager.ConfiguredNetworks;
foreach (WifiConfiguration removeConfig in wifiConfigurationList)
{
if (removeConfig.Ssid.Equals(conf.Ssid))
{
wifiManager.RemoveNetwork(removeConfig.NetworkId);
break;
}
}
int netId = wifiManager.AddNetwork(conf);
test_4.Text = Convert.ToString(wifiManager.ConnectionInfo.NetworkId);
//wifiManager.DisableNetwork(wifiManager.ConnectionInfo.NetworkId);
wifiManager.EnableNetwork(netId, true);
}
public override void OnReceive(Context context, Intent intent)
{
string action = intent.Action;
const string ssid = "\"sound_reactive\"";
const string password = "******"password\"";
if (WifiManager.ScanResultsAvailableAction.Equals(action))
{
List <ScanResult> wifiList = wifiManager
.ScanResults.ToList();
WifiConfiguration network = wifiList
.Where(x => x.Ssid.Equals("sound_reactive"))
.Select(x => new WifiConfiguration()
{
Ssid = "sound_reactive"
})
.FirstOrDefault();
if (network != null)
{
network.PreSharedKey = password;
network.Ssid = ssid;
wifiList.ForEach(x => {
if (x.Ssid != "sound_reactive")
{
WifiConfiguration wifi =
new WifiConfiguration()
{
Ssid = x.Ssid
};
wifiManager.DisableNetwork(wifi.NetworkId);
}
});
wifiManager.EnableNetwork(network.NetworkId, true);
if (wifiManager.Reconnect())
{
Intent redirectToMainControl =
new Intent(context, typeof(MainControlActivity));
context.StartActivity(redirectToMainControl);
}
}
else
{
AlertDialog.Builder builder =
new AlertDialog.Builder(context);
builder.SetMessage("Not found");
AlertDialog alert = builder.Create();
alert.Show();
}
}
context.UnregisterReceiver(this);
}
public async Task <bool> ConnectToWifi(WifiCredentials credentials)
{
if (credentials == null)
{
throw new ArgumentNullException(nameof(credentials));
}
var tcs = new TaskCompletionSource <bool>();
#pragma warning disable 4014
Task.Run(async() =>
{
try
{
var wifiConfig = new WifiConfiguration
{
Ssid = $"\"{credentials.Ssid}\"",
PreSharedKey = $"\"{credentials.Pwd}\""
};
WifiManager wifiManager = (WifiManager)_context.GetSystemService(Context.WifiService);
// Use ID
int netId = wifiManager.AddNetwork(wifiConfig);
wifiManager.Disconnect();
await Task.Delay(1000);
int disconnectedIp = wifiManager.ConnectionInfo?.IpAddress ?? 0;
int currentIp = disconnectedIp;
wifiManager.EnableNetwork(netId, true);
wifiManager.Reconnect();
for (int i = 0; i < 100; i++)
{
currentIp = wifiManager.ConnectionInfo?.IpAddress ?? 0;
if (currentIp != disconnectedIp)
{
await Task.Delay(1000);
break;
}
else
{
await Task.Delay(250);
}
}
tcs.SetResult(currentIp != disconnectedIp);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
Debugger.Break();
tcs.SetResult(false);
}
});
#pragma warning restore 4014
return(await tcs.Task);
}
public void ConnectToWifi(string ssid, string password)
{
var formattedSsid = $"\"{ssid}\"";
var formattedPassword = $"\"{password}\"";
var wifiConfig = new WifiConfiguration
{
Ssid = formattedSsid,
PreSharedKey = formattedPassword
};
try
{
var addNetwork = _wifiManager.AddNetwork(wifiConfig);
}
catch (Exception ex)
{
OnError?.Invoke(new Exception("WifiConnector can not add the new wifi network configuration", ex));
}
WifiConfiguration network = null;
try
{
network = _wifiManager.ConfiguredNetworks
.FirstOrDefault(n => n.Ssid == formattedSsid);
if (network == null)
{
OnError?.Invoke(new Exception("WifiConnector can not connect to the specified wifi network"));
return;
}
}
catch (Exception ex)
{
OnError?.Invoke(new Exception("WifiConnector can not get the list of configured wifi networks", ex));
return;
}
try
{
_wifiManager.Disconnect();
var enableNetwork = _wifiManager.EnableNetwork(network.NetworkId, true);
if (enableNetwork && _wifiManager.ConnectionInfo != null && _wifiManager.ConnectionInfo.SSID.Equals(formattedSsid))
{
OnLog?.Invoke("WiFi network has been connected");
}
else
{
OnError?.Invoke(new Exception("Te specified wifi network does not exist"));
}
}
catch (Exception ex)
{
OnError?.Invoke(new Exception("Activating the connection to the configured wifi network failed", ex));
}
}
public void Connect(Models.WifiDescriptor descriptor, string passPhrase)
{
WifiConfiguration wifiConfig = new WifiConfiguration
{
Ssid = $"\"{descriptor.Ssid}\"",
PreSharedKey = $"\"{passPhrase}\""
};
try
{
this._wifiManager.AddNetwork(wifiConfig);
}
catch (Exception ex)
{
throw new WifiException("WifiConnector can not add the new wifi network configuration", ex);
}
WifiConfiguration network = null;
try
{
network = this._wifiManager.ConfiguredNetworks
.FirstOrDefault(n => n.Ssid == wifiConfig.Ssid);
if (network == null)
{
throw new WifiException("WifiConnector can not connect to the specified wifi network");
}
}
catch (Exception ex)
{
throw new WifiException("WifiConnector can not get the list of configured wifi networks", ex);
}
try
{
this._wifiManager.Disconnect();
bool networkEnabled = _wifiManager.EnableNetwork(network.NetworkId, true);
if (this.VerifyConnectivity(wifiConfig.Ssid, networkEnabled))
{
OnConnected?.Invoke(this, EventArgs.Empty);
}
else
{
throw new WifiException("The specified wifi network does not exist");
}
}
catch (Exception ex)
{
throw new WifiException("Activating the connection to the configured wifi network failed", ex);
}
}
public void ConnectToWifi()
{
var config = new WifiConfiguration();
config.Ssid = '"' + _wifiSsid + '"';
config.PreSharedKey = '"' + _wifiPassword + '"';
int id = _wifiManager.AddNetwork(config);
_wifiManager.Disconnect();
_wifiManager.EnableNetwork(id, true);
_wifiManager.Reconnect();
}
private void Back_btn_Click(object sender, EventArgs e)
{
// Save modid;
SendUdp("WIFICONNECT");
List <DevInfo> dev_list_saved;
var prefs = Application.Context.GetSharedPreferences("SmartHomeApp", FileCreationMode.Private);
string dev_list_saved_json = prefs.GetString("DEVINFO", null);
if (dev_list_saved_json == null)
{
dev_list_saved = new List <DevInfo>();
}
else
{
dev_list_saved = JsonConvert.DeserializeObject <List <DevInfo> >(dev_list_saved_json);
}
foreach (DevInfo s in dev_list_saved.ToList())
{
if (s.ID == ID)
{
dev_list_saved.Remove(s);
}
}
// dev_list_saved.Add("ID:" + ID + ";NAME:" + devName.Text);
dev_list_saved.Add(new DevInfo(2, devName.Text, ID + "/control/out", ID));
string stringjson = JsonConvert.SerializeObject(dev_list_saved);
var prefEditor = prefs.Edit();
prefEditor.PutString("DEVINFO", stringjson);
prefEditor.Commit();
wifiManager = (WifiManager)Application.Context.GetSystemService(WifiService);
List <WifiConfiguration> list = new List <WifiConfiguration>(wifiManager.ConfiguredNetworks);
for (int j = 0; j < list.Count; j++)
{
if (list[j].Ssid.Contains(wifi_old))
{
wifiManager.Disconnect();
wifiManager.EnableNetwork(list[j].NetworkId, true);
wifiManager.Reconnect();
}
}
thdUDPServer.Abort();
timethread.Abort();
this.Finish();
}
private void OnConnect2ButtonClicked(object sender, EventArgs e)
{
string networkSSID = "welab_YVG24b";
string networkPass = "******";
WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.Ssid = string.Format("\"{0}\"", networkSSID);
wifiConfig.PreSharedKey = string.Format("\"{0}\"", networkPass);
WifiManager wifiManager = (WifiManager)Android.App.Application.Context.GetSystemService(Context.WifiService);
// Use ID
int netId = wifiManager.AddNetwork(wifiConfig);
wifiManager.Disconnect();
wifiManager.EnableNetwork(netId, true);
wifiManager.Reconnect();
}
public bool connect(string ssid, string psk)
{
Context context = Android.App.Application.Context;
if (context == null)
{
return(false);
}
WifiConfiguration wifiConfig = new WifiConfiguration
{
Ssid = string.Format("\"{0}\"", ssid),
PreSharedKey = string.Format("\"{0}\"", psk)
};
WifiManager wifi = (WifiManager)context.GetSystemService(Context.WifiService);
_remove(ssid, wifi);
int netId = wifi.AddNetwork(wifiConfig);
wifi.Disconnect();
if (wifi.EnableNetwork(netId, true))
{
if (wifi.Reconnect())
{
ConnectivityManager connectivityManager = (ConnectivityManager)context.GetSystemService(Context.ConnectivityService);
NetworkInfo networkInfo;
int i = 0;
do
{
networkInfo = connectivityManager.ActiveNetworkInfo;
Thread.Sleep(100);
i++;
} while ((networkInfo == null || !(networkInfo.Type == ConnectivityType.Wifi)) && i < 30);
if (networkInfo != null && networkInfo.Type == ConnectivityType.Wifi)
{
return(true);
}
}
}
_remove(ssid, wifi);
return(false);
}
/// <summary>
/// подключение по WPA стандарту к точке
/// </summary>
/// <param name="networkSSID">имя сети</param>
/// <param name="password"> пароль </param>
/// <returns>статус коннекта</returns>
public bool ConnectToNetworkWPA(string networkSSID, string password)
{
try
{
WifiConfiguration conf = new WifiConfiguration();//конфигурация
conf.Ssid = "\"" + networkSSID + "\"";
conf.PreSharedKey = "\"" + password + "\"";
conf.StatusField = WifiStatus.Enabled;
conf.AllowedGroupCiphers.NextSetBit((int)GroupCipherType.Tkip);
conf.AllowedGroupCiphers.Set((int)GroupCipherType.Tkip);
conf.AllowedGroupCiphers.Set((int)GroupCipherType.Ccmp);
conf.AllowedKeyManagement.Set((int)KeyManagementType.WpaPsk);
conf.AllowedPairwiseCiphers.Set((int)PairwiseCipherType.Tkip);
conf.AllowedPairwiseCiphers.Set((int)PairwiseCipherType.Ccmp);
WifiManager.AddNetwork(conf);
IList <WifiConfiguration> list = WifiManager.ConfiguredNetworks;
foreach (WifiConfiguration i in list)
{
if (i.Ssid != null && i.Ssid.Equals("\"" + networkSSID + "\""))
{
WifiManager.Disconnect();
WifiManager.EnableNetwork(i.NetworkId, true);
WifiManager.Reconnect();
break;
}
}
return(true);
}
catch (Exception)
{
//alertManager();
return(false);
}
}
private void ConnectToNetwork()
{
Logger.Info("Connecting to " + AccessPoint.Ssid);
var formatSSid = $"\"{AccessPoint.Ssid}\"";
var formatPassword = $"\"{AccessPoint.Password}\"";
var wifiConfig = new WifiConfiguration
{
Ssid = formatSSid,
PreSharedKey = formatPassword
};
var network = _manager.ConfiguredNetworks.FirstOrDefault(n => n.Ssid == formatSSid);
if (network == null)
{
var networkDesc = _manager.AddNetwork(wifiConfig);
network = _manager.ConfiguredNetworks.FirstOrDefault(n => n.Ssid == formatSSid);
}
if (network == null)
{
throw new System.Exception("Could not to connect:-(");
}
else
{
if (_manager.Disconnect())// просто отключаемся от текущей сети
{
}
//System.Diagnostics.Debug.WriteLine("TRYING TO CONNECT " + formatSSid);
if (!_manager.EnableNetwork(network.NetworkId, true))
{
Logger.Info("Fail to enable " + AccessPoint.Ssid);
}
}
}
private async Task <bool> Connect(int networkId, string ssid)
{
if (networkId == -1)
{
ConnectionFailed?.Invoke(this, new ConnectionFailedEventArgs("Network wasn't found"));
Console.WriteLine("Network Id was -1");
return(false);
}
StringBuilder stringBuilder = new StringBuilder();
bool connected;
WifiInfo info = default(WifiInfo);
int tryCount = 0;
do
{
if (tryCount < 50)
{
stringBuilder.Append(".");
CheckingConnectionStatusUpdated?.Invoke(this, new CheckingConnectionStatusUpdatedEventArgs($"Connecting{stringBuilder.ToString()}", ssid, false));
}
else
{
ConnectionFailed?.Invoke(this, new ConnectionFailedEventArgs("Didn't connect quickly enough."));
return(false);
}
connected = wifiManager.EnableNetwork(networkId, true);
await Task.Delay(500);
tryCount++;
info = wifiManager.ConnectionInfo;
}while ((info.NetworkId != networkId || info.SupplicantState != SupplicantState.Completed));
CheckingConnectionStatusUpdated?.Invoke(this, new CheckingConnectionStatusUpdatedEventArgs($"Connected", ssid, true));
return(true);
}
/// <summary>Udp
///
/// </summary>
/// <returns></returns>
private int EnableWifi()
{
string networkSSID = "bbox-xxx";
string networkPass = "******";
WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.Ssid = string.Format("\"{0}\"", networkSSID);
wifiConfig.PreSharedKey = string.Format("\"{0}\"", networkPass);
WifiManager wifiManager = (WifiManager)Application.Context.GetSystemService(Context.WifiService);
WifiInfo wifiinfo = (WifiInfo)Application.Context.GetSystemService(Context.WifiService);
// Use ID
int netId = wifiManager.AddNetwork(wifiConfig);
wifiManager.Disconnect();
wifiManager.EnableNetwork(netId, true);
wifiManager.Reconnect();
int ipAddress = wifiinfo.IpAddress;
return(ipAddress);
}
private void Btn1_Click(object sender, EventArgs e)
{
WifiConfiguration wconf = new WifiConfiguration();
wconf.Ssid = "\"" + ((Button)sender).Text + "\"";
wconf.PreSharedKey = "\"" + "12345678" + "\"";
int hhhh = wifiManager.AddNetwork(wconf);
List <WifiConfiguration> list = new List <WifiConfiguration>(wifiManager.ConfiguredNetworks);
if (list == null)
{
return;
}
for (int j = 0; j < list.Count; j++)
{
if (list[j].Ssid.Contains(((Button)sender).Text))
{
var intent = new Intent(this, typeof(ModConfigNext));
intent.PutExtra("WIFI_OLD_NAME", wifiManager.ConnectionInfo.SSID);
intent.PutExtra("IP_MOD", "192.168.4.1");
intent.PutExtra("ID", ((Button)sender).Tag.ToString());
wifiManager.Disconnect();
wifiManager.EnableNetwork(list[j].NetworkId, true);
wifiManager.Reconnect();
// while(wifiManager.ConnectionInfo.SSID!=wconf.Ssid )
// { }
progr_bar.Visibility = ViewStates.Invisible;
intent.PutExtra("DEV_WIFI_NAME", list[j].Ssid);
StartActivity(intent);
break;
}
}
}
public void ConnectToAccessPoint(string ssid, string password)
{
int netId = -1;
var wifi = new WifiConfiguration
{
Ssid = $"\"{ssid}\"",
PreSharedKey = $"\"{password}\"",
};
netId = _manager.ConfiguredNetworks.FirstOrDefault(x => x.Ssid == ssid) != null
? _manager.UpdateNetwork(wifi)
: _manager.AddNetwork(wifi);
_currentNetId = netId;
_current = wifi;
_manager.Disconnect();
_manager.EnableNetwork(netId, true);
_manager.Reconnect();
StartWifiCheckingTimer();
}
private void OnConnetti5ButtonClicked(object sender, EventArgs e)
{
ConnectivityManager cm = (ConnectivityManager)Android.App.Application.Context
.GetSystemService(Context.WifiService);
//var builder = new NetworkRequest.Builder();
//var callback = new ConnectivityManager.NetworkCallback();
//cm.RequestNetwork(builder.Build(), new _CreateCallBack());
Models.Device device = (Models.Device)BindingContext;
WifiConfiguration conf = new WifiConfiguration();
WifiManager wifiManager = (WifiManager)Android.App.Application.Context
.GetSystemService(Context.WifiService);
conf.Ssid = string.Format("\"{0}\"", device.Ssid);
conf.PreSharedKey = string.Format("\"{0}\"", device.WifiPwd);
int netId = wifiManager.AddNetwork(conf);
wifiManager.Disconnect();
wifiManager.EnableNetwork(netId, true);
wifiManager.Reconnect();
//cm.BindProcessToNetwork(cm.ActiveNetwork);
}
public override async Task <bool> Connect(string essid, string passphrase)
{
OnStatusUpdated("Enabling WiFi");
await EnableWifi();
OnStatusUpdated("Connecting to WiFi");
// create configuration parameter
var conf = new WifiConfiguration();
conf.Ssid = $"\"{essid}\"";
conf.PreSharedKey = $"\"{passphrase}\"";
conf.AllowedProtocols.Set((int)ProtocolType.Rsn);
conf.AllowedProtocols.Set((int)ProtocolType.Wpa);
conf.AllowedKeyManagement.Set((int)KeyManagementType.WpaPsk);
conf.AllowedPairwiseCiphers.Set((int)PairwiseCipherType.Ccmp);
conf.AllowedPairwiseCiphers.Set((int)PairwiseCipherType.Tkip);
conf.AllowedGroupCiphers.Set((int)GroupCipherType.Wep40);
conf.AllowedGroupCiphers.Set((int)GroupCipherType.Wep104);
conf.AllowedGroupCiphers.Set((int)GroupCipherType.Ccmp);
conf.AllowedGroupCiphers.Set((int)GroupCipherType.Tkip);
_manager.AddNetwork(conf);
_manager.SaveConfiguration();
_manager.UpdateNetwork(conf);
// try connect
var network = _manager.ConfiguredNetworks.FirstOrDefault(i => i.Ssid == conf.Ssid);
_manager.Disconnect();
await Task.Delay(333);
_manager.EnableNetwork(network.NetworkId, true);
// wait for connection
OnStatusUpdated("Waiting for connection");
await WaitForWifiEstablished(conf.Ssid);
return(true);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
this.SetContentView(Resource.Layout.StepOne);
TextView txtInternetCheck = FindViewById <TextView>(Resource.Id.txtInternetCheck);
TextView wifiName = FindViewById <TextView>(Resource.Id.wifiName);
EditText wifiPass = FindViewById <EditText>(Resource.Id.wifiPass);
ListView wifiNetworkList = FindViewById <ListView>(Resource.Id.listView1);
Button connBtn = FindViewById <Button>(Resource.Id.wifiConnBtn);
Button stepTwoBtn = FindViewById <Button>(Resource.Id.stepTwoBtn);
WifiManager wifiManager = (WifiManager)Application.Context.GetSystemService(WifiService);
ArrayList networks = new ArrayList();
if (wifiManager.StartScan())
{
foreach (ScanResult network in wifiManager.ScanResults)
{
networks.Add(network.Ssid);
}
}
//connBtn.Visibility = Android.Views.ViewStates.Invisible;
stepTwoBtn.Visibility = Android.Views.ViewStates.Invisible;
//Turn on wifi if not enabled
if (!wifiManager.IsWifiEnabled)
{
wifiManager.SetWifiEnabled(true);
}
//Supplies wifi connections picked up
var adapter = new ArrayAdapter(this, Android.Resource.Layout.SimpleListItem1, networks);
wifiNetworkList.Adapter = adapter;
//When network name gets clicked
wifiNetworkList.ItemClick += WifiItemClicked;
//Gets SSID of item clicked
void WifiItemClicked(object sender, AdapterView.ItemClickEventArgs e)
{
string selectedItem = (string)networks[e.Position];
wifiName.Visibility = Android.Views.ViewStates.Visible;
wifiPass.Visibility = Android.Views.ViewStates.Visible;
connBtn.Visibility = Android.Views.ViewStates.Visible;
wifiName.Text = selectedItem;
wifiPass.Hint = $"Enter password for {selectedItem}";
}
//Connect to the wifi
connBtn.Click += delegate {
InputMethodManager inputManager = (InputMethodManager)this.GetSystemService(Context.InputMethodService);
inputManager.HideSoftInputFromWindow(this.CurrentFocus.WindowToken, HideSoftInputFlags.NotAlways);
var wifiConfig = new WifiConfiguration();
wifiConfig.Ssid = string.Format("\"{0}\"", wifiName.Text);
wifiConfig.PreSharedKey = string.Format("\"{0}\"", wifiPass.Text);
using (WifiManager wifiManager2 = (WifiManager)Application.Context.GetSystemService(Context.WifiService))
{
int netId = wifiManager2.AddNetwork(wifiConfig);
wifiManager2.Disconnect();
wifiManager2.EnableNetwork(netId, true);
wifiManager2.Reconnect();
}
txtInternetCheck.Text = "Connecting...Please Wait";
//Thread.Sleep(7000);
//ConnectivityManager connectivityManager = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService);
//var netInfo = connectivityManager.ActiveNetworkInfo;
////netInfo.IsConnected &&
//if (netInfo.Type == ConnectivityType.Wifi)
//{
// txtInternetCheck.Text = "Great, you are connected!";
// stepTwoBtn.Visibility = Android.Views.ViewStates.Visible;
//}
//else
//{
// txtInternetCheck.Text = "Something went wrong. Please try again.";
//}
Thread thread = new Thread(() =>
{
Thread.Sleep(7000);
ConnectivityManager connectivityManager = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService);
var netInfo = connectivityManager.ActiveNetworkInfo;
//netInfo.IsConnected &&
if (netInfo.Type == ConnectivityType.Wifi)
{
RunOnUiThread(() =>
{
txtInternetCheck.Text = "Great, you are connected!";
stepTwoBtn.Visibility = Android.Views.ViewStates.Visible;
});
}
else if (netInfo == null)
{
RunOnUiThread(() =>
{
txtInternetCheck.Text = "Something went wrong. Please try again.";
});
}
});
thread.Start();
};
stepTwoBtn.Click += delegate {
Intent intent = new Intent(this, typeof(ActivateActivity));
StartActivity(intent);
Finish();
};
}
public bool ConnectToWifi(int netId)
{
return(_manager.EnableNetwork(netId, true));
}
public bool ConnectToWifi(string ssid, string password)
{
try
{
if (Android.OS.Build.VERSION.SdkInt < Android.OS.BuildVersionCodes.Q)
{
_WifiManager = (WifiManager)Android.App.Application.Context.GetSystemService(Context.WifiService);
string oldSsid = "empty";
string oldBsid = "empty";
try
{
oldSsid = _WifiManager.ConnectionInfo.SSID.Replace("\"", "");
oldBsid = _WifiManager.ConnectionInfo.BSSID.Replace("\"", "");
}
catch { }
var formattedSsid = $"\"{ssid}\"";
var formattedPassword = $"\"{password}\"";
var wifiConfig = new WifiConfiguration
{
Ssid = formattedSsid,
PreSharedKey = formattedPassword
};
_WifiManager.AddNetwork(wifiConfig);
var dis = _WifiManager.Disconnect();
var network = _WifiManager.ConfiguredNetworks.FirstOrDefault(n => n.Ssid.Contains(formattedSsid));
var ena = _WifiManager.EnableNetwork(network.NetworkId, true);
var req = _WifiManager.Reconnect();
_Status = "api<29, connecting to " + formattedSsid + " from " + oldSsid + ", dis = " + dis + " ena = " + ena + " req = " + req;
Android.Util.Log.Debug("TEST", _Status);
}
else
{
NetworkSpecifier specifier = new WifiNetworkSpecifier.Builder()
.SetSsidPattern(new PatternMatcher(ssid, Pattern.Prefix))
.SetBssidPattern(MacAddress.FromString(password), MacAddress.FromString("ff:ff:ff:ff:ff:ff"))
.Build();
NetworkRequest request = new NetworkRequest.Builder()
.AddTransportType(TransportType.Wifi)
.RemoveCapability(NetCapability.Internet)
.SetNetworkSpecifier(specifier)
.Build();
_ConnectivityManager = (ConnectivityManager)Android.App.Application.Context.GetSystemService(Context.ConnectivityService);
_NetworkCallback = new WifiNetworkCallback();
_Status = "api>=29, connecting to " + ssid + " mac " + password;
Android.Util.Log.Debug("TEST", _Status);
_ConnectivityManager.RequestNetwork(request, _NetworkCallback);
}
return(true);
}
catch (Exception ex)
{
_Status = "Connect to WiFi error, ex=" + ex.Message;
Android.Util.Log.Error("TEST", _Status);
return(false);
}
}
public ConnectionState ConnectTo(string ssid, string key)
{
if (ConnectionCooldown > DateTime.Now)
{
return(State);
}
ConnectionCooldown = DateTime.Now.AddSeconds(10);
//TODO: testar esse if
if (WifiManager.IsWifiEnabled == false)
{
WifiManager.SetWifiEnabled(true);
}
while (WifiManager.IsWifiEnabled == false)
{
}
WifiInfo wifiInfo = WifiManager.ConnectionInfo;
if (wifiInfo.SupplicantState == SupplicantState.Completed)
{
if (wifiInfo.SSID == quoted(ssid))
{
State = ConnectionState.connected;
return(State);
}
}
int highestPriorityNumber = 0;
WifiConfiguration selectedConfig = null;
/* Check if not connected but has connected to that wifi in the past */
foreach (WifiConfiguration config in WifiManager.ConfiguredNetworks)
{
if (config.Priority > highestPriorityNumber)
{
highestPriorityNumber = config.Priority;
}
if (config.Ssid == quoted(ssid))
{
selectedConfig = config;
}
}
State = ConnectionState.connecting;
if (selectedConfig != null)
{
selectedConfig.Priority = highestPriorityNumber + 1;
WifiManager.UpdateNetwork(selectedConfig);
WifiManager.Disconnect(); /* disconnect from whichever wifi you're connected to */
WifiManager.EnableNetwork(selectedConfig.NetworkId, true);
WifiManager.Reconnect();
return(State);
}
selectedConfig = new WifiConfiguration();
selectedConfig.Ssid = quoted(ssid);
selectedConfig.Priority = highestPriorityNumber + 1;
selectedConfig.StatusField = Android.Net.Wifi.WifiStatus.Enabled;
selectedConfig.PreSharedKey = quoted(key);
selectedConfig.AllowedKeyManagement.Set((int)Android.Net.Wifi.KeyManagementType.WpaPsk);
selectedConfig.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Tkip);
selectedConfig.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Ccmp);
selectedConfig.AllowedPairwiseCiphers.Set((int)Android.Net.Wifi.PairwiseCipherType.Tkip);
selectedConfig.AllowedPairwiseCiphers.Set((int)Android.Net.Wifi.PairwiseCipherType.Ccmp);
selectedConfig.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Rsn);
selectedConfig.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Wpa);
int netId = WifiManager.AddNetwork(selectedConfig);
WifiManager.Disconnect(); /* disconnect from whichever wifi you're connected to */
WifiManager.EnableNetwork(netId, true);
WifiManager.Reconnect(); // todo?
return(State);
//WifiConfiguration conf = new WifiConfiguration();
//conf.Ssid = "\"" + networkSSID + "\"";
//conf.PreSharedKey = "\"" + networkPass + "\"";
//WifiManager.Disconnect();
//var id = WifiManager.AddNetwork(conf);
//WifiManager.EnableNetwork(id, true);
//WifiManager.Reconnect();
//var aa = WifiManager.ConfiguredNetworks.Select(f => f.Ssid);
//IEnumerable<WifiConfiguration> list = WifiManager.ConfiguredNetworks;
//foreach (WifiConfiguration i in list)
//{
// if (i.Ssid != null && i.Ssid.Equals("\"" + networkSSID + "\""))
// {
// WifiManager.Disconnect();
// WifiManager.EnableNetwork(i.NetworkId, true);
// WifiManager.Reconnect();
// break;
// }
//}
//WifiConfiguration wfc = new WifiConfiguration();
//wfc.Ssid = ssid;
//wfc.StatusField = Android.Net.Wifi.WifiStatus.Disabled;
//wfc.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Rsn);
//wfc.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Wpa);
//wfc.AllowedKeyManagement.Set((int)Android.Net.Wifi.KeyManagementType.WpaPsk);
//wfc.AllowedPairwiseCiphers.Set((int)Android.Net.Wifi.PairwiseCipherType.Ccmp);
//wfc.AllowedPairwiseCiphers.Set((int)Android.Net.Wifi.PairwiseCipherType.Tkip);
//wfc.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Wep40);
//wfc.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Wep104);
//wfc.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Ccmp);
//wfc.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Tkip);
//wfc.PreSharedKey = password;
//wfc.Priority = 10000;
//WifiManager.Disconnect();
//int networkId = WifiManager.AddNetwork(wfc);
//var id = WifiManager.UpdateNetwork(wfc);
//WifiManager.SaveConfiguration();
//WifiManager.EnableNetwork(id, false);
//WifiManager.Reconnect();
//var aa = WifiManager.ConfiguredNetworks.Select(f => f.Ssid);
//if (networkId != -1)
//{
// //WifiManager.Disconnect();
// //// success, can call wfMgr.enableNetwork(networkId, true) to connect
// //WifiManager.EnableNetwork(networkId, true);
// //WifiManager.Reconnect();
//}
}
public override void OnReceive(Context context, Intent intent)
{
try
{
Wifi = (WifiManager)context.GetSystemService(Context.WifiService);
CManager = (ConnectivityManager)context.GetSystemService(Context.ConnectivityService);
if (!Wifi.IsWifiEnabled)
{
Wifi.SetWifiEnabled(true);
MainActivity.MakeText("WIFI IS OFF", true);
}
if (string.IsNullOrWhiteSpace(ConnectedSSID) || ConnectedSSID == "<unknown ssid>")
{
MainActivity.MakeText("WIFI NOT CONNECTED", true);
var networkInfo = CManager.ActiveNetworkInfo;
if (networkInfo == null || !networkInfo.IsConnectedOrConnecting)
{
var prefs = context.GetSharedPreferences("Wifiautoconnect", FileCreationMode.Private);
var ssid = prefs.GetString("network", "");
var pass = prefs.GetString("password", "");
if (ssid.Trim().Length > 0)
{
var NetworkConfig = Wifi.ConfiguredNetworks.Where(n => n.Ssid != null && (n.Ssid == ssid || n.Ssid == "\"" + ssid + "\"")).FirstOrDefault();
if (NetworkConfig == null)
{
NetworkConfig = new WifiConfiguration()
{
Ssid = "\"" + ssid + "\"",
StatusField = WifiStatus.Enabled,
Priority = Wifi.ConfiguredNetworks.Max(n => n.Priority) + 1,
PreSharedKey = "\"" + pass + "\""
};
NetworkConfig.AllowedKeyManagement.Set((int)KeyManagementType.WpaPsk);
NetworkConfig.NetworkId = Wifi.AddNetwork(NetworkConfig);
Wifi.SaveConfiguration();
}
if (Wifi.EnableNetwork(NetworkConfig.NetworkId, true))
{
MainActivity.MakeText("WIFI CONNECTED", true);
}
}
}
}
else
{
MainActivity.MakeText("CON SSID: " + ConnectedSSID, false);
}
}
catch (Exception ex)
{
MainActivity.MakeText("ERROR WIFI: " + ex.Message + " " + (ex.StackTrace ?? ""), false);
}
}
