コード例 #1
0
        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);
        }
コード例 #2
0
        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();
            }
        }
コード例 #3
0
        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);
        }