/// <summary>
/// 初期化
/// </summary>
/// <param name="msgFind">Windowメッセージ文字列(カード検出)</param>
/// <param name="msgEnable">Windowメッセージ文字列(カード使用可能)</param>
/// <param name="msgHandler">メッセージ処理ハンドラ</param>
/// <returns></returns>
public bool init(String msgFind, String msgEnable, ref MessageHandler msgHandler)
{
// Win32メッセージ登録
UInt32 card_find_message = RegisterWindowMessage(msgFind);
if (card_find_message == 0)
{
Console.Write("Failed: RegisterWindowMessage\n");
return(false);
}
UInt32 card_enable_message = RegisterWindowMessage(msgEnable);
if (card_enable_message == 0)
{
Console.Write("Failed: RegisterWindowMessage\n");
return(false);
}
messageSet[0] = card_find_message;
messageSet[1] = card_enable_message;
msgHandler =
new MessageHandler(card_find_message, card_enable_message);
mHandler +=
new MessageReceivedEventHandler(msgHandler.messageHandlerFunc);
return(true);
}
/// <summary>
/// Задача ждать смс
/// </summary>
/// <param name="origin">От кого ждать смс</param>
public Task WaitSMSFromNumber(string origin, int cmdId)
{
CurrentCommandID = cmdId;
return(Task.Factory.StartNew(() =>
{
if (IsConnected())
{
//for (int i = 0; i < 60; i++)
//{
string sms = CheckSMSFromNumber(origin);
if (sms != null)
{
SmsReceived(this, new MessageArgs()
{
messageText = sms
});
}
else
{
Search = origin;
MessageReceived += new MessageReceivedEventHandler(SmsModemBlock_MessageReceived);
}
// Thread.Sleep(1000);
//}
}
else
{
//return "ERROR";
}
}));
}
public Listener(
int port,
int timeout,
bool useIPv6,
PropertyChangedWithValueEventHandler propertyChangedHandler = null,
MessageReceivedEventHandler messageReceivedEventHandler = null
) {
Port = port;
Timeout = timeout;
if (propertyChangedHandler != null) {
_propertyChangedHandler = propertyChangedHandler;
this.PropertyChangedWithValue += propertyChangedHandler;
}
if (messageReceivedEventHandler != null) {
_messageReceivedEventHandler = messageReceivedEventHandler;
this.MessageReceived += messageReceivedEventHandler;
}
_listener = new TcpListenerEx(
(useIPv6 ?
IPAddress.IPv6Any :
IPAddress.Any),
Port
);
if (useIPv6) {
_listener.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 0);
}
_worker = CreateWorker();
}
/// <summary>
/// Interrupt Service Routine when pin INT falls LOW (message received)
/// uses the rollover feature from MAB to RXB1, when RXB0 is full
/// Note: Only standard identifier, no RTR frame detection
/// </summary>
private void INT_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e)
{
var readCmd = (ReadReg(regCANINTF) & 0x01) == 0x01 ? cmdReadRXB0 : cmdReadRXB1;
lock (_socket.LockSpi)
{
_canSpi.TransferFullDuplex(new Byte[] { readCmd, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, valueChangedBuffer);
Array.Copy(valueChangedBuffer, 1, valueChangedBuffer, 0, valueChangedBuffer.Length - 1);
}
var Msg = new CanMessage()
{
Timestamp = e.Timestamp,
ArbitrationId = valueChangedBuffer[0] << 3 | valueChangedBuffer[1] >> 5,
IsExtendedId = false,
IsRemoteTransmissionRequest = false,
Length = (Byte)(valueChangedBuffer[4] & 0x0F),
Data = new Byte[(Byte)(valueChangedBuffer[4] & 0x0F)]
};
for (Byte i = 0; i < Msg.Length; i++)
{
Msg.Data[i] = valueChangedBuffer[i + 5];
}
MessageReceivedEventHandler messageReceived = MessageReceived;
messageReceived(this, new MessageReceivedEventArgs(Msg));
}
public Listener(
int port,
int timeout,
bool useIPv6,
PropertyChangedWithValueEventHandler propertyChangedHandler = null,
MessageReceivedEventHandler messageReceivedEventHandler = null
)
{
Port = port;
Timeout = timeout;
if (propertyChangedHandler != null)
{
_propertyChangedHandler = propertyChangedHandler;
this.PropertyChangedWithValue += propertyChangedHandler;
}
if (messageReceivedEventHandler != null)
{
_messageReceivedEventHandler = messageReceivedEventHandler;
this.MessageReceived += messageReceivedEventHandler;
}
_listener = new TcpListenerEx(
(useIPv6 ?
IPAddress.IPv6Any :
IPAddress.Any),
Port
);
if (useIPv6)
{
_listener.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 0);
}
_worker = CreateWorker();
}
public RmqMessageConsumer(string hostname, string queue, MessageReceivedEventHandler callback)
{
Hostname = hostname;
Queue = queue;
MessageReceived = callback;
StartMessageConsumer();
}
protected virtual void OnMessageReceived(string message)
{
MessageReceivedEventHandler handler = messageReceived;
if (handler != null)
{
handler(this, new MessageReceivedEventArgs(message));
}
}
private void OnMessageReceived(MessageEventArgs e)
{
MessageReceivedEventHandler handler = MessageReceived;
if (handler != null)
{
handler(this, e);
}
}
/// <summary>
/// C O N S T R U C T O R method for the creation of a GameChatForm.
/// </summary>
public GameChatForm()
{
Handler = new ChatLib.MessageReceivedEventHandler(Executor_MessageRecieved);
InitializeComponent();
client = new Client(13000);
SendButton.Enabled = false;
SendMessageText.Enabled = false;
DisconnectMenuItem.Enabled = false;
}
// 接收到消息
void talker_MessageReceived(string msg)
{
MessageReceivedEventHandler del = delegate(string m)
{
richTextBox1.Text += m;
};
richTextBox1.Invoke(del, msg);
}
protected virtual void OnMessageReceived(NetworkMessage message)
{
// log.Debug(string.Format("Packet Id : {0}, lenght : {1}", message.MessageId, message.Data.Length));
MessageReceivedEventHandler handler = MessageReceived;
if (handler != null)
{
handler(this, message);
}
}
/// <inheritdoc />
public virtual void AddErrorReceivedHandler(MessageReceivedEventHandler messageReceivedEventHandler)
{
_errorReceivedHandler += messageReceivedEventHandler;
if (!_internalErrorDataReceivedHandlerAdded)
{
AddErrorDataReceivedHandler(InternalErrorDataReceivedHandler);
_internalErrorDataReceivedHandlerAdded = true;
}
}
void talk_FileReceivedFinish(string msg)
{
MessageReceivedEventHandler del = delegate(string m)
{
richTextBox1.Text += m;
};
richTextBox1.Invoke(del, msg);
isRec = true;
}
/// <inheritdoc />
public virtual void AddOutputReceivedHandler(MessageReceivedEventHandler messageReceivedEventHandler)
{
_outputReceivedHandler += messageReceivedEventHandler;
if (!_internalOutputDataReceivedHandlerAdded)
{
AddOutputDataReceivedHandler(InternalOutputDataReceivedHandler);
_internalOutputDataReceivedHandlerAdded = true;
}
}
// PDTS 966
/// <summary>
/// Tells the module that a server initiated message was received.
/// </summary>
/// <param name="commandId">The id of the message received.</param>
/// <param name="messageData">The payload data of the message or null
/// if the message has no data.</param>
public void MessageReceived(int commandId, object msgData)
{
MessageReceivedEventArgs args = new MessageReceivedEventArgs(commandId, msgData);
MessageReceivedEventHandler handler = ServerMessageReceived;
if (handler != null)
{
handler(this, args);
}
}
protected override void Run()
{
while (running)
{
object c = source.Receive();
MessageReceivedEventHandler handler = MessageReceived;
if (handler != null)
{
handler(this, new MessageReceivedEventArgs(c));
}
}
}
public void RegisterMessageReceiver(string queueName, MessageReceivedEventHandler messageHandler)
{
_messageHandler = messageHandler;
_sbMessageReceiverClient = new ServiceBusClient(_messageBrokerEndpoint);
_sbProcessor = _sbMessageReceiverClient.CreateProcessor(queueName, new ServiceBusProcessorOptions()
{
ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
});
_sbProcessor.ProcessMessageAsync += MessageHandlerAsync;
_sbProcessor.ProcessErrorAsync += ErrorHandlerAsync;
}
public RobustSerial(string port, MessageReceivedEventHandler onMessageReceived)
{
arduinoPort = new SerialPort(port);
arduinoPort.BaudRate = 115200;
arduinoPort.ReadTimeout = 500;
arduinoPort.WriteTimeout = 500;
arduinoPort.Handshake = Handshake.None;
arduinoPort.RtsEnable = true;
//arduinoPort.DtrEnable = true;
this.OnMessageReceived = onMessageReceived;
arduinoPort.DataReceived += DataReceivedHandler;
}
/// <summary>
/// Listener Set
/// </summary>
private void TibListenerSetting()
{
try
{
OnMessageReceived += new MessageReceivedEventHandler(__OnMessageReceived);
tibListener = new Listener(Queue.Default, OnMessageReceived, tibTrans, LOCAL_SUBJECT, "");
}
catch (System.Exception ex)
{
CLogManager.Instance.Log(new CExceptionLogFormat(Catagory.Error, "EMP", ex));
CLogManager.Instance.Log(new CStatusLogFormat(Catagory.Error, "OGS", "TIB", "TibListenerSetting \r\n" + ex.ToString()));
}
}
public void ReceiveMessage(Client sender, string text)
{
if (text == null)
{
throw new ArgumentNullException("text");
}
MessageReceivedEventHandler textReceived = this.MessageReceived;
if (textReceived != null)
{
textReceived(this, sender, text);
}
}
internal virtual void DataReceivedHandler(StringBuilder stringBuilder,
MessageReceivedEventHandler messageReceivedEventHandler,
object sender,
DataReceivedEventArgs dataReceivedEventArgs)
{
string data = dataReceivedEventArgs.Data;
// Process output is received line by line. The last line of a message ends with a \0 (null character),
// so we accumulate lines in a StringBuilder till the \0, then log the entire message in one go.
if (TryCreateMessage(stringBuilder, data, out string result))
{
messageReceivedEventHandler(sender, result);
}
}
protected Cabinet(RfidReader currenRfidReader, string strPortBadgeAndLCD)
{
Rs232Module = new Rs232Module(strPortBadgeAndLCD);
MessageReceivedEventHandler msgReceivedEventHandler = UpdateMessage;
Rs232Module.MessageEvent += msgReceivedEventHandler;
CurrenRfidReader = currenRfidReader;
if (CurrenRfidReader != null)
{
CurrenRfidReader.NotifyEvent += myDevice_NotifyEvent;
}
StrPortBadgeAndLCD = strPortBadgeAndLCD;
}
public void AddErrorReceivedHandler_OnlyAddsInternalErrorDataReceivedHandlerOnce()
{
// Arrange
Mock <NodeJSProcess> mockTestSubject = CreateMockNodeJSProcess();
mockTestSubject.CallBase = true;
mockTestSubject.Setup(t => t.AddErrorDataReceivedHandler(mockTestSubject.Object.InternalErrorDataReceivedHandler));
MessageReceivedEventHandler dummyHandler = (object _, string __) => { };
// Act
mockTestSubject.Object.AddErrorReceivedHandler(dummyHandler);
mockTestSubject.Object.AddErrorReceivedHandler(dummyHandler);
// Assert
mockTestSubject.Verify(n => n.AddErrorDataReceivedHandler(mockTestSubject.Object.InternalErrorDataReceivedHandler), Times.Once);
}
void IMessagingClient.RegisterEventHandler(EventType eventType, MessageReceivedEventHandler messageReceivedEventHandler)
{
switch (eventType)
{
case EventType.ChannelMessage:
Action <object, IrcEventArgs> handler = ((s, e) =>
{
var convertedData = new MessageData(e.Data.Nick, e.Data.Channel, e.Data.Message, e.Data.MessageArray);
messageReceivedEventHandler(convertedData);
});
_ircClient.OnChannelMessage += new IrcEventHandler(handler);
break;
default:
throw new NotImplementedException($"EventType {eventType} not supported yet");
}
}
void IMessagingClient.RegisterEventHandler(EventType eventType, MessageReceivedEventHandler messageReceivedEventHandler)
{
switch (eventType)
{
case EventType.ChannelMessage:
Action<object, IrcEventArgs> handler = ((s, e) =>
{
var convertedData = new MessageData(e.Data.Nick, e.Data.Channel, e.Data.Message, e.Data.MessageArray);
messageReceivedEventHandler(convertedData);
});
_ircClient.OnChannelMessage += new IrcEventHandler(handler);
break;
default:
throw new NotImplementedException($"EventType {eventType} not supported yet");
}
}
internal virtual void DataReceivedHandler(StringBuilder stringBuilder,
MessageReceivedEventHandler messageReceivedEventHandler,
object sender,
DataReceivedEventArgs dataReceivedEventArgs)
{
string data = dataReceivedEventArgs.Data;
if (data == null) // When the stream is closed, an event with data = null is received - https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.datareceivedeventargs.data?view=netframework-4.8#remarks
{
return;
}
// Process output is received line by line. The last line of a message ends with a \0 (null character),
// so we accumulate lines in a StringBuilder till the \0, then log the entire message in one go.
if (TryCreateMessage(stringBuilder, data, out string result))
{
messageReceivedEventHandler(sender, result);
}
}
//接收到文件
void talker_FileReceived(string msg)
{
MessageReceivedEventHandler del = delegate(string m)
{
richTextBox1.Text += m;
};
richTextBox1.Invoke(del, msg);
isRec = false;
Thread myThread = new Thread(() =>
{
while (!isRec)
{
setProgressBar("received");
}
});
myThread.IsBackground = true;
myThread.Start();
}
public void AddOutputReceivedHandler_AddsHandlers()
{
// Arrange
var dummySender = new object();
var dummyStringBuilder = new StringBuilder();
DataReceivedEventArgs dummyDataReceivedEventArgs = CreateDataReceivedEventArgs();
MessageReceivedEventHandler dummyHandler = (object _, string __) => { };
Mock <NodeJSProcess> mockTestSubject = CreateMockNodeJSProcess(outputDataStringBuilder: dummyStringBuilder);
mockTestSubject.CallBase = true;
mockTestSubject.Setup(n => n.DataReceivedHandler(dummyStringBuilder, dummyHandler, dummySender, dummyDataReceivedEventArgs)); // Output received handler added
mockTestSubject.Setup(n => n.AddOutputDataReceivedHandler(mockTestSubject.Object.InternalOutputDataReceivedHandler)); // Output data received handler added
// Act
mockTestSubject.Object.AddOutputReceivedHandler(dummyHandler);
// Assert
mockTestSubject.Object.InternalOutputDataReceivedHandler(dummySender, dummyDataReceivedEventArgs);
mockTestSubject.VerifyAll();
}
private void WaitForMessage(SipMessage currentMessage, MessageReceivedEventHandler handler, int timer, params int[] timers)
{
Task.Factory.StartNew(
() =>
{
foreach (var i in new[] { timer }.Concat(timers))
{
SipMessage msg;
if (this.TryGetNextMessage(i, out msg))
{
if (msg.CallId == this.CallId)
{
handler(currentMessage, msg);
return;
}
}
}
handler(currentMessage, null);
});
}
private void _Output(StatusLog isError, string format, params object[] param)
{
try
{
lock (mSynce)
{
string logMsg = string.Format("{0}{1}", DateTime.Now.ToString("[HH:mm:ss.fff] "), String.Format(format, param));
if (mLogQueue.Count >= QUEUE_SIZE)
{
mLogQueue.Dequeue();
}
mLogQueue.Enqueue(new KeyValuePair <StatusLog, string>(isError, logMsg));
using (StreamWriter writer = new StreamWriter(FileName, true))
{
writer.WriteLine(logMsg);
}
MessageReceivedEventHandler?.Invoke(this, isError, logMsg);
}
}
catch (Exception)
{
}
}
public void DataReceivedHandler_IfDataIsNotNullAndMessageIsCreatedCallsMessageReceivedEventHandler()
{
// Arrange
var dummySender = new object();
const string dummyData = "dummyData";
var dummyStringBuilder = new StringBuilder();
Mock <NodeJSProcess> mockTestSubject = CreateMockNodeJSProcess();
mockTestSubject.CallBase = true;
string dummyMessage = "dummyMessage";
mockTestSubject.Setup(t => t.TryCreateMessage(dummyStringBuilder, dummyData, out dummyMessage)).Returns(true);
object resultSender = null;
string resultMessage = null;
MessageReceivedEventHandler dummyMessageReceivedEventHandler = (object sender, string message) => { resultSender = sender; resultMessage = message; };
// Act
mockTestSubject.Object.DataReceivedHandler(dummyStringBuilder, dummyMessageReceivedEventHandler, dummySender, CreateDataReceivedEventArgs(dummyData));
// Assert
_mockRepository.VerifyAll();
Assert.Same(dummySender, resultSender);
Assert.Equal(dummyMessage, resultMessage);
}
public void InitUI(bool reNew = false)
{
InitTVItem();
InitTabItem();
if (reNew == true)
_cts = new CancellationTokenSource();
InitSocketTask();
if (reNew == false)
{
MessageReceivedEvent += new MessageReceivedEventHandler(TIUC.MessageReceivedEventHandler);
SocketStateChangeEvent += new SocketStateChangeEventHandler(TIUC.SocketStateChangeEventHandler);
}
}
protected async Task StartAsync(string providerName, MessageReceivedEventHandler eventHandler, CancellationToken cancellationToken)
{
_logger.LogDebug($"{this.GetType().Name} starting; registering message handler.");
MessageBroker.RegisterMessageReceiver($"provider-{providerName}-response", eventHandler);
await MessageBroker.StartListenerAsync();
}
public void RemoveMethodFromMessageReceivedEvent(MessageReceivedEventHandler messageReceivedEventHandler)
{
_superPeerClient.MessageReceivedEvent -= messageReceivedEventHandler;
}
public void AddMethodToMessageReceivedEvent(MessageReceivedEventHandler messageReceivedEventHandler)
{
_superPeerClient.MessageReceivedEvent += messageReceivedEventHandler;
}
public MessageReceivedEventHandlerMapping(EventType eventType, MessageReceivedEventHandler eventHandler)
{
EventType = eventType;
EventHandler = eventHandler;
}
/// <summary>
/// 初期化
/// </summary>
/// <param name="msgFind">Windowメッセージ文字列(カード検出)</param>
/// <param name="msgEnable">Windowメッセージ文字列(カード使用可能)</param>
/// <param name="msgHandler">メッセージ処理ハンドラ</param>
/// <returns></returns>
public bool init(String msgFind, String msgEnable, ref MessageHandler msgHandler)
{
// Win32メッセージ登録
UInt32 card_find_message = RegisterWindowMessage(msgFind);
if(card_find_message == 0) {
Console.Write("Failed: RegisterWindowMessage\n");
return false;
}
UInt32 card_enable_message = RegisterWindowMessage(msgEnable);
if(card_enable_message == 0) {
Console.Write("Failed: RegisterWindowMessage\n");
return false;
}
messageSet[0] = card_find_message;
messageSet[1] = card_enable_message;
msgHandler =
new MessageHandler(card_find_message, card_enable_message);
handler +=
new MessageReceivedEventHandler(msgHandler.messageHandlerFunc);
return true;
}
void IMessagingClient.RegisterEventHandler(EventType eventType, MessageReceivedEventHandler messageReceivedEventHandler)
{
throw new NotImplementedException();
}
