/// <summary>
/// Send a message to the server.
/// </summary>
/// <param name="message">Message to send.</param>
/// <returns><c>true</c> if successful, otherwise <c>false</c>.</returns>
public bool Send(IrssMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (_serverSocket == null)
{
return(false);
}
byte[] data = message.ToBytes();
int dataLength = IPAddress.HostToNetworkOrder(data.Length);
byte[] dataLengthBytes = BitConverter.GetBytes(dataLength);
try
{
// Send packet size ...
_serverSocket.Send(dataLengthBytes);
// Send packet ...
_serverSocket.Send(data);
return(true);
}
catch (SocketException)
{
return(false);
}
}
private void ReceivedMessage(IrssMessage received)
{
switch (received.Type)
{
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_registered = true;
labelStatus.Text = "Connected";
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
labelStatus.Text = "Failed to negotiate connection";
}
return;
case MessageType.ServerShutdown:
_registered = false;
labelStatus.Text = "Server Shutdown";
return;
case MessageType.Error:
labelStatus.Text = received.GetDataAsString();
return;
}
}
private void ButtonPress(string keyCode)
{
if (!_registered)
{
return;
}
if (keyCode == null)
{
return;
}
byte[] deviceNameBytes = Encoding.ASCII.GetBytes("Abstract");
byte[] keyCodeBytes = Encoding.ASCII.GetBytes(keyCode);
byte[] bytes = new byte[8 + deviceNameBytes.Length + keyCodeBytes.Length];
BitConverter.GetBytes(deviceNameBytes.Length).CopyTo(bytes, 0);
deviceNameBytes.CopyTo(bytes, 4);
BitConverter.GetBytes(keyCodeBytes.Length).CopyTo(bytes, 4 + deviceNameBytes.Length);
keyCodeBytes.CopyTo(bytes, 8 + deviceNameBytes.Length);
IrssMessage message = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Notify, bytes);
_client.Send(message);
}
private void ReceivedMessage(IrssMessage received)
{
switch (received.Type)
{
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_registered = true;
Invoke(_Notification, "Connected");
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
Invoke(_Notification, "Failed to negotiate connection");
}
return;
case MessageType.ServerShutdown:
_registered = false;
Invoke(_Notification, "Server Shutdown");
return;
case MessageType.Error:
Invoke(_Notification, received.GetDataAsString());
return;
}
}
private static void Connected(object obj)
{
IrssLog.Info("Connected to server");
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
private static void SendMessage(IrssMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (_client != null)
{
_client.Send(message);
}
}
internal static void ButtonPress(string keyCode)
{
if (!_registered)
{
return;
}
byte[] bytes = IrssMessage.EncodeRemoteEventData(_device, keyCode);
IrssMessage message = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Request, bytes);
SendMessage(message);
}
private static void ReceivedMessage(IrssMessage received)
{
IrssLog.Debug("Received Message \"{0}\"", received.Type);
try
{
switch (received.Type)
{
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
//_irServerInfo = IRServerInfo.FromBytes(received.DataAsBytes);
_registered = true;
IrssLog.Info("Registered to IR Server");
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
IrssLog.Warn("IR Server refused to register");
}
break;
case MessageType.ServerShutdown:
IrssLog.Warn("IR Server Shutdown - Virtual Remote disabled until IR Server returns");
_registered = false;
break;
case MessageType.Error:
IrssLog.Error(received.GetDataAsString());
break;
}
}
catch (Exception ex)
{
IrssLog.Error(ex);
}
}
private void ButtonPress(string keyCode)
{
if (!_registered)
return;
byte[] deviceNameBytes = Encoding.ASCII.GetBytes("Abstract");
byte[] keyCodeBytes = Encoding.ASCII.GetBytes(keyCode);
byte[] bytes = new byte[8 + deviceNameBytes.Length + keyCodeBytes.Length];
BitConverter.GetBytes(deviceNameBytes.Length).CopyTo(bytes, 0);
deviceNameBytes.CopyTo(bytes, 4);
BitConverter.GetBytes(keyCodeBytes.Length).CopyTo(bytes, 4 + deviceNameBytes.Length);
keyCodeBytes.CopyTo(bytes, 8 + deviceNameBytes.Length);
IrssMessage message = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Notify, bytes);
_client.Send(message);
}
private void Connected(object obj)
{
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
private void ReceivedMessage(IrssMessage received)
{
switch (received.Type)
{
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_registered = true;
Invoke(_Notification, "Connected", false);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
Invoke(_Notification, "Failed to negotiate connection", true);
}
return;
case MessageType.ServerShutdown:
_registered = false;
Invoke(_Notification, "Server Shutdown", true);
return;
case MessageType.Error:
Invoke(_Notification, received.GetDataAsString(), true);
return;
}
}
private void QueueMessageSink(IrssMessage message)
{
_messageSink(message);
}
/// <summary>
/// Send a message to the server.
/// </summary>
/// <param name="message">Message to send.</param>
/// <returns><c>true</c> if successful, otherwise <c>false</c>.</returns>
public bool Send(IrssMessage message)
{
if (message == null)
throw new ArgumentNullException("message");
if (_serverSocket == null)
return false;
byte[] data = message.ToBytes();
int dataLength = IPAddress.HostToNetworkOrder(data.Length);
byte[] dataLengthBytes = BitConverter.GetBytes(dataLength);
try
{
// Send packet size ...
_serverSocket.Send(dataLengthBytes);
// Send packet ...
_serverSocket.Send(data);
return true;
}
catch (SocketException)
{
return false;
}
}
private void ConnectionThread()
{
// Outer loop is for reconnection attempts ...
while (_processConnectionThread)
{
_connected = false;
_serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#region Attempt to connect
while (_processConnectionThread)
{
try
{
_serverSocket.Connect(_serverEndpoint);
break;
}
catch (SocketException socketException)
{
if (!_processConnectionThread)
{
return;
}
if (socketException.ErrorCode == 10061) // ConnectionRefused
{
Thread.Sleep(1000);
continue;
}
if (_commsFailureCallback != null)
{
_commsFailureCallback(socketException);
}
else
{
throw;
}
}
catch (Exception ex)
{
if (!_processConnectionThread)
{
return;
}
if (_commsFailureCallback != null)
{
_commsFailureCallback(ex);
}
else
{
throw;
}
}
}
#endregion Attempt to connect
if (!_processConnectionThread)
{
return;
}
_connected = true;
if (_connectCallback != null)
{
_connectCallback(null);
}
#region Read from socket
try
{
byte[] buffer = new byte[4];
int bytesRead;
// Read data from socket ...
while (_processConnectionThread)
{
bytesRead = _serverSocket.Receive(buffer, buffer.Length, SocketFlags.None);
if (bytesRead != buffer.Length)
{
break;
}
int readSize = BitConverter.ToInt32(buffer, 0);
readSize = IPAddress.NetworkToHostOrder(readSize);
byte[] packet = new byte[readSize];
bytesRead = _serverSocket.Receive(packet, packet.Length, SocketFlags.None);
if (bytesRead != packet.Length)
{
break;
}
IrssMessage message = IrssMessage.FromBytes(packet);
_messageSink(message);
}
if (!_processConnectionThread)
{
return;
}
if (_disconnectCallback != null)
{
_disconnectCallback(null);
}
}
catch (SocketException socketException)
{
if (!_processConnectionThread)
{
return;
}
if (socketException.ErrorCode == 10054) // ConnectionReset
{
if (_disconnectCallback != null)
{
_disconnectCallback(null);
}
}
else
{
if (_commsFailureCallback != null)
{
_commsFailureCallback(socketException);
}
else
{
throw;
}
}
}
catch (Exception ex)
{
if (!_processConnectionThread)
{
return;
}
if (_commsFailureCallback != null)
{
_commsFailureCallback(ex);
}
else
{
throw;
}
}
#endregion Read from socket
}
}
private void Connected(object obj)
{
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
private void QueueMessageSink(IrssMessage message)
{
_messageSink(message);
}
private static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
IrssLog.LogLevel = IrssLog.Level.Debug;
IrssLog.Open("Virtual Remote.log");
Application.ThreadException += Application_ThreadException;
LoadSettings();
if (args.Length > 0) // Command Line Start ...
{
List <string> virtualButtons = new List <string>();
try
{
for (int index = 0; index < args.Length; index++)
{
if (args[index].Equals("-host", StringComparison.OrdinalIgnoreCase))
{
_serverHost = args[++index];
continue;
}
else
{
virtualButtons.Add(args[index]);
}
}
}
catch (Exception ex)
{
IrssLog.Error("Error processing command line parameters: {0}", ex.ToString());
}
IPAddress serverIP = Network.GetIPFromName(_serverHost);
IPEndPoint endPoint = new IPEndPoint(serverIP, Server.DefaultPort);
if (virtualButtons.Count != 0 && StartClient(endPoint))
{
Thread.Sleep(250);
// Wait for registered ... Give up after 10 seconds ...
int attempt = 0;
while (!_registered)
{
if (++attempt >= 10)
{
break;
}
else
{
Thread.Sleep(1000);
}
}
if (_registered)
{
foreach (string button in virtualButtons)
{
if (button.StartsWith("~", StringComparison.OrdinalIgnoreCase))
{
Thread.Sleep(button.Length * 500);
}
else
{
IrssMessage message = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Notify, button);
_client.Send(message);
}
}
Thread.Sleep(500);
}
else
{
IrssLog.Warn("Failed to register with server host \"{0}\", custom message(s) not sent", ServerHost);
}
}
}
else // GUI Start ...
{
if (String.IsNullOrEmpty(_serverHost))
{
ServerAddress serverAddress = new ServerAddress();
serverAddress.ShowDialog();
_serverHost = serverAddress.ServerHost;
}
bool clientStarted = false;
IPAddress serverIP = Network.GetIPFromName(_serverHost);
IPEndPoint endPoint = new IPEndPoint(serverIP, Server.DefaultPort);
try
{
clientStarted = StartClient(endPoint);
}
catch (Exception ex)
{
IrssLog.Error(ex);
clientStarted = false;
}
if (clientStarted)
{
Application.Run(new MainForm());
}
SaveSettings();
}
StopClient();
Application.ThreadException -= Application_ThreadException;
IrssLog.Close();
}
