/// <summary>
/// Adds background handler to the collection. <paramref name="handler"/> will be invoked on <paramref name="trigger"/>.
/// </summary>
/// <param name="trigger">Invocation trigger for <paramref name="handler"/>.</param>
/// <param name="handler">Background handler to add.</param>
/// <returns>Self (for fluency).</returns>
public BackgroundServiceCollection AddHandler(IServiceTrigger trigger, IBackgroundHandler handler)
{
Ensure.NotNull(trigger, "trigger");
Ensure.NotNull(handler, "worker");
handlers.Add(new KeyValuePair <IServiceTrigger, IBackgroundHandler>(trigger, handler));
return(this);
}
public BoontonPiStatusViewModel(IBackgroundHandler backgroundHandler, IBoontonPi device) : base(backgroundHandler, device)
{
foreach (var sensor in Device.Sensors)
{
Sensors.Add(new SensorInfoViewModel(sensor));
}
}
public RabbitConsumerViewModel(IBackgroundHandler backgroundHandler, IRabbitControlledManager deviceManager, IPiControlPublisher commandPublisher) : base(backgroundHandler)
{
_deviceManager = deviceManager;
_commandPublisher = commandPublisher;
//_uiContext = SynchronizationContext.Current;
_ = OnUpdateView();
//_ = InitView();
}
public WiznetPiControlViewModel(IBackgroundHandler backgroundHandler, IWiznetPiControl wiz, int pi) : base(backgroundHandler, wiz)
{
//Func<int, bool> CanPiPowerFunc = new Func<int, bool>(CanPiPower());
piNumber = pi;
Wiznet = wiz;
//RaspberryErrorCommand = new MvxAsyncCommand(OnRaspberryError, CanSend, allowConcurrentExecutions: true);
//RaspberryIPCommand = new MvxAsyncCommand(OnRaspberryIP, CanSend, allowConcurrentExecutions: true);
RaspberryPowerCommand = new MvxAsyncCommand(OnRaspberryPower, CanSend, allowConcurrentExecutions: true);
}
protected BoontonPiViewModel(IBackgroundHandler backgroundHandler, IBoontonPi device) : base(backgroundHandler)
{
Device = device;
foreach (var item in Device.Interfaces)
{
Interfaces.Add(new InterfaceInfoViewModel(item));
}
}
void InitializeBackgroundHandler()
{
_messenger = new Messenger();
_logManager = new LogManager();
_notificationService = new SimpleNotificationService();
_backgroundHandler = new SimpleBackgroundHandler(_messenger, _logManager, _notificationService);
_backgroundHandler.RegisterMessage <MasterNavigationMessage>(this, x => MasterViewModel = x.NavigateToViewModel);
_backgroundHandler.RegisterMessage <DetailNavigationMessage>(this, x => DetailViewModel = x.NavigateToViewModel);
//messenger = iMessenger;
//messenger.Register<MasterNavigationMessage>(this, x => MasterViewModel = x.NavigateToViewModel);
//messenger.Register<DetailNavigationMessage>(this, x => DetailViewModel = x.NavigateToViewModel);
}
public BoontonPiControlViewModel(IBackgroundHandler backgroundHandler, IBoontonPi device, IPiControlPublisher commandPublisher) : base(backgroundHandler, device)
{
_commandPublisher = commandPublisher;
foreach (var sensor in Device.Sensors)
{
Sensors.Add(new SensorControlViewModel(sensor, _commandPublisher));
}
StartPollingCommand = new MvxAsyncCommand(OnStartPi);
StopPollingCommand = new MvxAsyncCommand(OnStopPi);
BoontonStartupCommand = new MvxAsyncCommand(OnBoontonStartup);
BoontonCloseSensorsCommand = new MvxAsyncCommand(OnBoontonCloseSensors);
BoontonResetSensorsCommand = new MvxAsyncCommand(OnBoontonResetSensors);
}
public RabbitControlOverviewViewModel(IBackgroundHandler backgroundHandler, IRabbitControlledManager deviceManager, IPiControlPublisher commandPublisher) : base(backgroundHandler)
{
_deviceManager = deviceManager;
_commandPublisher = commandPublisher;
//StartPi1Command = new MvxAsyncCommand(OnStartPi1);
StartAllPisCommand = new MvxAsyncCommand(OnStartAllPis);
//StopPi1Command = new MvxAsyncCommand(OnStopPi1);
StopAllPisCommand = new MvxAsyncCommand(OnStopAllPis);
BoontonStartupCommand = new MvxAsyncCommand(OnBoontonStartup);
BoontonCloseSensorsCommand = new MvxAsyncCommand(OnBoontonCloseSensors);
BoontonResetSensorsCommand = new MvxAsyncCommand(OnBoontonResetSensors);
_ = PollUpdates();
}
public PrimaryOverviewViewModel(IBackgroundHandler backgroundHandler, IWiznetManager wiznetManager, IRabbitControlledManager deviceManager, IPiControlPublisher commandPublisher) : base(backgroundHandler)
{
//_backgroundHandler = backgroundHandler;
_wiznetManager = wiznetManager;
_deviceManager = deviceManager;
_commandPublisher = commandPublisher;
foreach (var item in _wiznetManager.AllWiznets)
{
WiznetStatusControls.Add(new WiznetStatusViewModel(_backgroundHandler, (IWiznetPiControl)item));
}
RabbitConsumer = new RabbitConsumerViewModel(_backgroundHandler, _deviceManager, _commandPublisher);
_ = PollUpdates();
_ = PollRabbitDevices();
}
public WiznetStatusViewModel(IBackgroundHandler backgroundHandler, IWiznetPiControl wizController) : base(backgroundHandler)
{
ConnectCommand = new MvxAsyncCommand(OnConnect, CanConnect);
DisconnectCommand = new MvxAsyncCommand(OnDisconnect, CanDisconnect);
CancelConnectCommand = new MvxAsyncCommand(OnCancelConnect, CanCancelConnect);
//this might be needed to handle initial bindings
//Wiznet = new WiznetControlSCPI();
Wiznet = wizController;
//_ = WiznetStatus();
PiPowerControls = new ObservableCollection <WiznetPiControlViewModel>
{
new WiznetPiControlViewModel(backgroundHandler, Wiznet, 1),
new WiznetPiControlViewModel(backgroundHandler, Wiznet, 2),
};
_backgroundHandler.RegisterMessage <UpdateViewMessage>(this, async x => await OnUpdateView());
_backgroundHandler.RegisterMessage <ViewUnloadedMessage>(this, async x => await OnUnloaded());
}
public BaseWiznetViewModel(IBackgroundHandler backgroundHandler, IWiznetControl wiz) : base(backgroundHandler)
{
Wiznet = wiz;
}
public UpgradeDebugViewModel(IBackgroundHandler backgroundHandler) : base(backgroundHandler)
{
EnterKeyCommand = new MvxCommand(OnSendCmdMessage, CanSendCmdMessage);
StartCmdConsoleCommand = new MvxCommand(OnStartCmdConsole);
StopCmdConsoleCommand = new MvxCommand(OnStopCmdConsole);
}
public Application(IBackgroundHandler backgroundHandler, IWiznetManager wiznetManager)
{
_backgroundHandler = backgroundHandler;
_wiznetManager = wiznetManager;
}
/// <summary>
/// Adds <paramref name="handler"/> triggered every <paramref name="interval"/>.
/// </summary>
/// <param name="collection">Target collection of background workers.</param>
/// <param name="startDelay">Amount of time to first trigger hit after start.</param>
/// <param name="interval">Amount of time between trigger hits.</param>
/// <param name="handler">Handler to execute.</param>
/// <returns>Self (for fluency).</returns>
public static BackgroundServiceCollection AddIntervalDelayedHandler(this BackgroundServiceCollection collection, TimeSpan startDelay, TimeSpan interval, IBackgroundHandler handler)
{
Ensure.NotNull(collection, "collection");
Ensure.NotNull(handler, "handler");
return(collection.AddHandler(new TimerServiceTrigger(startDelay, interval), handler));
}
//private Dictionary<string, Type> ResponseDictionary = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)
//{
// {"status_check_response", typeof(StatusCheck)},
// {"start_poll_response", typeof(StartPoll) }
//};
#endregion
#region Properties
#endregion
#region Constructors
public MasterControlProcessor(IRabbitControlledManager rabbitTracker, IBackgroundHandler backgroundHandler)
{
_rabbitTracker = rabbitTracker;
_backgroundHandler = backgroundHandler;
}
