async Task <IEnumerable <WifiNetworkDto> > FindInternal(FindDelegateBulk findMethod)
{
var delimiter = '\t';
var lstRes = new List <WifiNetworkDto>();
using (var fs = new FileStream(_filePathCSV, FileMode.Open, FileAccess.Read))
{
using (var fr = new StreamReader(fs, Constants.UNIVERSAL_ENCODING))
{
// skip header
var ss2 = await fr.ReadLineAsync();
while (!fr.EndOfStream)
{
var lineFromCSV = await fr.ReadLineAsync();
if (string.IsNullOrWhiteSpace(lineFromCSV))
{
continue;
}
var wifiDtoFromFile = WifiNetworkDto.GetWifiDtoFromString(lineFromCSV, delimiter);
if (findMethod(wifiDtoFromFile))
{
lstRes.Add(wifiDtoFromFile);
}
}
}
}
return(lstRes);
}
public List <WifiNetworkDto> GetActiveWifiNetworks()
{
var wifiNetworks = new List <WifiNetworkDto>();
var wifiManager = (WifiManager)Android.App.Application.Context.GetSystemService(Android.Content.Context.WifiService);
//wifiManager.SetWifiEnabled(false);
//wifiManager.SetWifiEnabled(true);
wifiManager.StartScan();
//var networks = wifiManager.ConfiguredNetworks;
//var connectionInfo = wifiManager.ConnectionInfo;
var results = wifiManager.ScanResults;
foreach (ScanResult nw in results)
{
var netw = new WifiNetworkDto(wifiManager.ConnectionInfo?.BSSID)
{
BssID = nw.Bssid.ToUpper(),
Name = nw.Ssid,
NetworkType = nw.Capabilities,
Level = nw.Level,
IsEnabled = true
};
if (netw.IsIgnoredNetwork)
{
continue;
}
wifiNetworks.Add(netw);
}
return(wifiNetworks);
}
public async Task DoSave(WifiNetworkDto theOne = null)
{
try
{
Device.BeginInvokeOnMainThread(() => {
IsBusy = true;
});
List <WifiNetworkDto> lst;
if (DumpRawList)
{
lst = new List <WifiNetworkDto>(WifiNetworks);
await mgr.DumpRawListAsync(lst);
}
else
{
lst = new List <WifiNetworkDto>();
if (null == theOne)
{
if (WifiNetworksSaveList.Count > 0)
{
lst.AddRange(WifiNetworksSaveList);
}
else
{
lst.AddRange(WifiNetworks);
}
}
else
{
lst.Add(theOne);
}
await mgr.SaveToCSVAsync(lst);
}
}
catch
{
IsFailed = true;
}
finally
{
WifiNetworksSaveList.Clear();
Device.BeginInvokeOnMainThread(() => {
IsBusy = false;
});
}
}
public void CreateUnixFiles(WifiNetworkDto network)
{
var sdCardPathDCIM = GetSDCardDir();
var pwdFileName = "";
if (network.NetworkType.Contains("[WEP]"))
{
/*
* network={
* ssid="JODEL"
* key_mgmt=NONE
* wep_key0="1234567..."
* wep_tx_keyidx=0
* }
*/
}
else
{
pwdFileName = network.BssID.ReplaceNullSafe(":", "-") + "--1";
var fn1 = Path.Combine(sdCardPathDCIM, pwdFileName + ".sh");
using (var fsw = new FileStream(fn1, FileMode.Create))
{
using (var fw = new StreamWriter(fsw, Constants.UNIVERSAL_ENCODING))
{
// write header
fw.Write("#!/bin/bash" + '\xA');
fw.Write($"wpa_passphrase \"{network.Name}\" {network.Password} | sudo tee /mnt/sdb/{pwdFileName}.conf" + '\xA');
}
}
}
var connectFileName = network.BssID.ReplaceNullSafe(":", "-") + "--2";
var fn2 = Path.Combine(sdCardPathDCIM, connectFileName + ".sh");
using (var fsw = new FileStream(fn2, FileMode.Create))
{
using (var fw = new StreamWriter(fsw, Constants.UNIVERSAL_ENCODING))
{
// write header
fw.Write("#!/bin/bash" + '\xA');
fw.Write($"wpa_supplicant -i wlan0 -c /mnt/sdb/{pwdFileName}.conf" + '\xA');
}
}
}
//public void SaveToJSON(List<WifiNetworkDto> wifiNetworks)
//{
// JsonSerializerSettings settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.All };
// string str = JsonConvert.SerializeObject(wifiNetworks, settings);
// var filePathJSON = string.Format(filePathTemplateJSON, DateTime.Now.ToString("yyyyMMdd-HHmm"));
// System.IO.File.WriteAllText(filePathJSON, str);
//}
public async Task <WifiConnectionInfo> ConnectAsync(WifiNetworkDto network)
{
WifiConnectionInfo info2 = null;
info2 = TryConnectViaMethod(network);
if (info2 != null)
{
var coords = await GetCoordsAsync();
if (coords != null)
{
info2.FirstCoordLat = coords.Item1;
info2.FirstCoordLong = coords.Item2;
info2.FirstCoordAlt = coords.Item3;
info2.FirstConnectWhen = DateTime.Now;
}
info2.RouterWebUIIP = "http://" + info2.RouterWebUIIP;
}
return(info2);
}
public async Task ActualizeCoordsWifiNetworkAsync(WifiNetworkDto network)
{
var wifiManager = (WifiManager)Android.App.Application.Context.GetSystemService(Android.Content.Context.WifiService);
wifiManager.StartScan();
var networks = wifiManager.ConfiguredNetworks;
var connectionInfo = wifiManager.ConnectionInfo;
var results = wifiManager.ScanResults;
int signalLevel = 0;
bool networkWasFound = false;
for (int i = 0; i < wifiManager.ScanResults.Count; i++)
{
var n = wifiManager.ScanResults[i];
if (n.Ssid == network.Name)
{
networkWasFound = true;
signalLevel = n.Level;
break;
}
}
if (networkWasFound)
{
var coords2 = await GetCoordsAsync();
network.CoordsAndPower.Add(new CoordsAndPower
{
Lat = coords2.Item1,
Long = coords2.Item2,
Alt = coords2.Item3,
Level = signalLevel,
When = DateTime.Now
});
network.LastCoordLat = coords2.Item1;
network.LastCoordLong = coords2.Item2;
network.LastCoordAlt = coords2.Item3;
}
}
public async Task <WifiNetworkDto> FindWifiInCSV(WifiNetworkDto nw, bool byBssIdOnly)
{
WifiNetworkDto res = null;
try
{
if (!System.IO.File.Exists(_filePathCSV))
{
return(null);
}
res = await FindInternal(nw, byBssIdOnly, (nw1, wifiDtoFromFile) => {
return((byBssIdOnly && nw1.BssID.ToUpper() == wifiDtoFromFile.BssID.ToUpper()) || (nw1.Name == wifiDtoFromFile.Name && !byBssIdOnly && nw1.BssID.ToUpper() == wifiDtoFromFile.BssID.ToUpper()));
});
if (byBssIdOnly)
{
return(res);
}
if (res == null)
{
res = await FindInternal(nw, byBssIdOnly, (nw1, wifiDtoFromFile) =>
{
return(nw1.BssID.ToUpper() == wifiDtoFromFile.BssID.ToUpper());
});
}
if (res == null)
{
res = await FindInternal(nw, byBssIdOnly, (nw1, wifiDtoFromFile) =>
{
return(nw1.Name == wifiDtoFromFile.Name);
});
}
}
catch (Exception ex)
{
Log.Error(TAG, "FindWifiInCSV " + ex.Message);
}
return(res);
}
public async Task DumpRawListAsync(List <WifiNetworkDto> wifiNetworksOnAir)
{
try
{
var hasPermission = await Utils.CheckPermissions(Plugin.Permissions.Abstractions.Permission.Storage);
if (!hasPermission)
{
return;
}
var fileAlreadyExists = System.IO.File.Exists(_filePathRawDumpCSV);
using (var fsw = new FileStream(_filePathRawDumpCSV, fileAlreadyExists? FileMode.Append : FileMode.Create))
{
using (var fw = new StreamWriter(fsw, Constants.UNIVERSAL_ENCODING))
{
if (!fileAlreadyExists)
{
// write header
await fw.WriteLineAsync("Name Bssid Level TimeUtc Lat Long Alt");
}
foreach (var wifiOnAir in wifiNetworksOnAir)
{
await fw.WriteLineAsync($"{WifiNetworkDto.ToStringInCSV (wifiOnAir.Name)}\t{wifiOnAir.BssID}\t{wifiOnAir.Level}\t{DateTime.UtcNow.ToString(_cultUS)}\t{wifiOnAir.LastCoordLat}\t{wifiOnAir.LastCoordLong}\t{wifiOnAir.LastCoordAlt}");
}
}
}
}
catch (Exception ex)
{
Log.Error(TAG, "DumpRawListAsync " + ex.Message);
throw ex;
}
finally
{
}
}
public static WifiNetworkDto GetExistingWifiDto(this List <WifiNetworkDto> lst1, WifiNetworkDto wifiDtoFromFile)
{
if (string.IsNullOrEmpty(wifiDtoFromFile.BssID))
{
var foundByName = lst1.FirstOrDefault(r => r.Name == wifiDtoFromFile.Name);
return(foundByName);
}
var foundByBssId = lst1.FirstOrDefault(r => r.BssID.ToUpper() == wifiDtoFromFile.BssID.ToUpper());
return(foundByBssId);
}
WifiConnectionInfo TryConnectViaMethod(WifiNetworkDto dto)
{
string bssid = dto.BssID;
string ssid = dto.Name;
string password = dto.Password;
var formattedSsid = $"\"{ssid}\"";
var formattedPassword = $"\"{password}\"";
WifiConnectionInfo info2 = null;
var wifiConfig = new WifiConfiguration
{
Bssid = bssid,
Ssid = formattedSsid,
Priority = Constants.WIFI_CONFIG_PRIORITY
};
if (dto.NetworkType.Contains("[WEP]"))
{
// for WEP
wifiConfig.WepKeys[0] = formattedPassword;
wifiConfig.WepTxKeyIndex = 0;
wifiConfig.AllowedKeyManagement.Set((int)KeyManagementType.None);
wifiConfig.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Rsn);
wifiConfig.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Wep40);
wifiConfig.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Wpa);
wifiConfig.AllowedGroupCiphers.Set((int)Android.Net.Wifi.GroupCipherType.Wep104);
}
else
if (dto.NetworkType.Contains("[WPA"))
{
//wifiConfig.AllowKeyManagement.Set((int)KeyManagementType.WpaPsk);
wifiConfig.PreSharedKey = formattedPassword;
}
else
{
// open networks
wifiConfig.AllowedProtocols.Set((int)Android.Net.Wifi.ProtocolType.Rsn);
wifiConfig.AllowedKeyManagement.Set((int)KeyManagementType.None);
}
var wifiManager = (WifiManager)Android.App.Application.Context.GetSystemService(Android.Content.Context.WifiService);
var connManager = (ConnectivityManager)Android.App.Application.Context.GetSystemService(Android.Content.Context.ConnectivityService);
var ni1 = connManager.ActiveNetworkInfo;
if (ni1 != null && ni1.IsConnected && ni1.Type == ConnectivityType.Wifi)
{
//WifiConnectionInfo info = new WifiConnectionInfo
//{
// FirstConnectMac = wifiManager.ConnectionInfo.MacAddress,
//};
return(null);
}
else
{
wifiManager.SetWifiEnabled(true);
var addNetworkIdx = wifiManager.AddNetwork(wifiConfig);
var bd = wifiManager.Disconnect();
var enableNetwork = wifiManager.EnableNetwork(addNetworkIdx, true);
var brc = wifiManager.Reconnect();
DhcpInfo dhcpInfo = wifiManager.DhcpInfo;
//byte[] ipAddress = BitConverter.GetBytes(dhcpInfo.Gateway);
int gwip = wifiManager.DhcpInfo.Gateway;
Task.Delay(500);
gwip = wifiManager.DhcpInfo.Gateway;
var gwAddr = (gwip & 0xFF) + "." +
((gwip >> 8) & 0xFF) + "." +
((gwip >> 16) & 0xFF) + "." +
((gwip >> 24) & 0xFF);
info2 = new WifiConnectionInfo
{
FirstConnectMac = wifiManager.ConnectionInfo.MacAddress,
// https://theconfuzedsourcecode.wordpress.com/2015/05/16/how-to-easily-get-device-ip-address-in-xamarin-forms-using-dependencyservice/
RouterWebUIIP = gwAddr //DependencyService.Get<IIPAddressManager>().GetIPAddress(),
};
}
var isConnectedToAP = wifiManager.ConnectionInfo.BSSID != "00:00:00:00:00:00" &&
info2.RouterWebUIIP != "127.0.0.1" &&
info2.RouterWebUIIP != "0.0.0.0";
return(isConnectedToAP ? info2 : null);
}
public async Task SaveToCSVAsync(List <WifiNetworkDto> wifiNetworksOnAir)
{
FileStream fsBAK = null;
var delimiter = '\t';
try
{
//await RequestStorageWritePermission();
//var newStatus = await CrossPermissions.Current.RequestPermissionsAsync(Plugin.Permissions.Abstractions.Permission.Storage);
//var br = RequestExternalStoragePermissionIfNecessary(RC_WRITE_EXTERNAL_STORAGE_PERMISSION);
var hasPermission = await Utils.CheckPermissions(Plugin.Permissions.Abstractions.Permission.Storage);
if (!hasPermission)
{
return;
}
//RequestPermissions(PERMISSIONS_TO_REQUEST, requestCode);
Android.Util.Log.Info(TAG, "Saving CSV in BAK as " + _filePathCSVBAK);
var csvAlreadyExists = System.IO.File.Exists(_filePathCSV);
if (csvAlreadyExists)
{
if (System.IO.File.Exists(_filePathCSVBAK))
{
//System.IO.File.Delete(_filePathCSVBAK);
}
// works in 2017, busted in 2019 - "Access denied"
//System.IO.File.Copy(_filePathCSV, _filePathCSVBAK, true);
await SafeFileCopy(_filePathCSV, _filePathCSVBAK);
fsBAK = new FileStream(_filePathCSVBAK, FileMode.Open);
}
var alreadySavedWifis = new List <WifiNetworkDto>();
var s = "";
using (var fsw = new FileStream(_filePathCSV, FileMode.Create))
{
using (var fw = new StreamWriter(fsw, Constants.UNIVERSAL_ENCODING))
{
// write header
await fw.WriteLineAsync($"Name{delimiter}Bssid{delimiter}Password{delimiter}IsBanned{delimiter}NetworkType{delimiter}Provider{delimiter}WpsPin{delimiter}FirstConnectWhen{delimiter}FirstConnectPublicIP{delimiter}RouterWebUIIP{delimiter}FirstConnectMac{delimiter}FirstCoordLat{delimiter}FirstCoordLong{delimiter}FirstCoordAlt{delimiter}LastCoordLat{delimiter}LastCoordLong{delimiter}LastCoordAlt{delimiter}");
if (csvAlreadyExists)
{
using (var sr = new StreamReader(fsBAK, Constants.UNIVERSAL_ENCODING))
{
var isHeaderline = true;
while (!sr.EndOfStream)
{
s = await sr.ReadLineAsync();
// skip header from BAK
if (isHeaderline)
{
isHeaderline = false;
continue;
}
WifiNetworkDto wifiDtoFromFile = WifiNetworkDto.GetWifiDtoFromString(s, delimiter);
var wifiOnAir = wifiNetworksOnAir.GetExistingWifiDto(wifiDtoFromFile);
if (wifiOnAir == null)
{
await fw.WriteLineAsync(s);
}
else
{
var res = WifiNetworkDto.NetworkToStringInCSV(wifiOnAir, delimiter);
await fw.WriteLineAsync(res);
alreadySavedWifis.Add(wifiOnAir);
}
}
}
}
foreach (var wifiOnAir in wifiNetworksOnAir)
{
var wifiAlreadySaved = alreadySavedWifis.GetExistingWifiDto(wifiOnAir);
if (wifiAlreadySaved == null)
{
var res = WifiNetworkDto.NetworkToStringInCSV(wifiOnAir, delimiter);
await fw.WriteLineAsync(res);
}
}
}
}
System.IO.File.Delete(_filePathCSVBAK);
}
catch (Exception ex)
{
Log.Error(TAG, "SaveToCSV " + ex.Message);
throw;
}
finally
{
fsBAK?.Close();
fsBAK?.Dispose();
}
}
async Task <WifiNetworkDto> FindInternal(WifiNetworkDto nw, bool byBssIdOnly, FindDelegate findMethod)
{
WifiNetworkDto wifiDtoFromFile;
var delimiter = '\t';
if (UseCachedNetworkLookup)
{
if (_CachedCSVNetworkList.Count == 0)
{
#region Populate CSV cache
using (var fs = new FileStream(_filePathCSV, FileMode.Open, FileAccess.Read))
{
using (var fr = new StreamReader(fs, Constants.UNIVERSAL_ENCODING))
{
// skip header
var ss2 = fr.ReadLine();
while (!fr.EndOfStream)
{
var lineFromCSV = fr.ReadLine();
if (string.IsNullOrWhiteSpace(lineFromCSV))
{
continue;
}
wifiDtoFromFile = WifiNetworkDto.GetWifiDtoFromString(lineFromCSV, delimiter);
_CachedCSVNetworkList.Add(wifiDtoFromFile);
}
}
}
#endregion
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Refactor lookup code, also do the same for FindWifiInCSV()
// Use FindDelegate
var wifiDtoFromFileKVP = _CachedCSVNetworkList.FirstOrDefault(
(nwFromCache) => {
if (string.IsNullOrEmpty(nwFromCache.BssID))
{
return(nwFromCache.Name == nw.Name);
}
if (string.IsNullOrEmpty(nw.BssID))
{
return(nwFromCache.Name == nw.Name);
}
else
{
return(nwFromCache.BssID.ToUpper() == nw.BssID.ToUpper());
}
});
wifiDtoFromFile = wifiDtoFromFileKVP;
}
else
{
using (var fs = new FileStream(_filePathCSV, FileMode.Open, FileAccess.Read))
{
using (var fr = new StreamReader(fs, Constants.UNIVERSAL_ENCODING))
{
// skip header
var ss2 = await fr.ReadLineAsync();
while (!fr.EndOfStream)
{
var lineFromCSV = await fr.ReadLineAsync();
if (string.IsNullOrWhiteSpace(lineFromCSV))
{
continue;
}
wifiDtoFromFile = WifiNetworkDto.GetWifiDtoFromString(lineFromCSV, delimiter);
if (findMethod(nw, wifiDtoFromFile))
{
return(wifiDtoFromFile);
}
}
}
}
wifiDtoFromFile = null;
}
return(wifiDtoFromFile);
}
