public Session(IReceiver receiver, IAnalysis analysis)
{
Id = Guid.NewGuid();
Receiver = receiver;
DiagnoseOutputEntries = new ReactiveCollection<IDiagnoseOutputEntry>();
Analysis = new ReactiveCollection<IAnalysis>();
Analysis.ItemsAdded.Subscribe(x =>
{
foreach (var diagnoseOutputEntry in DiagnoseOutputEntries)
{
x.ProcessNewDiagnoseOutputEntry(diagnoseOutputEntry);
}
});
Analysis.Add(analysis);
DiagnoseOutputEntries.ItemsAdded.Subscribe(x =>
{
foreach (var analyse in Analysis)
{
analyse.ProcessNewDiagnoseOutputEntry(x);
}
});
}
public void StartReceiving(IReceiver receiver, ILogger logger)
{
Scheduler.Start(() =>
{
int exceptionCount = 0;
var receivingState = ReceivingState.CanContinueReceiving;
while (receivingState == ReceivingState.CanContinueReceiving)
{
try
{
receivingState = Channel.Receive(receiver);
exceptionCount = 0;
}
catch (Exception ex)
{
logger.InfoMessage(new ReceiveFailed { ChannelKey = Key, Exception = ex });
logger.Error("Error in receive loop", ex);
if (++exceptionCount > 9)
{
// We're probably stuck getting the same error forever, let the process crash.
throw new ReceiveFailureException(
"Received repeated errors while listening for messages on channel: " + Key,
ex);
}
}
}
});
}
public void Setup()
{
Helper.SetupTestMessagingWithoutPurging();
MessagingSystem.Events.AddEventHook<ConsoleEventHook>();
_receiver = MessagingSystem.Receiver();
senderNode = MessagingSystem.Sender();
}
public Guid AddSession(IReceiver receiver, IAnalysis analysis)
{
var newSession = new Session(receiver, analysis);
Sessions.Add(newSession);
return newSession.Id;
}
static Invoker VoiceCall, VideoCall, Chat; //Add more commands here
#endregion Fields
#region Constructors
public Command(IReceiver receiver, CommandType type)
{
VoiceCall = receiver.MakeAVoiceCall;
VideoCall = receiver.MakeAVideoCall;
Chat = receiver.StartChat;
SendFile = receiver.SendFile;
Type = type;
}
public void Connect(string portName, int baud, int databits)
{
var port = new SerialPort(portName, baud, Parity.None, databits, StopBits.One);
_link = Factory.GetLink(port, LinkBufferSize, LinkTimeoutModifier);
_sender = new SenderStmContext(_link, _checksum, new SequenceGenerator(), MaxMessageDataSize, MessageTimeoutModifier);
_receiver = new ReceiverStmContext(_link, _checksum, new SequenceGenerator(), MaxMessageDataSize);
_connected = true;
}
public void Disconnect()
{
_sender = null;
_receiver = null;
_link.Close();
_link = null;
_connected = false;
}
public void SetUp()
{
event_hook = new HoldingEventHook();
ObjectFactory.Configure(map => map.For<IEventHook>().Use(event_hook));
node_factory = MessagingSystem.Receiver();
senderNode = MessagingSystem.Sender();
}
private void AddReceiver(IReceiver receiver)
{
string displayName = String.IsNullOrEmpty(receiver.DisplayName)
? ReceiverUtils.GetTypeDescription(receiver.GetType())
: receiver.DisplayName;
ListViewItem lvi = receiversListView.Items.Add(displayName);
lvi.Tag = receiver;
lvi.Selected = true;
}
public ReceiveDataHandler(Topic t, Participant part, IReceiver receiver)
{
topic = t;
bytes = new byte[t.GetSampleMaxSize()];
headerBytes = new byte[FRAGMENT_HEADER_SIZE];
participant = part;
fragmentSize = Globals.MAX_SEGMENT_SIZE;
this.receiver = receiver;
}
public void SetUp()
{
Helper.SetupTestMessaging();
mock_event_hook = Substitute.For<IEventHook>();
ObjectFactory.Configure(map=> map.For<IEventHook>().Use(mock_event_hook));
node_factory = ObjectFactory.GetInstance<IReceiver>();
}
protected ListenerBase(string name, [TypeConverter(typeof(IPEndPointConverter))]IPEndPoint address) : base(name)
{
if(address == null)
throw new ArgumentNullException("address");
_syncRoot = new object();
_address = address;
_receiver = null;
}
public void SetUp()
{
ConfigureMessaging();
_receiver = MessagingSystem.Receiver();
_sender = MessagingSystem.Sender();
MessagingSystem.Events.ClearEventHooks();
MessagingSystem.Events.AddEventHook<ConsoleEventHook>();
}
public ReceivingState Receive(IReceiver receiver)
{
var stream = _queueManager.ReceiveStream(_queueName);
foreach (var message in stream.TakeWhile(message => !_disposed))
{
receiver.Receive(message.Message.Data, new NameValueHeaders(message.Message.Headers),
new TransactionCallback(message.TransactionalScope, message.Message, _delayedMessages));
}
return ReceivingState.StopReceiving;
}
protected override void SetUp()
{
var fiber = new StubFiber();
_mock_first = CreateMock<IReceiver<int>>();
_mock_rest = CreateMock<IReceiver<int>>();
_receiver = new FirstReceiver<int>(fiber,
_mock_first.Object, _mock_rest.Object);
}
public override Command CreateCommand(ConsoleKeyInfo keyInfo, IReceiver receiver)
{
switch (keyInfo.Key)
{
case ConsoleKey.Enter:
return new SubmitCommand(receiver);
case ConsoleKey.Backspace:
return new BackspaceCommand(receiver);
default:
return new InputCharacterCommand(keyInfo.KeyChar, receiver);
}
}
public ChatConsoleActor(string userName,string clientActorPath)
{
_userName = userName;
_clientActorPath = clientActorPath;
_clientActor = ActorSystemContainer.Instance.System.ActorSelection(_clientActorPath).ResolveOne(new TimeSpan(0, 0, 10)).Result;
_clientActor.Tell(new Messages.AttachConsole(Self));
Dictionary<string, object> parameters = new Dictionary<string, object>() { { "actor", _clientActor }, { "userName", _userName } };
//Dictionary<string, object> parameters = new Dictionary<string, object>() { { "filePath", @"c:\logs\fileoutput.txt" } };
_receiver = GlobalIocContainer.Container.IocContainer.Resolve<IReceiver>(parameters);
_commandFactory = GlobalIocContainer.Container.IocContainer.Resolve<CommandFactory>();
_commandManager = new CommandManager();
}
public MessageBroker(IChannel channel, IWorker worker, IReceiver[] receivers, Configuration.HostSection config)
{
this.channel = channel;
this.worker = worker;
this.receivers = receivers.ToLookup(r => r.MessageType);
this.Name = config.Messaging.SenderName;
this.Enabled = config.Messaging.Enabled;
this.Async = config.Messaging.Async;
this.OnlyFromMachineNamed = config.Messaging.Targets.OnlyFromMachineNamed;
this.SharedSecret = config.Messaging.Targets.SharedSecret;
this.Targets = config.Messaging.Targets.AllElements.Select(te => new MessageTarget { Name = te.Name, Address = te.Address, ExceptFromMachineNamed = te.ExceptFromMachineNamed }).ToArray();
}
public ReceivingState Receive(IReceiver receiver)
{
_disposable = _queueManager.Receive(_queueName).Subscribe(message =>
{
Task.Run(() =>
{
receiver.Receive(message.Message.Data, new DictionaryHeaders(message.Message.Headers),
new TransactionCallback(message.QueueContext, message.Message));
});
});
return ReceivingState.StopReceiving;
}
public void SetUp()
{
// Start messaging, put everything in place
Helper.SetupTestMessaging();
_receiver = MessagingSystem.Receiver();
_senderNode = MessagingSystem.Sender();
using (_receiver.Listen(_=>_.Handle<IColourMessage>().With<ColourMessageHandler>())) { }
_senderNode.SendMessage(new GreenMessage());
MessagingSystem.Control.Shutdown(); // should cause message to flush
// Start messaging again with purging:
Helper.SetupTestMessaging();
}
public static IReceiver GetReceiver()
{
if(_receiver == null)
{
try
{
_receiver = new UDPReceiver();
}
catch (System.Exception ex)
{
throw new Exception(ex.Message);
}
}
return _receiver;
}
public void Receive(IReceiver receiver)
{
while (!_disposed)
{
foreach (var data in _queue.GetConsumingEnumerable())
{
using (var stream = new MemoryStream(data))
{
var token = _formatter.Deserialize(stream).As<EnvelopeToken>();
var callback = new InMemoryCallback(this, token);
receiver.Receive(token.Data, token.Headers, callback);
}
}
}
}
public void Bus_PublishedMessage_EachReceiverGetsMessageCopy()
{
Person actual = new Person
{
Id = 5
};
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (IReceiver receiverB1 = busB.CreateReceiver(), receiverB2 = busB.CreateReceiver(), receiverC1 = busC.CreateReceiver())
{
receiverB1.Subscribe <Person>();
receiverB2.Subscribe <Person>();
receiverC1.Subscribe <Person>();
receiverB1.Open();
receiverB2.Open();
receiverC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
publisher.Send(actual);
}
Person b1 = receiverB1.Receive <Person>();
Person b2 = receiverB2.Receive <Person>();
Person c1 = receiverC1.Receive <Person>();
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actual);
b2.ShouldBeEquivalentTo(actual);
c1.ShouldBeEquivalentTo(actual);
}
}
}
public void UnRegisterReceiver <T>(int id, Action <T> action)
{
if (mReceiverDic.ContainsKey(id))
{
for (int i = mReceiverDic[id].Count - 1; i >= 0; --i)
{
IReceiver receiver = mReceiverDic[id][i];
if (receiver != null && receiver.IsType(typeof(T)))
{
Receiver <T> o = receiver as Receiver <T>;
if (o != null && o.Equals(action))
{
mReceiverDic[id].RemoveAt(i);
}
}
}
if (mReceiverDic[id].Count == 0)
{
mReceiverTypeDic.Remove(id);
}
}
}
private InputHandler NewHandler(
PipeReader inputStream,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor?> requestRouter,
ILoggerFactory loggerFactory,
IResponseRouter responseRouter
) =>
new InputHandler(
inputStream,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
_unhandledException,
null,
TimeSpan.FromSeconds(30),
true,
null
);
/// <summary>
/// Process this IRequest and update the given <b>Response</b> with
/// the result.
/// </summary>
/// <remarks>
/// Implementations of this method are free to throw an exception
/// while processing the IRequest. An exception will result in the
/// <b>Response</b> being marked as a failure that the
/// <b>Response</b> result will be the exception itself.
/// </remarks>
/// <param name="response">
/// The <b>Response</b> that will be sent back to the requestor.
/// </param>
/// <exception cref="Exception">
/// If exception occurs during execution.
/// </exception>
protected override void OnRun(Response response)
{
IChannel channel0 = Channel;
Debug.Assert(channel0.Id == 0);
Connection connection = (Connection)channel0.Connection;
Debug.Assert(connection != null);
Peer peer = (Peer)channel0.Receiver;
IReceiver receiver = peer.GetReceiver(ReceiverName);
if (receiver == null)
{
throw new ArgumentException("unknown receiver: " + ReceiverName);
}
response.Result = connection.OpenChannelRequest(ProtocolName,
channel0.Serializer,
receiver,
peer.AssertIdentityToken(peer.DeserializeIdentityToken(IdentityToken)));
}
private void InitializeReceiver(IReceiver receiver)
{
try
{
receiver.Initialize();
receiver.Attach(this);
//LogManager.Instance.SetRootLoggerName(String.Format("Root [{0}]", receiver));
}
catch (Exception ex)
{
try
{
receiver.Terminate();
}
catch
{
// ignored
}
ShowErrorBox("Failed to Initialize Receiver: " + ex.Message);
}
}
private async Task PlayVideo()
{
IReceiver selectedCastDevice = CvChromecastDevices.SelectedItem as IReceiver;
if (selectedCastDevice == null)
{
return;
}
Sender ccSender = new Sender();
await ccSender.ConnectAsync(selectedCastDevice);
IMediaChannel mediaChannel = ccSender.GetChannel <IMediaChannel>();
await ccSender.LaunchAsync(mediaChannel);
MediaStatus mediaStatus = await mediaChannel.LoadAsync(new MediaInformation()
{
ContentId = EnUrl.Text
});
CvChromecastDevices.SelectedItem = null;
await CloseReceiversList();
}
public Connection(
Stream input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
ISerializer serializer)
{
_requestRouter = requestRouter;
_inputHandler = new InputHandler(
input,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
serializer
);
}
//Сохраняет значения сигналов одного приемника в таблицу
private void SaveReceiverDebug(IReceiver receiver)
{
try
{
AddEvent("Сохранение значений сигналов приемника в таблицу");
using (var sav = new ResultSaver(receiver.Name, this))
{
Procent = 10;
int i = 0;
foreach (var sig in receiver.Signals.Values)
{
sav.ValuesToRec(sig.Code, "СигналПриемника", 0, null, receiver.AllowListValues ? sig.Value : new SingleValue(sig.Value.LastMoment));
if (++i % 20 == 0)
{
Procent = 10 + 90.0 * i / (receiver.Signals.Count);
}
}
}
}
catch (Exception ex)
{
AddError("Ошибка подготовки отладочного файла Result", ex);
}
}
public void ReceiverUpdatesMultipleValues_IfMultipleUpdateSettingsAreSpecified()
{
// Arrange
InsertOutMessageInDatastoreWith(Operation.ToBeDelivered, OutStatus.NotApplicable);
IReceiver receiver =
DataStoreReceiverWith(
SettingsToPollOnOutMessages(
filter: "Operation = ToBeDelivered",
updates: new[] { "Operation", "Status" },
values: new[] { "Sending", "Sent" }));
// Act
StartReceiver(receiver);
// Assert
AssertOutMessageIf(
m => m.Operation == Operation.Sending,
message =>
{
Assert.Equal(OutStatus.Sent, message.Status.ToEnum <OutStatus>());
Assert.Equal(Operation.Sending, message.Operation);
});
}
public void MultiTransmitMessageToSingleReceiverTest()
{
bool rcv1Waiting = true;
bool rcv2Waiting = true;
const string channel = "channel";
const string message1 = "message1";
const string message2 = "message2";
ITransmitter <string> transmitter1 = StringChannel.CreateTransmitter(channel);
ITransmitter <string> transmitter2 = StringChannel.CreateTransmitter(channel);
IReceiver <string> receiver1 = StringChannel.CreateReceiver(channel);
receiver1.Received += (sender, args) =>
{
if (args.Message.Equals(message1))
{
rcv1Waiting = false;
}
if (args.Message.Equals(message2))
{
rcv2Waiting = false;
}
};
transmitter1.Send(message1);
transmitter2.Send(message2);
while (rcv1Waiting && rcv2Waiting)
{
Thread.Sleep(200);
}
Assert.IsNotNull(receiver1.LastMessage);
}
/// <summary>
/// Sets a handler for the statistics emitted event of the <see cref="KafkaReceiver"/>.
/// <para>
/// After setting the event handler, the handler will be called on intervals specified by the
/// <see cref="ClientConfig.StatisticsIntervalMs"/> property.
/// </para>
/// </summary>
/// <param name="receiver">The <see cref="KafkaReceiver"/> to set the event handler on</param>
/// <param name="statisticsEmittedHandler">The event handler to be called when the underlying Consumer emits statistics.
/// The statistics is a JSON formatted string as defined here:
/// <a href="https://github.com/edenhill/librdkafka/blob/master/STATISTICS.md">https://github.com/edenhill/librdkafka/blob/master/STATISTICS.md</a>
/// </param>
/// <returns>The same <see cref="IReceiver"/> for method chaining</returns>
/// <exception cref="ArgumentNullException">
/// If <paramref name="receiver"/> or <paramref name="statisticsEmittedHandler"/> is <see langword="null"/>
/// </exception>
/// <exception cref="ArgumentException">
/// If <paramref name="receiver"/> is not a <see cref="KafkaReceiver"/>
/// </exception>
public static IReceiver AddStatisticsEmittedHandler(this IReceiver receiver, EventHandler <string> statisticsEmittedHandler)
{
if (receiver is null)
{
throw new ArgumentNullException(nameof(receiver));
}
if (statisticsEmittedHandler is null)
{
throw new ArgumentNullException(nameof(statisticsEmittedHandler));
}
var kafkaReceiver = (receiver as ConfigReloadingProxy <IReceiver>)?.Object as KafkaReceiver;
kafkaReceiver ??= receiver as KafkaReceiver;
if (kafkaReceiver is null)
{
throw new ArgumentException($"Receiver should be of type {nameof(KafkaReceiver)} or a proxy class wrapping {nameof(KafkaReceiver)}", nameof(receiver));
}
kafkaReceiver.StatisticsEmitted += statisticsEmittedHandler;
return(receiver);
}
/// <summary>
/// Handles the VirtualPortRemoved event of the this._virtualComPortsFinder control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="LaJust.EIDSS.Communications.Hardware.VirtualComPortEventArgs"/> instance containing the event data.</param>
private void VirtualComPortsFinder_VirtualPortRemoved(object sender, VirtualComPortEventArgs e)
{
Trace.TraceInformation("{0}.VirtualPortRemoved: PNPDeviceID={1}", CLASSNAME, e.PnpDeviceId);
Trace.Indent();
IReceiver receiver = null;
int count;
lock (this.recievers)
{
if (this.recievers.ContainsKey(e.PnpDeviceId))
{
receiver = this.recievers[e.PnpDeviceId];
this.recievers.Remove(e.PnpDeviceId);
}
count = this.recievers.Count;
}
if (receiver != null)
{
// UnHook event handlers
receiver.StrikeDetected -= this.OnStrikeDetected;
receiver.PanelButtonPressed -= this.OnPanelButtonPressed;
receiver.DeviceStatusUpdate -= this.OnDeviceStatusUpdate;
receiver.DeviceRegistered -= this.OnDeviceRegistered;
receiver.Dispose();
}
this.OnReceiverCountChanged(this, new ReceiverCountEventArgs()
{
Count = count
});
Trace.Unindent();
}
public OutputHandler(
PipeWriter pipeWriter,
ISerializer serializer,
IReceiver receiver,
IScheduler scheduler,
ILogger <OutputHandler> logger
)
{
_pipeWriter = pipeWriter;
_serializer = serializer;
_logger = logger;
_queue = new Subject <object>();
_outputIsFinished = new TaskCompletionSource <object>();
_disposable = new CompositeDisposable {
_queue
.ObserveOn(scheduler)
.Where(receiver.ShouldFilterOutput)
.Select(value => Observable.FromAsync(ct => ProcessOutputStream(value, ct)))
.Concat()
.Subscribe(),
_queue
};
}
public void AddReceiver(IReceiver receiver)
{
/*
* Low = Lowest Importance
* Will be invoked first, therefore it will NOT have final judgement on the data being passed.
*/
int rank = -1;
switch (receiver.GetType().Name)
{
case nameof(ModulesPage): rank = 0; break;
case nameof(FiltersPage): rank = 1; break;
case nameof(ConnectionPage): rank = 2; break;
case nameof(PacketLoggerFrm): rank = 3; break;
default:
throw new ArgumentException("Unrecognized receiver: " + receiver, nameof(receiver));
}
if (_receivers.ContainsKey(rank))
{
throw new ArgumentException("This rank is already being occupied by a receiver: " + rank);
}
else if (_receivers.ContainsValue(receiver))
{
throw new ArgumentException("This receiver has already been added: " + receiver);
}
else
{
_receivers.Add(rank, receiver);
}
}
public void TransmitMessageToSingleReceiverTest()
{
bool waiting = true;
const string channel = "channel";
const string message = "message";
ITransmitter <string> stringTransmitter = StringChannel.CreateTransmitter(channel);
IReceiver <string> stringReceiver = StringChannel.CreateReceiver(channel);
stringReceiver.Received += (sender, args) =>
{
Assert.AreEqual(channel, args.Channel.ChannelName);
waiting = false;
};
stringTransmitter.Send(message);
while (waiting)
{
Thread.Sleep(200);
}
Assert.AreEqual(message, stringReceiver.LastMessage);
}
public IGameState CreateGame(IReceiver gameMaster, Xsd2.RegisterGame msg)
{
var gameWithSameName = _games.FirstOrDefault(g => g.Value.GameName == msg.NewGameInfo.gameName).Value;
if (gameWithSameName != null)
{
return(null);
}
ulong gameId = 0;
lock (_gameCountLock)
{
_gameCount++;
gameId = _gameCount;
}
gameMaster.IsGameMaster = true;
gameMaster.GameId = gameId;
var game = new GameState(gameMaster, gameId, msg);
_games.Add(gameId, game);
return(game);
}
public Player(
ILogger logger,
IReceiver receiver,
string destinationId = AppConstants.DESTINATION_ID,
string senderId = AppConstants.SENDER_ID,
bool logToConsole = true,
bool logTrace = false)
{
_logger = logger;
_destinationId = destinationId;
CanLogToConsole = logToConsole;
CanLogTrace = logTrace;
_sender = new Sender(_logger, senderId, receiver, HandleResponseMsg);
_sender.Disconnected += OnDisconnect;
_connectionChannel = new ConnectionChannel(destinationId);
_heartbeatChannel = new HeartbeatChannel(destinationId);
_mediaChannel = new MediaChannel(destinationId, async() =>
{
var app = await _receiverChannel.GetApplication(_sender, _connectionChannel, _mediaChannel.Namespace);
return(app.SessionId);
});
_receiverChannel = new ReceiverChannel(destinationId);
}
public void HandleOnCommunicationServer(IConnection server, IReceiver receiver)
{
}
public void ReceiveAt(ChannelNode node, IReceiver receiver)
{
Channels[node.Uri].StartReceiving(receiver);
}
public JsonRpcServerOptions WithReceiver(IReceiver receiver)
{
Receiver = receiver;
return(this);
}
public PressHome(IReceiver aReceiver )
{
myReceiver= aReceiver ;
}
public Emailer(IReceiver nextReceiver)
{
_nextReceiver = nextReceiver;
}
public void ReceiverRemoved(IReceiver aReceiver)
{
Console.WriteLine("Removed {0}:{1}:{2}:{3}", aReceiver.Room, aReceiver.Group, aReceiver.Name, aReceiver.Status);
}
protected CharacterAction(IReceiver receiver)
{
Receiver = receiver;
IsExecuted = false;
}
public void ReceiverMuteChanged(IReceiver aReceiver)
{
Console.WriteLine("ReceiverMuteChanged {0}:{1}:{2} {3} {4}", aReceiver.Room, aReceiver.Group, aReceiver.Name, aReceiver.Status, aReceiver.Mute);
}
private void TerminateReceiver(IReceiver receiver)
{
try
{
receiver.Detach();
receiver.Terminate();
}
catch (Exception ex)
{
ShowErrorBox("Failed to Terminate Receiver: " + ex.Message);
}
}
protected CommandBase(IReceiver <T, L> receiver)
{
MyReceiver = receiver;
}
public CreateLineCommand(IReceiver receiver)
{
_receiver = receiver;
}
public void StartReceiving(IReceiver receiver)
{
Receiver = receiver;
}
internal void Added(IReceiver aReceiver)
{
Receiver receiver = new Receiver(aReceiver);
iList.Add(receiver);
if (CollectionChanged != null)
{
CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, receiver));
}
}
public void ReceiverVolumeControlChanged(IReceiver aReceiver)
{
Console.WriteLine("VolumeControlChanged {0}:{1}:{2} {3} {4}", aReceiver.Room, aReceiver.Group, aReceiver.Name, aReceiver.Status, aReceiver.HasVolumeControl);
}
internal void Changed(IReceiver aReceiver)
{
foreach (Receiver receiver in iList)
{
if (receiver.MapsTo(aReceiver))
{
receiver.Changed();
return;
}
}
}
public void ReceiverVolumeLimitChanged(IReceiver aReceiver)
{
Console.WriteLine("ReceiverVolumeLimitChanged {0}:{1}:{2} {3} {4}", aReceiver.Room, aReceiver.Group, aReceiver.Name, aReceiver.Status, aReceiver.VolumeLimit);
}
internal void Removed(IReceiver aReceiver)
{
int index = 0;
foreach (Receiver receiver in iList)
{
if (receiver.MapsTo(aReceiver))
{
iList.Remove(receiver);
if (CollectionChanged != null)
{
CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, receiver, index));
}
return;
}
index++;
}
}
public CmdCreateOrder(IReceiver pR)
{
r = pR;
}
internal Receiver(IReceiver aReceiver)
{
iReceiver = aReceiver;
iDescription = iReceiver.Room + " (" + iReceiver.Group + ")";
}
public PressHome(IReceiver aReceiver)
{
myReceiver = aReceiver;
}
private void InitializeReceiver(IReceiver receiver)
{
try
{
receiver.Initialize();
receiver.Attach(this);
//LogManager.Instance.SetRootLoggerName(String.Format("Root [{0}]", receiver));
}
catch (Exception ex)
{
try
{
receiver.Terminate();
}
catch { }
ShowErrorBox("Failed to Initialize Receiver: " + ex.Message);
}
}
