private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKinds, IList <Engine.Data.Configuration.Device> deviceConfigurations)
{
int deviceCount = 0;
for (int i = 0; i < deviceConfigurations.Count; i++)
{
Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i];
Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration));
if ((deviceKinds & device.Kind) == 0)
{
continue;
}
deviceCount++;
//don't actually add stratum device as a device index
if (device.Kind != DeviceKind.PXY)
{
minerConfiguration.DeviceDescriptors.Add(device);
}
else
{
//only enable the stratum proxy if these devices contain the PXY device
minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy;
minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort;
minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort;
}
}
return(deviceCount);
}
public void ApplyDeviceConfigurationModels(List <Engine.Data.Configuration.Device> deviceConfigurations, List <Engine.Data.Configuration.Coin> coinConfigurations)
{
foreach (DeviceViewModel deviceViewModel in Devices)
{
Engine.Data.Configuration.Device deviceConfiguration = deviceConfigurations.SingleOrDefault(dc => dc.Equals(deviceViewModel));
if (deviceConfiguration != null)
{
deviceViewModel.Enabled = deviceConfiguration.Enabled;
if (String.IsNullOrEmpty(deviceConfiguration.CoinSymbol))
{
deviceViewModel.Coin = null;
}
else
{
Engine.Data.Configuration.Coin coinConfiguration = coinConfigurations.SingleOrDefault(
cc => cc.CryptoCoin.Symbol.Equals(deviceConfiguration.CoinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinConfiguration != null)
{
deviceViewModel.Coin = coinConfiguration.CryptoCoin;
}
}
}
else
{
deviceViewModel.Enabled = true;
Engine.Data.Configuration.Coin coinConfiguration = coinConfigurations.SingleOrDefault(
cc => cc.CryptoCoin.Symbol.Equals(KnownCoins.BitcoinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinConfiguration != null)
{
deviceViewModel.Coin = coinConfiguration.CryptoCoin;
}
}
}
}
public static List <Engine.Data.Configuration.Device> ToModelObjects(this List <Remoting.Data.Transfer.Configuration.Device> transferObjects)
{
List <Engine.Data.Configuration.Device> modelObjects = new List <Engine.Data.Configuration.Device>();
foreach (Remoting.Data.Transfer.Configuration.Device transferConfig in transferObjects)
{
Engine.Data.Configuration.Device modelObject = ObjectCopier.CloneObject <Remoting.Data.Transfer.Configuration.Device, Engine.Data.Configuration.Device>(transferConfig);
modelObjects.Add(modelObject);
}
return(modelObjects);
}
public void ApplyDeviceConfigurationModels(List <Engine.Data.Configuration.Device> deviceConfigurations, List <Engine.Data.Configuration.Coin> coinConfigurations)
{
foreach (DeviceViewModel deviceViewModel in Devices.Where(d => d.Kind != DeviceKind.NET))
{
Engine.Data.Configuration.Device deviceConfiguration = deviceConfigurations.SingleOrDefault(dc => dc.Equals(deviceViewModel));
if (deviceConfiguration != null)
{
deviceViewModel.Enabled = deviceConfiguration.Enabled;
if (String.IsNullOrEmpty(deviceConfiguration.CoinSymbol))
{
deviceViewModel.Coin = null;
}
else
{
Engine.Data.Configuration.Coin coinConfiguration = coinConfigurations.SingleOrDefault(
cc => cc.CryptoCoin.Symbol.Equals(deviceConfiguration.CoinSymbol, StringComparison.OrdinalIgnoreCase));
if (coinConfiguration != null)
{
deviceViewModel.Coin = coinConfiguration.CryptoCoin;
}
}
}
else
{
deviceViewModel.Enabled = true;
Engine.Data.Configuration.Coin btcConfiguration = coinConfigurations.SingleOrDefault(
cc => cc.CryptoCoin.Symbol.Equals(KnownCoins.BitcoinSymbol, StringComparison.OrdinalIgnoreCase));
Engine.Data.Configuration.Coin ltcConfiguration = coinConfigurations.SingleOrDefault(
cc => cc.CryptoCoin.Symbol.Equals(KnownCoins.LitecoinSymbol, StringComparison.OrdinalIgnoreCase));
if (deviceViewModel.SupportsAlgorithm(CoinAlgorithm.Scrypt) && (ltcConfiguration != null))
{
deviceViewModel.Coin = ltcConfiguration.CryptoCoin;
}
else if (deviceViewModel.SupportsAlgorithm(CoinAlgorithm.SHA256) && (btcConfiguration != null))
{
deviceViewModel.Coin = btcConfiguration.CryptoCoin;
}
}
}
}
private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKind, IList <Engine.Data.Configuration.Device> deviceConfigurations)
{
int deviceCount = 0;
for (int i = 0; i < deviceConfigurations.Count; i++)
{
Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i];
Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration));
if (deviceKind != device.Kind)
{
continue;
}
deviceCount++;
minerConfiguration.DeviceDescriptors.Add(device);
}
return(deviceCount);
}
private static bool DeviceConfigurationsDiffer(List <Engine.Data.Configuration.Device> configuration1, List <Engine.Data.Configuration.Device> configuration2)
{
bool configDifferent = configuration1.Count != configuration2.Count;
if (!configDifferent)
{
for (int i = 0; i < configuration1.Count; i++)
{
Engine.Data.Configuration.Device entry1 = configuration1[i];
Engine.Data.Configuration.Device entry2 = configuration2[i];
configDifferent = (!entry1.CoinSymbol.Equals(entry2.CoinSymbol) ||
(entry1.Kind != entry2.Kind) ||
(entry1.Driver != entry2.Driver) ||
(entry1.Path != entry2.Path));
if (configDifferent)
{
break;
}
}
}
return(configDifferent);
}
private void SaveViewModelValuesToConfiguration()
{
engineConfiguration.DeviceConfigurations.Clear();
foreach (Xgminer.Data.Device device in devices)
{
//don't assume 1-to-1 of Devices and ViewModel.Devices
//Devices doesn't include Network Devices
DeviceViewModel viewModel = localViewModel.Devices.Single(vm => vm.Equals(device));
//pull this from coin configurations, not known coins, may not be in CoinChoose
CryptoCoin coin = viewModel.Coin;
Engine.Data.Configuration.Device deviceConfiguration = new Engine.Data.Configuration.Device();
deviceConfiguration.Assign(viewModel);
deviceConfiguration.Enabled = viewModel.Enabled;
deviceConfiguration.CoinSymbol = coin == null ? string.Empty : coin.Symbol;
engineConfiguration.DeviceConfigurations.Add(deviceConfiguration);
}
}
private void ConfigureDevicesForNewUser()
{
Engine.Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single();
for (int i = 0; i < devices.Count; i++)
{
Engine.Data.Configuration.Device deviceConfiguration = new Engine.Data.Configuration.Device()
{
CoinSymbol = coinConfiguration.CryptoCoin.Symbol,
Enabled = true
};
deviceConfiguration.Assign(devices[i]);
engineConfiguration.DeviceConfigurations.Add(deviceConfiguration);
}
engineConfiguration.SaveDeviceConfigurations();
UpdateMiningButtons();
}
private List <Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List <CoinInformation> allProfitableCoins,
List <CoinInformation> sha256ProfitableCoins, List <CoinInformation> scryptProfitableCoins)
{
List <Engine.Data.Configuration.Device> newConfiguration = new List <Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int comboAlgoIterator = 0;
int sha256Iterator = 0;
int scryptIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.Kind == DeviceKind.PXY)
{
Data.Configuration.Coin existingCoinConfig = engineConfiguration.CoinConfigurations.Single(cc => cc.CryptoCoin.Symbol.Equals(existingConfiguration.CoinSymbol, StringComparison.OrdinalIgnoreCase));
//keep Proxies on the same algo - don't know what is pointed at them
if (existingCoinConfig.CryptoCoin.Algorithm == CoinAlgorithm.Scrypt)
{
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
}
else
{
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
}
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && !device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//scrypt only
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, comboAlgoIterator);
comboAlgoIterator++;
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
}
if (comboAlgoIterator >= allProfitableCoins.Count())
{
comboAlgoIterator = 0;
}
if (sha256Iterator >= sha256ProfitableCoins.Count())
{
sha256Iterator = 0;
}
if (scryptIterator >= scryptProfitableCoins.Count())
{
scryptIterator = 0;
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return(newConfiguration);
}
private List<Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List<CoinInformation> allProfitableCoins, List<CoinInformation> sha256ProfitableCoins)
{
List<Engine.Data.Configuration.Device> newConfiguration = new List<Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int gpuIterator = 0;
int amuIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.Kind == DeviceKind.GPU)
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, gpuIterator);
gpuIterator++;
if (gpuIterator >= allProfitableCoins.Count())
gpuIterator = 0;
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, amuIterator);
amuIterator++;
if (amuIterator >= sha256ProfitableCoins.Count())
amuIterator = 0;
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return newConfiguration;
}
private List <Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List <CoinInformation> allProfitableCoins, List <CoinInformation> sha256ProfitableCoins)
{
List <Engine.Data.Configuration.Device> newConfiguration = new List <Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int gpuIterator = 0;
int amuIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.Kind == DeviceKind.GPU)
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, gpuIterator);
gpuIterator++;
if (gpuIterator >= allProfitableCoins.Count())
{
gpuIterator = 0;
}
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, amuIterator);
amuIterator++;
if (amuIterator >= sha256ProfitableCoins.Count())
{
amuIterator = 0;
}
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return(newConfiguration);
}
private void SetAllDevicesToCoinLocally(string coinSymbol)
{
bool wasMining = miningEngine.Mining;
StopMiningLocally();
Engine.Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.SingleOrDefault(c => c.CryptoCoin.Symbol.Equals(coinSymbol));
engineConfiguration.DeviceConfigurations.Clear();
foreach (Xgminer.Data.Device device in devices)
{
//don't assume 1-to-1 of Devices and ViewModel.Devices
//Devices doesn't include Network Devices
DeviceViewModel viewModel = localViewModel.Devices.Single(vm => vm.Equals(device));
Engine.Data.Configuration.Device deviceConfiguration = new Engine.Data.Configuration.Device();
deviceConfiguration.Assign(viewModel);
if (viewModel.Kind == DeviceKind.NET)
{
//assume BTC for Network Devices (for now)
deviceConfiguration.CoinSymbol = NetworkDeviceCoinSymbol;
deviceConfiguration.Enabled = true;
}
else
{
if (viewModel.SupportsAlgorithm(coinConfiguration.CryptoCoin.Algorithm))
deviceConfiguration.CoinSymbol = coinConfiguration.CryptoCoin.Symbol;
else
deviceConfiguration.CoinSymbol = viewModel.Coin == null ? String.Empty : viewModel.Coin.Name;
deviceConfiguration.Enabled = viewModel.Enabled;
}
engineConfiguration.DeviceConfigurations.Add(deviceConfiguration);
}
localViewModel.ApplyDeviceConfigurationModels(engineConfiguration.DeviceConfigurations,
engineConfiguration.CoinConfigurations);
engineConfiguration.StrategyConfiguration.AutomaticallyMineCoins = false;
engineConfiguration.SaveDeviceConfigurations();
engineConfiguration.SaveStrategyConfiguration();
RefreshListViewFromViewModel();
AutoSizeListViewColumns();
if (wasMining)
StartMiningLocally();
else
//so the Start button becomes enabled if we now have a valid config
UpdateMiningButtons();
}
private List<Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List<CoinInformation> allProfitableCoins,
List<CoinInformation> sha256ProfitableCoins, List<CoinInformation> scryptProfitableCoins)
{
List<Engine.Data.Configuration.Device> newConfiguration = new List<Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int comboAlgoIterator = 0;
int sha256Iterator = 0;
int scryptIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && !device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//scrypt only
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
if (scryptIterator >= scryptProfitableCoins.Count())
scryptIterator = 0;
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, comboAlgoIterator);
comboAlgoIterator++;
if (comboAlgoIterator >= allProfitableCoins.Count())
comboAlgoIterator = 0;
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
if (sha256Iterator >= sha256ProfitableCoins.Count())
sha256Iterator = 0;
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return newConfiguration;
}
//each device needs to have a DeviceConfiguration
//this will add any missing ones after populating devices
//for instance if the user starts up the app with a new device
private void AddMissingDeviceConfigurations()
{
const string btcSymbol = KnownCoins.BitcoinSymbol;
bool hasBtcConfigured = engineConfiguration.CoinConfigurations.Exists(c => c.Enabled && c.CryptoCoin.Symbol.Equals(btcSymbol, StringComparison.OrdinalIgnoreCase));
foreach (Xgminer.Data.Device device in devices)
{
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations.FirstOrDefault(
c => (c.Equals(device)));
if (existingConfiguration == null)
{
Engine.Data.Configuration.Device newConfiguration = new Engine.Data.Configuration.Device();
newConfiguration.Assign(device);
//if the user has BTC configured, default to that
if (hasBtcConfigured)
newConfiguration.CoinSymbol = btcSymbol;
newConfiguration.Enabled = true;
engineConfiguration.DeviceConfigurations.Add(newConfiguration);
}
}
}
private List<Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List<CoinInformation> allProfitableCoins,
List<CoinInformation> sha256ProfitableCoins, List<CoinInformation> scryptProfitableCoins)
{
List<Engine.Data.Configuration.Device> newConfiguration = new List<Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int comboAlgoIterator = 0;
int sha256Iterator = 0;
int scryptIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.Kind == DeviceKind.PXY)
{
Data.Configuration.Coin existingCoinConfig = engineConfiguration.CoinConfigurations.Single(cc => cc.CryptoCoin.Symbol.Equals(existingConfiguration.CoinSymbol, StringComparison.OrdinalIgnoreCase));
//keep Proxies on the same algo - don't know what is pointed at them
if (existingCoinConfig.CryptoCoin.Algorithm == CoinAlgorithm.Scrypt)
{
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
}
else
{
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
}
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && !device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//scrypt only
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, comboAlgoIterator);
comboAlgoIterator++;
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
}
if (comboAlgoIterator >= allProfitableCoins.Count())
comboAlgoIterator = 0;
if (sha256Iterator >= sha256ProfitableCoins.Count())
sha256Iterator = 0;
if (scryptIterator >= scryptProfitableCoins.Count())
scryptIterator = 0;
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return newConfiguration;
}
private void SetAllDevicesToCoinLocally(string coinSymbol, bool disableStrategies)
{
bool wasMining = miningEngine.Mining;
StopMiningLocally();
Engine.Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.SingleOrDefault(c => c.CryptoCoin.Symbol.Equals(coinSymbol));
engineConfiguration.DeviceConfigurations.Clear();
foreach (Xgminer.Data.Device device in devices)
{
//don't assume 1-to-1 of Devices and ViewModel.Devices
//Devices doesn't include Network Devices
DeviceViewModel viewModel = localViewModel.Devices.Single(vm => vm.Equals(device));
Engine.Data.Configuration.Device deviceConfiguration = new Engine.Data.Configuration.Device();
deviceConfiguration.Assign(viewModel);
if (viewModel.Kind == DeviceKind.NET)
{
//assume BTC for Network Devices (for now)
deviceConfiguration.CoinSymbol = KnownCoins.BitcoinSymbol;
deviceConfiguration.Enabled = true;
}
else if (viewModel.Kind == DeviceKind.PXY)
{
if (viewModel.SupportsAlgorithm(coinConfiguration.CryptoCoin.Algorithm) &&
//don't change the Algo a Proxy is mining - don't know what is pointed at it
(viewModel.Coin.Algorithm == coinConfiguration.CryptoCoin.Algorithm))
deviceConfiguration.CoinSymbol = coinConfiguration.CryptoCoin.Symbol;
else
deviceConfiguration.CoinSymbol = viewModel.Coin == null ? String.Empty : viewModel.Coin.Name;
deviceConfiguration.Enabled = viewModel.Enabled;
}
else
{
if (viewModel.SupportsAlgorithm(coinConfiguration.CryptoCoin.Algorithm))
deviceConfiguration.CoinSymbol = coinConfiguration.CryptoCoin.Symbol;
else
deviceConfiguration.CoinSymbol = viewModel.Coin == null ? String.Empty : viewModel.Coin.Name;
deviceConfiguration.Enabled = viewModel.Enabled;
}
engineConfiguration.DeviceConfigurations.Add(deviceConfiguration);
}
localViewModel.ApplyDeviceConfigurationModels(engineConfiguration.DeviceConfigurations,
engineConfiguration.CoinConfigurations);
engineConfiguration.SaveDeviceConfigurations();
RefreshListViewFromViewModel();
AutoSizeListViewColumns();
if (wasMining)
{
bool wasAutoMining = engineConfiguration.StrategyConfiguration.AutomaticallyMineCoins;
if (wasAutoMining)
EnableMiningStrategies(false);
StartMiningLocally();
//only re-enable if they were enabled before
if (!disableStrategies && wasAutoMining)
EnableMiningStrategies(true);
}
else
{
if (disableStrategies)
EnableMiningStrategies(false);
//so the Start button becomes enabled if we now have a valid config
UpdateMiningButtons();
}
RefreshStrategiesCountdown();
}
//each device needs to have a DeviceConfiguration
//this will add any missing ones after populating devices
//for instance if the user starts up the app with a new device
private void AddMissingDeviceConfigurations()
{
bool hasBtcConfigured = engineConfiguration.CoinConfigurations.Exists(c => c.Enabled && c.CryptoCoin.Symbol.Equals(KnownCoins.BitcoinSymbol, StringComparison.OrdinalIgnoreCase));
bool hasLtcConfigured = engineConfiguration.CoinConfigurations.Exists(c => c.Enabled && c.CryptoCoin.Symbol.Equals(KnownCoins.LitecoinSymbol, StringComparison.OrdinalIgnoreCase));
foreach (Xgminer.Data.Device device in devices)
{
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations.FirstOrDefault(
c => (c.Equals(device)));
if (existingConfiguration == null)
{
Engine.Data.Configuration.Device newConfiguration = new Engine.Data.Configuration.Device();
newConfiguration.Assign(device);
if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && hasLtcConfigured)
newConfiguration.CoinSymbol = KnownCoins.LitecoinSymbol;
else if (device.SupportsAlgorithm(CoinAlgorithm.SHA256) && hasBtcConfigured)
newConfiguration.CoinSymbol = KnownCoins.BitcoinSymbol;
newConfiguration.Enabled = true;
engineConfiguration.DeviceConfigurations.Add(newConfiguration);
}
}
}
private List <Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List <CoinInformation> allProfitableCoins,
List <CoinInformation> sha256ProfitableCoins, List <CoinInformation> scryptProfitableCoins)
{
List <Engine.Data.Configuration.Device> newConfiguration = new List <Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int comboAlgoIterator = 0;
int sha256Iterator = 0;
int scryptIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && !device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//scrypt only
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
if (scryptIterator >= scryptProfitableCoins.Count())
{
scryptIterator = 0;
}
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, comboAlgoIterator);
comboAlgoIterator++;
if (comboAlgoIterator >= allProfitableCoins.Count())
{
comboAlgoIterator = 0;
}
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
if (sha256Iterator >= sha256ProfitableCoins.Count())
{
sha256Iterator = 0;
}
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return(newConfiguration);
}
