private void buttonShutdownServer_Click(object sender, EventArgs e)
{
AddStatusLine("Shutdown");
if (_client == null)
{
AddStatusLine(" - Not connected");
return;
}
if (!_client.Connected)
{
AddStatusLine(" - Connecting...");
return;
}
try
{
IrssMessage message = new IrssMessage(MessageType.ServerShutdown, MessageFlags.Request);
_client.Send(message);
}
catch (Exception ex)
{
AddStatusLine(ex.Message);
}
}
/// <summary>
/// Blast an IR command.
/// </summary>
/// <param name="fileName">File to blast (absolute path).</param>
/// <param name="port">Port to blast to.</param>
internal static void BlastIR(string fileName, string port)
{
Log.Debug("TV3BlasterPlugin - BlastIR(): {0}, {1}", fileName, port);
if (!_registered)
{
throw new InvalidOperationException("Cannot Blast, not registered to an active IR Server");
}
using (FileStream file = File.OpenRead(fileName))
{
if (file.Length == 0)
{
throw new IOException(String.Format("Cannot Blast. IR file \"{0}\" has no data, possible IR learn failure",
fileName));
}
byte[] outData = new byte[4 + port.Length + file.Length];
BitConverter.GetBytes(port.Length).CopyTo(outData, 0);
Encoding.ASCII.GetBytes(port).CopyTo(outData, 4);
file.Read(outData, 4 + port.Length, (int)file.Length);
IrssMessage message = new IrssMessage(MessageType.BlastIR, MessageFlags.Request, outData);
_client.Send(message);
}
}
private void Stop()
{
_notifyIcon.Visible = false;
try
{
if (_registered)
{
_registered = false;
IrssMessage message = new IrssMessage(MessageType.UnregisterClient, MessageFlags.Request);
_client.Send(message);
}
}
catch
{
}
StopClient();
if (_mediaState != null)
{
_mediaState.Dispose();
_mediaState = null;
}
}
/// <summary>
/// Connect the IRSS client to any IRSS server.
/// </summary>
/// <returns>true if the disconnection is successful</returns>
public bool Disconnect()
{
try
{
if (!Connected || irss == null)
{
LogWarn("Not connected");
return(true);
}
LogInfo("Disconnect " + ServerHost);
IrssMessage message = new IrssMessage(MessageType.UnregisterClient, MessageFlags.Request);
irss.Send(message);
Connected = false;
ServerHost = "";
irss.Dispose();
irss = null;
}
catch (Exception ex)
{
LogErr(ex.Message);
return(false);
}
return(true);
}
private bool LearnIR(string fileName)
{
try
{
if (_learnIRFilename != null)
{
return(false);
}
_learnIRFilename = fileName;
IrssMessage message = new IrssMessage(MessageType.LearnIR, MessageFlags.Request);
_client.Send(message);
AddStatusLine("Learning");
}
catch (Exception ex)
{
_learnIRFilename = null;
AddStatusLine(ex.Message);
return(false);
}
return(true);
}
private bool BlastIR(string fileName, string port)
{
try
{
using (FileStream file = File.OpenRead(fileName))
{
if (file.Length == 0)
{
throw new IOException(String.Format("Cannot Blast. IR file \"{0}\" has no data, possible IR learn failure",
fileName));
}
byte[] outData = new byte[4 + port.Length + file.Length];
BitConverter.GetBytes(port.Length).CopyTo(outData, 0);
Encoding.ASCII.GetBytes(port).CopyTo(outData, 4);
file.Read(outData, 4 + port.Length, (int)file.Length);
IrssMessage message = new IrssMessage(MessageType.BlastIR, MessageFlags.Request, outData);
_client.Send(message);
}
}
catch (Exception ex)
{
AddStatusLine(ex.Message);
return(false);
}
return(true);
}
private void buttonBlast_Click(object sender, EventArgs e)
{
if (!_registered)
{
MessageBox.Show(this, "Not registered to an active IR Server", "Cannot blast", MessageBoxButtons.OK,
MessageBoxIcon.Warning);
}
Invoke(new UpdateWindowDel(UpdateWindow), new string[] { "Blasting ..." });
string port = comboBoxPort.Text;
byte[] codeBytes = _code.ToByteArray();
byte[] outData = new byte[4 + port.Length + codeBytes.Length];
BitConverter.GetBytes(port.Length).CopyTo(outData, 0);
Encoding.ASCII.GetBytes(port).CopyTo(outData, 4);
Array.Copy(codeBytes, 0, outData, 4 + port.Length, codeBytes.Length);
IrssMessage message = new IrssMessage(MessageType.BlastIR, MessageFlags.Request, outData);
_client.Send(message);
}
private void buttonDisconnect_Click(object sender, EventArgs e)
{
AddStatusLine("Disconnect");
try
{
if (_client == null)
{
AddStatusLine(" - Not connected");
return;
}
if (_registered)
{
IrssMessage message = new IrssMessage(MessageType.UnregisterClient, MessageFlags.Request);
_client.Send(message);
}
StopClient();
}
catch (Exception ex)
{
AddStatusLine(ex.Message);
}
}
private void buttonSendRemoteButton_Click(object sender, EventArgs e)
{
AddStatusLine("Send Remote Button");
try
{
if (_client == null)
{
AddStatusLine(" - Not connected");
return;
}
if (!_client.Connected)
{
AddStatusLine(" - Connecting...");
return;
}
byte[] bytes = IrssMessage.EncodeRemoteEventData(textBoxRemoteDevice.Text, textBoxRemoteCode.Text);
IrssMessage message = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Notify, bytes);
_client.Send(message);
}
catch (Exception ex)
{
AddStatusLine(ex.Message);
}
}
private void ReceivedMessage(IrssMessage received)
{
if (received.Type == MessageType.RemoteEvent)
{
//string deviceName = received.MessageData[IrssMessage.DEVICE_NAME] as string;
string keyCode = received.MessageData[IrssMessage.KEY_CODE] as string;
// TODO: Activate this code for 1.4.3
//if (deviceName.Equals("Abstract", StringComparison.OrdinalIgnoreCase))
Invoke(_addNode, new Object[] { keyCode });
//else
// this.Invoke(_addNode, new Object[] { String.Format("{0} ({1})", deviceName, keyCode) });
}
else if (_learnIR != null && received.Type == MessageType.LearnIR)
{
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_learnIR.LearnStatus("Learned IR successfully", true);
}
else if ((received.Flags & MessageFlags.Timeout) == MessageFlags.Timeout)
{
_learnIR.LearnStatus("Learn IR timed out", false);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_learnIR.LearnStatus("Learn IR failed", false);
}
}
}
void Connected(object obj)
{
ServiceRegistration.Get <ILogger>().Info("IrInputPlugin: Connected to server");
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
private static void Connected(object obj)
{
Log.Info("TV3BlasterPlugin: Connected to server");
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
private void Connected(object obj)
{
IrssLog.Info("Connected to server");
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
/// <summary>
/// Called back when the client is successfully connected to the server.
/// </summary>
private void SocketConnected(object obj)
{
LogInfo("Connection to server " + ServerHost + " successful");
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
irss.Send(message);
}
private static IntPtr InternalHookDelegate(int code, int wParam, IntPtr lParam)
{
try
{
if (code >= 0 && wParam == 256)
{
KeyboardHookStruct khs = new KeyboardHookStruct(lParam);
int keyCode = khs.virtualKey;
AppCommands appCommand = KeyCodeToAppCommand((Keys)khs.virtualKey);
if (appCommand == AppCommands.None)
{
if (khs.virtualKey == (int)Keys.LShiftKey || khs.virtualKey == (int)Keys.LControlKey ||
khs.virtualKey == (int)Keys.RShiftKey || khs.virtualKey == (int)Keys.RControlKey)
{
return(CallNextHookEx(_hookHandle, code, wParam, lParam));
}
if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
{
keyCode |= 0x00100000;
}
if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
{
keyCode |= 0x01000000;
}
if ((Control.ModifierKeys & Keys.Alt) == Keys.Alt)
{
keyCode |= 0x10000000;
}
}
else
{
keyCode |= (((int)appCommand) << 8);
}
if (_registered)
{
byte[] bytes = IrssMessage.EncodeRemoteEventData("Keyboard", String.Format("{0:X8}", keyCode));
IrssMessage message = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Notify, bytes);
_client.Send(message);
}
if (_stealAppCommands && appCommand != AppCommands.None)
{
return(new IntPtr(1));
}
}
}
catch (Exception ex)
{
IrssLog.Error(ex);
}
return(CallNextHookEx(_hookHandle, code, wParam, lParam));
}
/// <summary>
/// Lean in IR code and save it to the given irName.
/// After this method is called, an IR event is expect unless the time-out is reached before that (typically: 10 sec).
/// </summary>
/// <param name="irName">This name will be used to create a file, so make sure the name supplied doesn't break any of the windows file name conventions. That is, don't use / ? \ : * | "</param>
/// <param name="millisecondsTimeout">Wait for the learn-event response from server to succeed for that many milliseconds</param>
public bool Learn(string irName = "", int millisecondsTimeout = 15000)
{
_learnSuccess = false;
if (irss == null)
{
LogErr("Not connected");
return(_learnSuccess);
}
if (!irss.Connected)
{
LogWarn("...Connecting...");
return(_learnSuccess);
}
if (!ServerInfo.CanLearn)
{
LogErr("IR Server is not setup to support learning");
return(_learnSuccess);
}
try
{
// make filename
_irFile = irName;
if (_irFile == null)
{
_irFile = "";
}
if (_irFile != "" && !_irFile.ToUpper().EndsWith(Common.FileExtensionIR))
{
_irFile += Common.FileExtensionIR;
}
IrssMessage message = new IrssMessage(MessageType.LearnIR, MessageFlags.Request);
irss.Send(message);
System.Console.WriteLine("Hold your remote close to the receiver and press the button to learn");
LogInfo("Learning...");
_learntEvent.WaitOne(millisecondsTimeout);
if (_learnSuccess)
{
LogInfo("Learning successful: " + _irFile);
}
else
{
LogErr("Learning failed");
}
}
catch (Exception ex)
{
LogErr(ex.Message);
}
return(_learnSuccess);
}
private void ReceivedMessage(IrssMessage received)
{
Invoke(_addStatusLine, String.Format("Received Message: \"{0}, {1}\"", received.Type, received.Flags));
try
{
switch (received.Type)
{
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_registered = true;
//_irServerInfo = IRServerInfo.FromBytes(received.GetDataAsBytes());
_client.Send(new IrssMessage(MessageType.ActiveReceivers, MessageFlags.Request));
_client.Send(new IrssMessage(MessageType.ActiveBlasters, MessageFlags.Request));
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
}
return;
case MessageType.ActiveBlasters:
Invoke(_addStatusLine, received.GetDataAsString());
break;
case MessageType.ActiveReceivers:
Invoke(_addStatusLine, received.GetDataAsString());
string[] receivers = received.GetDataAsString().Split(new[] { ',' },
StringSplitOptions.RemoveEmptyEntries);
Invoke(_setDevices, receivers, "ActiveReceivers");
break;
case MessageType.RemoteEvent:
string deviceName = received.MessageData[IrssMessage.DEVICE_NAME] as string;
string keyCode = received.MessageData[IrssMessage.KEY_CODE] as string;
RemoteHandlerCallback(deviceName, keyCode);
return;
case MessageType.ServerShutdown:
_registered = false;
return;
case MessageType.Error:
Invoke(_addStatusLine, received.GetDataAsString());
return;
}
}
catch (Exception ex)
{
Invoke(_addStatusLine, ex.Message);
}
}
private static void Connected(object obj)
{
IrssLog.Info("Connected to server");
UpdateTrayIcon("Media Center Blaster", Resources.Icon16);
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
private static void Connected(object obj)
{
IrssLog.Info("Connected to server");
_notifyIcon.Text = "Keyboard Input Relay";
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_client.Send(message);
}
private void disconnectToolStripMenuItem_Click(object sender, EventArgs e)
{
if (_registered)
{
IrssMessage message = new IrssMessage(MessageType.UnregisterClient, MessageFlags.Request);
_client.Send(message);
_registered = false;
}
StopClient();
}
private static void SendMessage(IrssMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (_client != null)
{
_client.Send(message);
}
}
/// <summary>
/// Destroy the IRSS client instance.
/// </summary>
public void Dispose()
{
if (Connected)
{
IrssMessage message = new IrssMessage(MessageType.UnregisterClient, MessageFlags.Request);
irss.Send(message);
Connected = false;
}
irss.Stop();
irss.Dispose();
}
private void disconnectToolStripMenuItem_Click(object sender, EventArgs e)
{
if (_registered)
{
IrssMessage message = new IrssMessage(MessageType.UnregisterClient, MessageFlags.Request);
_client.Send(message);
_registered = false;
}
Invoke(new UpdateWindowDel(UpdateWindow), new string[] { "Disconnected" });
StopClient();
}
private void buttonLearn_Click(object sender, EventArgs e)
{
if (!_registered)
{
MessageBox.Show(this, "Not registered to an active IR Server", "Cannot learn", MessageBoxButtons.OK,
MessageBoxIcon.Warning);
}
Invoke(new UpdateWindowDel(UpdateWindow), new string[] { "Learning ..." });
IrssMessage message = new IrssMessage(MessageType.LearnIR, MessageFlags.Request);
_client.Send(message);
}
private 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.RemoteEvent:
string deviceName = received.MessageData[IrssMessage.DEVICE_NAME] as string;
string keyCode = received.MessageData[IrssMessage.KEY_CODE] as string;
RemoteHandlerCallback(deviceName, keyCode);
break;
case MessageType.ServerShutdown:
IrssLog.Warn("IR Server Shutdown - Tray Launcher disabled until IR Server returns");
_registered = false;
break;
case MessageType.Error:
IrssLog.Error("Received error: {0}", received.GetDataAsString());
break;
}
if (_handleMessage != null)
{
_handleMessage(received);
}
}
catch (Exception ex)
{
IrssLog.Error("ReceivedMessage(): {0}", ex.ToString());
}
}
internal static void ButtonPress(string keyCode)
{
#if TRACE
Trace.WriteLine("ButtonPress: " + keyCode);
#endif
if (!_registered)
{
return;
}
byte[] bytes = IrssMessage.EncodeRemoteEventData(_device, keyCode);
IrssMessage message = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Notify, bytes);
SendMessage(message);
}
private static void ReceivedMessage(IrssMessage received)
{
IrssLog.Debug("Received Message \"{0}\"", received.Type);
try
{
switch (received.Type)
{
case MessageType.BlastIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
Info("Blast Success");
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
Warn("Blast Failed!");
}
break;
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
Info("Registered to IR Server");
_registered = true;
//_irServerInfo = TransceiverInfo.FromString(received.Data);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
Warn("IR Server refused to register");
}
break;
case MessageType.ServerShutdown:
_registered = false;
Warn("IR Server Shutdown - Blasting disabled until IR Server returns");
break;
case MessageType.Error:
Warn(received.GetDataAsString());
break;
}
}
catch (Exception ex)
{
Error(ex);
}
}
private void ReceivedMessage(IrssMessage received)
{
IrssLog.Debug("Received Message \"{0}\"", received.Type);
try
{
switch (received.Type)
{
case MessageType.RemoteEvent:
if (listViewButtons.SelectedItems.Count == 1)
{
string keyCode = received.MessageData[IrssMessage.KEY_CODE] as string;
listViewButtons.SelectedItems[0].SubItems[1].Text = keyCode;
}
return;
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_registered = true;
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
MessageBox.Show(this, "Failed to register with server", "Virtual Remote Skin Editor Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return;
case MessageType.ServerShutdown:
MessageBox.Show(this, "Server has been shut down", "Virtual Remote Skin Editor Error", MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
case MessageType.Error:
MessageBox.Show(this, received.GetDataAsString(), "Virtual Remote Skin Editor Error from Server",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
catch (Exception ex)
{
IrssLog.Error(ex);
MessageBox.Show(this, ex.Message, "Virtual Remote Skin Editor Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void MessageReceiver(IrssMessage received)
{
if (received.Type == MessageType.RemoteEvent)
{
string deviceName = received.MessageData[IrssMessage.DEVICE_NAME] as string;
string keyCode = received.MessageData[IrssMessage.KEY_CODE] as string;
_deviceName = deviceName;
// TODO: When Abstract Remote Model becomes on by default
//if (deviceName.Equals("Abstract", StringComparison.OrdinalIgnoreCase)
_keyCode = keyCode;
//else
// _keyCode = String.Format("{0} ({1})", deviceName, keyCode);
Invoke(_keyCodeSet);
}
}
private void ReceivedMessage(IrssMessage received)
{
if (_learnIR != null && received.Type == MessageType.LearnIR)
{
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_learnIR.LearnStatus("Learned IR successfully", true);
}
else if ((received.Flags & MessageFlags.Timeout) == MessageFlags.Timeout)
{
_learnIR.LearnStatus("Learn IR timed out", false);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_learnIR.LearnStatus("Learn IR failed", false);
}
}
}
private static void SendMessage(IrssMessage message)
{
if (message == null)
throw new ArgumentNullException("message");
if (_client != null)
_client.Send(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();
}
private static void Connected(object obj)
{
IrssLog.Info("Connected to server");
IrssMessage message = new IrssMessage(MessageType.RegisterClient, MessageFlags.Request);
_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);
}
}
