public HardwareManager()
{
var extensions = Banshee.IO.Provider.GetOrderedExtensions(
"/Banshee/Platform/HardwareManager",
"Banshee.Hardware.Gio", "Banshee.HalBackend.HardwareManager"
);
foreach (var node in extensions)
{
try {
manager = (IHardwareManager)node.CreateInstance(typeof(IHardwareManager));
Log.DebugFormat("Loaded HardwareManager backend: {0}", node.Id);
break;
} catch (Exception e) {
Log.Exception("Hardware manager extension failed to load", e);
}
}
if (manager == null)
{
throw new Exception("No HardwareManager extensions could be loaded. Hardware support will be disabled.");
}
manager.DeviceAdded += OnDeviceAdded;
manager.DeviceRemoved += OnDeviceRemoved;
ServiceManager.Get <DBusCommandService> ().ArgumentPushed += OnCommandLineArgument;
AddinManager.AddExtensionNodeHandler("/Banshee/Platform/HardwareDeviceProvider", OnExtensionChanged);
}
public TroubleshootingPage()
{
_hardwareManager = DependencyService.Get <IHardwareManager>();
BluetoothOn = _hardwareManager.BluetoothPoweredOn;
MicPermissionOK = _hardwareManager.HasMicrophonePermission;
InitializeComponent();
}
public void Dispose()
{
lock (this) {
if (manager != null)
{
manager.DeviceAdded -= OnDeviceAdded;
manager.DeviceRemoved -= OnDeviceRemoved;
manager.Dispose();
manager = null;
}
ServiceManager.Get <DBusCommandService> ().ArgumentPushed -= OnCommandLineArgument;
if (custom_device_providers != null)
{
foreach (ICustomDeviceProvider provider in custom_device_providers.Values)
{
provider.Dispose();
}
custom_device_providers.Clear();
custom_device_providers = null;
}
AddinManager.RemoveExtensionNodeHandler("/Banshee/Platform/HardwareDeviceProvider", OnExtensionChanged);
}
}
public HardwareManager()
{
foreach (TypeExtensionNode node in AddinManager.GetExtensionNodes("/Banshee/Platform/HardwareManager"))
{
try {
if (manager != null)
{
throw new Exception(String.Format(
"A HardwareManager has already been loaded ({0}). Only one can be loaded.",
manager.GetType().FullName));
}
manager = (IHardwareManager)node.CreateInstance(typeof(IHardwareManager));
} catch (Exception e) {
Log.Warning("Hardware manager extension failed to load", e.Message);
}
}
if (manager == null)
{
throw new Exception("No HardwareManager extensions could be loaded. Hardware support will be disabled.");
}
manager.DeviceAdded += OnDeviceAdded;
manager.DeviceRemoved += OnDeviceRemoved;
ServiceManager.Get <DBusCommandService> ().ArgumentPushed += OnCommandLineArgument;
AddinManager.AddExtensionNodeHandler("/Banshee/Platform/HardwareDeviceProvider", OnExtensionChanged);
}
public void GivenNotSupportedTarget_WhenGetCalculatedValue_ThenItThrowsProper()
{
IHardwareManager manager = GivenHardwareManager();
MonitoringTarget notSupported = GetNotSupportedTarget();
Assert.Throws <HardwareCommunicationException>(() => manager.GetCalculatedValue(notSupported));
}
public PublicController(
ILogger <PublicController> logger,
PoolControl poolControl,
IHardwareManager hardwareManager)
{
this.logger = logger;
this.poolControl = poolControl;
this.hardwareManager = hardwareManager;
}
public void GivenInitialTargetsConfig_WhenInstantiateManager_ThenItSetsInitialTargets()
{
IHardwareManager manager = GivenHardwareManager();
IEnumerable <MonitoringTarget> expected = GetConfigurationInitialTargets();
IEnumerable <MonitoringTarget> actual = manager.GetInitialTargets();
Assert.Empty(expected.Except(actual));
}
/// <summary>
/// Initializes a new instance of the <see cref="PoolControlPump"/> class.
/// </summary>
public PoolControlPump(
PoolSettings poolSettings,
SystemState systemState,
IHardwareManager hardwareManager)
{
this.poolSettings = poolSettings;
this.systemState = systemState;
this.hardwareManager = hardwareManager;
}
private void PluginLoader_PluginUnloaded(object sender, IPlugin e)
{
if (e is IHardwarePlugin)
{
var manager = (e as IHardwarePlugin).GetHardwareManager();
Detach(manager);
_manager = null;
}
}
public void GivenTargetConfig_WhenGetAllTargets_ThenItOmitsNotReachableTargets()
{
IHardwareManager manager = GivenHardwareManager();
IEnumerable <MonitoringTarget> allTargets = GetConfigurationAllTargets();
MonitoringTarget notSupported = GetNotSupportedTarget();
IEnumerable <MonitoringTarget> actual = manager.GetAllTargets();
Assert.NotEmpty(allTargets.Except(actual));
Assert.Contains(notSupported, allTargets.Except(actual));
}
/// <summary>
/// Initializes a new instance of the <see cref="PoolControl"/> class.
/// </summary>
public PoolControl(
ILogger <PoolControl> logger,
IHardwareManager hardwareManager,
IStoreService storeService,
int loopDelay = 1000)
{
this.logger = logger;
this.hardwareManager = hardwareManager;
this.storeService = storeService;
this.loopDelay = loopDelay;
}
public void GivenSupportedTarget_WhenGetCalculatedValue_ThenItReturnsProperValue()
{
IHardwareManager manager = GivenHardwareManager();
IEnumerable <MonitoringTarget> initial = manager.GetInitialTargets();
IHardwareInfo hardwareInfo = manager.GetCalculatedValue(initial.First());
Assert.NotNull(hardwareInfo);
Assert.NotNull(hardwareInfo.MainValue);
Assert.NotEmpty(hardwareInfo.ShortName);
Assert.NotEmpty(hardwareInfo.UnitSymbol);
}
public static IHardwareManager GetHardwareManager(this PanaceaServices core)
{
if (_instance == null)
{
lock (_lock)
{
if (_instance == null)
{
_instance = new HardwarePluginWrapper(core);
}
}
}
return(_instance);
}
public ComputerMonitoringManager(IEventAggregator eventHub,
IHardwareManager hardwareManager,
IProcessWatcher watchDog,
IRepository repository,
ITimer refreshCounter) : base(eventHub)
{
_monitoringRefreshCounter = refreshCounter;
_hardwareManager = hardwareManager;
_monitoringTargets = new List <MonitoringTarget>();
_processWatcher = watchDog;
_repository = repository;
SetInitialMonitoringTargets();
SubscribeToEvents();
}
public void GivenMultipleSupportedTargets_WhenGetCalculatedValues_ThenItReturnsProperValue()
{
IHardwareManager manager = GivenHardwareManager();
IEnumerable <MonitoringTarget> expected = GetConfigurationInitialTargets();
IEnumerable <IHardwareInfo> values = manager.GetCalculatedValues(expected.ToList());
Assert.All(values, v =>
{
Assert.NotNull(v);
Assert.NotNull(v.MainValue);
Assert.NotEmpty(v.ShortName);
Assert.NotEmpty(v.UnitSymbol);
});
}
public VariablesModel(PoolControl poolControl, IHardwareManager hardwareManager)
{
var state = poolControl.GetPoolControlInformation().SystemState;
this.Outputs = hardwareManager.GetOutputs().ToArray();
this.Variables = new List <VariableItem>();
this.Variables.Add(VariableItem.Create("Température extérieure", state.AirTemperature));
this.Variables.Add(VariableItem.Create("Température eau brute (sonde)", state.WaterTemperature));
this.Variables.Add(VariableItem.Create("Température min jour", state.PoolTemperatureMinOfTheDay));
this.Variables.Add(VariableItem.Create("Température max jour", state.PoolTemperatureMaxOfTheDay));
this.Variables.Add(VariableItem.Create("Température de consigne", state.PoolTemperatureDecision));
this.Variables.Add(VariableItem.Create("Température du bassin", state.PoolTemperature));
this.Variables.Add(VariableItem.Create("Durée de filtration/jour", state.PumpingDurationPerDayInHours));
this.Variables.Add(VariableItem.Create("Pompe", state.Pump));
}
public void GivenMultipleSupportedTargetsWithOneNotSupported_WhenGetCalculatedValues_ThenItReturnsProperValue()
{
IHardwareManager manager = GivenHardwareManager();
ICollection <MonitoringTarget> expected = GetConfigurationInitialTargets().ToList();
MonitoringTarget notSupported = GetNotSupportedTarget();
expected.Add(notSupported);
int initialCount = expected.Count();
IEnumerable <IHardwareInfo> values = manager.GetCalculatedValues(expected);
Assert.All(values, v =>
{
Assert.NotNull(v);
Assert.NotNull(v.MainValue);
Assert.NotEmpty(v.ShortName);
Assert.NotEmpty(v.UnitSymbol);
});
Assert.Equal(initialCount - 1, expected.Count());
Assert.DoesNotContain(notSupported, expected);
}
private void PluginLoader_PluginLoaded(object sender, IPlugin e)
{
try
{
if (e is IHardwarePlugin)
{
if (_manager != null)
{
Detach(_manager);
}
var manager = (e as IHardwarePlugin).GetHardwareManager();
manager.HandsetStateChanged += Manager_HandsetStateChanged;
manager.LcdButtonChange += Manager_LcdButtonChange;
manager.PowerButtonChange += Manager_PowerButtonChange;
_manager = manager;
}
}
catch (Exception ex)
{
_core.Logger.Error(this, ex.Message);
}
}
public ClientController(PoolControl poolControl, IHardwareManager hardwareManager)
{
this.poolControl = poolControl;
this.hardwareManager = hardwareManager;
}
public SettingsModel(PoolControl poolControl, IHardwareManager hardwareManager)
{
this.poolControl = poolControl;
this.LoadData();
}
void Detach(IHardwareManager manager)
{
manager.HandsetStateChanged -= Manager_HandsetStateChanged;
manager.LcdButtonChange -= Manager_LcdButtonChange;
manager.PowerButtonChange -= Manager_PowerButtonChange;
}
