/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
// Resolve command station
var cs = RailwayState.SelectCommandStation(Entity);
if (cs == null)
{
return(false);
}
cs.AddInput(this);
// Resolve destination blocks
var routes = RailwayState.RouteStates.Where(x => x.Contains(this));
destinationBlocks = routes.Select(x => x.To).ToList();
if (Entity.Block != null)
{
var blockState = RailwayState.BlockStates[Entity.Block];
if ((blockState != null) && (!destinationBlocks.Contains(blockState)))
{
destinationBlocks.Add(blockState);
}
}
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
var splb = lb as SerialPortLocoBuffer;
if (splb != null)
{
var portNames = SerialPort.GetPortNames();
if (!portNames.Contains(splb.PortName))
{
var portName = ui.ChooseComPortName(this);
if (portNames.Contains(portName))
{
// Now we have an available port name
splb.PortName = portName;
}
else
{
// No available port name provided, we cannot be used.
return(false);
}
}
}
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
try
{
client = new MqttClient(Entity.HostName);
client.MqttMsgPublishReceived += onMqttMsgPublishReceived;
client.MqttMsgPublished += onMqttMsgPublished;
client.ConnectionClosed += onMqttConnectionClosed;
// Power on
client.Connect(clientID);
// Subscribe to topics
var topics = getSubscribeTopics();
var qos = topics.Select(x => MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE).ToArray();
client.Subscribe(topics, qos);
}
catch (Exception ex)
{
Log.Error("Failed to connect to MQTT server: " + ex);
return(false);
}
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// Check the IsReadyForUse property afterwards if it has succeeded.
/// </summary>
internal void PrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!readyForUse)
{
readyForUse = TryPrepareForUse(ui, statePersistence);
}
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
var portNames = SerialPort.GetPortNames();
if (!portNames.Contains(Entity.ComPortName))
{
var portName = ui.ChooseComPortName(this);
if (portNames.Contains(portName))
{
// Now we have an available port name
client.PortName = portName;
}
else
{
// No available port name provided, we cannot be used.
return(false);
}
}
// Request for status, this triggers the open process.
PostWorkerAction(() => client.Status());
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
// Do not change the order of initialization
commandStationStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
locStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
junctionStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
signalStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
blockStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
blockGroupStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
routeStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
sensorStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
outputStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence));
// Wrap up
blockStates.Cast <BlockState>().Foreach(x => x.FinalizePrepare());
routeStates.Cast <RouteState>().Foreach(x => x.FinalizePrepare());
// Attach power event
foreach (var csState in commandStationStates)
{
csState.Power.ActualChanged += (s, _) => power.OnActualChanged();
}
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
RailwayState.ModelTime.ActualChanged += (s, _) => OnTimeChanged();
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
CommandStation.AddInput(busyInput);
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
blocks.Clear();
var myBlockEntities = Entity.Module.Blocks.Where(x => x.BlockGroup == Entity);
blocks.AddRange(myBlockEntities.Select(x => RailwayState.BlockStates[x]));
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
var stream = Entity.Sound;
if (stream != null)
{
sound = ui.SoundPlayer.Create(stream);
}
return(true);
}
/// <summary>
/// Default ctor
/// </summary>
internal AppState(IStateUserInterface ui, MainForm mainForm)
{
Application.ThreadException += (s, x) => OnErrorPowerDown(x.Exception);
Application.Idle += (s, x) => OnApplicationIdle();
this.ui = ui;
this.mainForm = mainForm;
var persistence = new StatePersistence();
statePersistence = persistence;
server = new Core.Server.Impl.Server();
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
try
{
discoveryBroadcaster.Start();
}
catch (Exception ex)
{
Log.Error("Failed to start discovery broadcaster: " + ex);
return(false);
}
try
{
localWorkerService = new LocalWorkerServiceImpl(this, Log);
grpcServer = new Server
{
Services = { LocalWorkerService.BindService(localWorkerService) },
Ports = { new ServerPort("0.0.0.0", Entity.APIPort, ServerCredentials.Insecure) }
};
grpcServer.Start();
}
catch (Exception ex)
{
Log.Error("Failed to start GRPC server: " + ex);
return(false);
}
try
{
client = new MqttClient(Entity.HostName);
client.MqttMsgPublishReceived += onMqttMsgPublishReceived;
client.MqttMsgPublished += onMqttMsgPublished;
client.ConnectionClosed += onMqttConnectionClosed;
// Power on
client.Connect(clientID);
// Subscribe to topics
var topics = getSubscribeTopics();
var qos = topics.Select(x => MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE).ToArray();
client.Subscribe(topics, qos);
}
catch (Exception ex)
{
Log.Error("Failed to connect to MQTT server: " + ex);
return(false);
}
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (Entity.Loc != null)
{
loc = RailwayState.LocStates[Entity.Loc];
if (loc == null)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
var cs = RailwayState.SelectCommandStation(Entity);
if (cs == null)
{
return(false);
}
this.statePersistence = statePersistence;
cs.AddLoc(this);
commandStation = cs;
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
var cs = SelectCommandStation();
if (cs == null)
{
return(false);
}
cs.AddJunction(this);
commandStation = cs;
RailwayState.Power.ActualChanged += OnPowerActualChanged;
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
var index = 0;
while (index < actions.Count)
{
var x = (EntityState)actions[index];
x.PrepareForUse(ui, statePersistence);
if (!x.IsReadyForUse)
{
actions.RemoveAt(index);
}
else
{
index++;
}
}
return(actions.Any());
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
// Load state
this.statePersistence = statePersistence;
bool closed;
if (statePersistence.TryGetBlockState(RailwayState, this, out closed))
{
Closed.Requested = closed;
}
junctions.Clear();
var myJunctionEntities = Entity.Module.Junctions.Where(x => x.Block == Entity);
junctions.AddRange(myJunctionEntities.Select(x => RailwayState.JunctionStates[x]));
var groupEntity = Entity.BlockGroup;
blockGroup = (groupEntity != null) ? RailwayState.BlockGroupStates[groupEntity] : null;
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
var fromBlock = routes[0].From as IBlock;
if (fromBlock == null)
{
return(false);
}
from = RailwayState.BlockStates[fromBlock];
var lastRoute = routes[routes.Length - 1];
var toBlock = lastRoute.To as IBlock;
if (toBlock == null)
{
return(false);
}
to = RailwayState.BlockStates[toBlock];
destinationReachedTrigger.PrepareForUse(ui, statePersistence);
foreach (var route in routes)
{
foreach (var item in route.CrossingJunctions)
{
var junctionState = RailwayState.JunctionStates[item.Junction];
var state = item.Accept(Default <JunctionWithStateBuilder> .Instance, junctionState);
if (state == null)
{
return(false);
}
crossingJunctions.Add(state);
hasNonStraightSwitches |= state.IsNonStraight;
}
}
events.ForEach(x => x.PrepareForUse(ui, statePersistence));
permissions.PrepareForUse(ui, statePersistence);
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
// Resolve block.
var entity = Entity;
block = (entity.Block != null) ? RailwayState.BlockStates[entity.Block] : null;
if (block == null)
{
return(false);
}
// Resolve command station
var cs = RailwayState.SelectCommandStation(Entity);
if (cs == null)
{
return(false);
}
commandStation = cs;
commandStation.AddSignal(this);
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
if (!base.TryPrepareForUse(ui, statePersistence))
{
return(false);
}
/*var portNames = SerialPort.GetPortNames();
* if (!portNames.Contains(Entity.ComPortName))
* {
* var portName = ui.ChooseComPortName(this);
* if (portNames.Contains(portName))
* {
* // Now we have an available port name
* sender.PortName = portName;
* }
* else
* {
* // No available port name provided, we cannot be used.
* return false;
* }
* }*/
return(true);
}
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected abstract bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence);
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
activateTrigger.PrepareForUse(ui, statePersistence);
deActivateTrigger.PrepareForUse(ui, statePersistence);
return(base.TryPrepareForUse(ui, statePersistence));
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
sensor = RailwayState.SensorStates[Entity.Sensor];
return(sensor != null);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// Check the IsReadyForUse property afterwards if it has succeeded.
/// </summary>
void IRailwayState.PrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
PrepareForUse(ui, statePersistence);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
return(true);
}
/// <summary>
/// Prepare this state for use in a live railway.
/// Make sure all relevant connections to other state objects are resolved.
/// </summary>
/// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns>
protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence)
{
junction = RailwayState.JunctionStates[Entity.Junction] as IInitializationJunctionState;
return(junction != null);
}
