/// <summary>
/// Given a byte array this method returns the deserialized IRServerInfo object.
/// </summary>
/// <param name="dataBytes">Byte array of serialized IRServerInfo object.</param>
/// <returns>IRServerInfo object.</returns>
public static IRServerInfo FromBytes(byte[] dataBytes)
{
try
{
string dataString = Encoding.ASCII.GetString(dataBytes);
string[] data = dataString.Split(',');
IRServerInfo irServerInfo = new IRServerInfo();
irServerInfo.CanLearn = bool.Parse(data[0]);
irServerInfo.CanReceive = bool.Parse(data[1]);
irServerInfo.CanTransmit = bool.Parse(data[2]);
int portIndex = 3;
int portCount = int.Parse(data[portIndex]);
irServerInfo.Ports = new string[portCount];
for (int index = portIndex + 1; index <= portIndex + portCount; index++)
{
irServerInfo.Ports[index - (portIndex + 1)] = data[index];
}
return(irServerInfo);
}
catch
{
return(null);
}
}
//------------------------------------------------------------------------------------------------------------------
#region ctors
/// <summary>
/// Just create a .NET instance of an IRSS client. The Connect() method must be used to connect the client to an IRSS server.
/// </summary>
public IRClient()
{
ServerHost = "";
Connected = false;
ServerInfo = new IRServerInfo();
_connectedEvent = new AutoResetEvent(false);
_learntEvent = new AutoResetEvent(false);
}
// --------------------------------------------------------------------------------------------------
#region Constructor
public CommandManager(IRServerInfo server = null, BlastIrDelegate BlastFunc = null, LearnIrDelegate LearnIrFunc = null, ProcessCommandDelegate processCommand = null, bool script = false)
{
InitializeComponent();
IRServer = server;
_BlastFunc = BlastFunc;
_LearnIrFunc = LearnIrFunc;
_ProcessCommand = processCommand;
_showGeneralCmds = true;
_showScriptCmds = script;
_showMacroCmds = true;
_showMediaPortalCmds = false;
_showServerCmds = BlastFunc != null && LearnIrFunc != null;
_macroCommands = null;
learnIRCommandToolStripMenuItem.Enabled = _LearnIrFunc != null;
PopulateCommandList();
}
private static void ReceivedMessage(IrssMessage received)
{
Log.Debug("TV2BlasterPlugin: Received Message \"{0}\"", received.Type);
try
{
switch (received.Type)
{
case MessageType.BlastIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
Log.Debug("TV2BlasterPlugin: Blast successful");
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
Log.Error("TV2BlasterPlugin: Failed to blast IR command");
}
break;
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_irServerInfo = IRServerInfo.FromBytes(received.GetDataAsBytes());
_registered = true;
Log.Debug("TV2BlasterPlugin: Registered to IR Server");
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
_registered = false;
Log.Error("TV2BlasterPlugin: IR Server refused to register");
}
break;
case MessageType.LearnIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
Log.Debug("TV2BlasterPlugin: Learned IR Successfully");
byte[] dataBytes = received.GetDataAsBytes();
using (FileStream file = File.Create(_learnIRFilename))
file.Write(dataBytes, 0, dataBytes.Length);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
Log.Error("TV2BlasterPlugin: Failed to learn IR command");
}
else if ((received.Flags & MessageFlags.Timeout) == MessageFlags.Timeout)
{
Log.Error("TV2BlasterPlugin: Learn IR command timed-out");
}
_learnIRFilename = null;
break;
case MessageType.ServerShutdown:
Log.Info("TV2BlasterPlugin: IR Server Shutdown - Plugin disabled until IR Server returns");
_registered = false;
break;
case MessageType.Error:
_learnIRFilename = null;
Log.Error("TV2BlasterPlugin: Received error: {0}", received.GetDataAsString());
break;
}
if (_handleMessage != null)
_handleMessage(received);
}
catch (Exception ex)
{
_learnIRFilename = null;
Log.Error(ex);
}
}
void ReceivedMessage(IrssMessage received)
{
ServiceRegistration.Get<ILogger>().Debug("IrInputPlugin: Received Message '{0}' {1}", received.Type, received.GetDataAsString());
try
{
switch (received.Type)
{
case MessageType.RemoteEvent:
string keyCode = received.MessageData[IrssMessage.KEY_CODE] as string;
RemoteHandler(keyCode);
break;
// TODO: What to do with this code?
/*
case MessageType.BlastIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
ServiceRegistration.Get<ILogger>().Info("IrInputPlugin: Blast successful");
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
ServiceRegistration.Get<ILogger>().Warn("IrInputPlugin: Failed to blast IR command");
break;
*/
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_irServerInfo = IRServerInfo.FromBytes(received.GetDataAsBytes());
ServiceRegistration.Get<ILogger>().Info("IrInputPlugin: Registered to Input Service '{0}'", _irServerInfo);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
ServiceRegistration.Get<ILogger>().Warn("IrInputPlugin: Input Service refused to register plugin");
break;
// TODO: What to do with this code?
/*
case MessageType.LearnIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
ServiceRegistration.Get<ILogger>().Info("IrInputPlugin: Learned IR Successfully");
byte[] dataBytes = received.GetDataAsBytes();
using (FileStream file = File.Create(_learnIRFilename))
file.Write(dataBytes, 0, dataBytes.Length);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
ServiceRegistration.Get<ILogger>().Error("IrInputPlugin: Failed to learn IR command");
else if ((received.Flags & MessageFlags.Timeout) == MessageFlags.Timeout)
ServiceRegistration.Get<ILogger>().Error("IrInputPlugin: Learn IR command timed-out");
break;
*/
case MessageType.ServerShutdown:
ServiceRegistration.Get<ILogger>().Warn("IrInputPlugin: Input Service shutdown - IrInputPlugin is disabled until Input Service returns");
break;
case MessageType.Error:
ServiceRegistration.Get<ILogger>().Error("IrInputPlugin: Received error '{0}'", received.GetDataAsString());
break;
}
}
catch (Exception ex)
{
ServiceRegistration.Get<ILogger>().Error("Problem receiving IR message: {0}", ex);
}
}
private static void ReceivedMessage(IrssMessage received)
{
IrssLog.Debug("Received Message \"{0}\"", received.Type);
try
{
switch (received.Type)
{
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.KeyboardEvent:
{
int vKey = (int)received.MessageData[IrssMessage.V_KEY];
bool keyUp = (bool)received.MessageData[IrssMessage.KEY_UP];
KeyboardHandlerCallback("TODO", vKey, keyUp);
break;
}
case MessageType.MouseEvent:
{
int deltaX = (int)received.MessageData[IrssMessage.DELTA_X];
int deltaY = (int)received.MessageData[IrssMessage.DELTA_Y];
int buttons = (int)received.MessageData[IrssMessage.BUTTONS];
MouseHandlerCallback("TODO", deltaX, deltaY, buttons);
break;
}
case MessageType.BlastIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
IrssLog.Info("Blast successful");
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
IrssLog.Error("Failed to blast IR command");
break;
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_irServerInfo = IRServerInfo.FromBytes(received.GetDataAsBytes());
_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.LearnIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
IrssLog.Info("Learned IR Successfully");
byte[] dataBytes = received.GetDataAsBytes();
using (FileStream file = File.Create(_learnIRFilename))
file.Write(dataBytes, 0, dataBytes.Length);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
IrssLog.Error("Failed to learn IR command");
}
else if ((received.Flags & MessageFlags.Timeout) == MessageFlags.Timeout)
{
IrssLog.Warn("Learn IR command timed-out");
}
_learnIRFilename = null;
break;
case MessageType.ServerShutdown:
IrssLog.Warn("IR Server Shutdown - Translator disabled until IR Server returns");
_registered = false;
_notifyIcon.Icon = Resources.Icon16Connecting;
_notifyIcon.Text = "Translator - Connecting ...";
break;
case MessageType.Error:
_learnIRFilename = null;
IrssLog.Error("Received error: {0}", received.GetDataAsString());
break;
}
if (_handleMessage != null)
_handleMessage(received);
}
catch (Exception ex)
{
_learnIRFilename = null;
IrssLog.Error(ex);
}
}
private void ReceivedMessage(IrssMessage received)
{
Invoke(_addStatusLine,
new Object[] { String.Format("Received Message: \"{0}, {1}\"", received.Flags , received.Type) });
try
{
switch (received.Type)
{
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
_registered = true;
_irServerInfo = IRServerInfo.FromBytes(received.GetDataAsBytes());
comboBoxPort.Items.Clear();
comboBoxPort.Items.AddRange(_irServerInfo.Ports);
comboBoxPort.SelectedIndex = 0;
_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, new Object[] {received.GetDataAsString()});
break;
case MessageType.ActiveReceivers:
Invoke(_addStatusLine, new Object[] {received.GetDataAsString()});
break;
case MessageType.RemoteEvent:
string deviceName = received.MessageData[IrssMessage.DEVICE_NAME] as string;
string keyCode = received.MessageData[IrssMessage.KEY_CODE] as string;
Invoke(_addStatusLine, new Object[] {String.Format("{0} ({1})", deviceName, keyCode)});
return;
case MessageType.LearnIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
byte[] dataBytes = received.GetDataAsBytes();
using (FileStream file = File.Create(_learnIRFilename))
file.Write(dataBytes, 0, dataBytes.Length);
}
_learnIRFilename = null;
break;
case MessageType.ServerShutdown:
_registered = false;
return;
case MessageType.Error:
_learnIRFilename = null;
Invoke(_addStatusLine, new Object[] {received.GetDataAsString()});
return;
}
}
catch (Exception ex)
{
Invoke(_addStatusLine, new Object[] {ex.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.GetDataAsBytes());
_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.BlastIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
IrssLog.Debug("Blast successful");
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
IrssLog.Error("Failed to blast IR command");
}
break;
case MessageType.LearnIR:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
IrssLog.Debug("Learnt IR Successfully");
byte[] dataBytes = received.GetDataAsBytes();
using (FileStream file = File.Create(_learnIRFilename))
file.Write(dataBytes, 0, dataBytes.Length);
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
IrssLog.Error("Failed to learn IR command");
}
else if ((received.Flags & MessageFlags.Timeout) == MessageFlags.Timeout)
{
IrssLog.Error("Learn IR command timed-out");
}
_learnIRFilename = null;
break;
case MessageType.ServerShutdown:
IrssLog.Warn("IR Server Shutdown - Media Center Blaster 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());
}
}
/// <summary>
/// Given a byte array this method returns the deserialized IRServerInfo object.
/// </summary>
/// <param name="dataBytes">Byte array of serialized IRServerInfo object.</param>
/// <returns>IRServerInfo object.</returns>
public static IRServerInfo FromBytes(byte[] dataBytes)
{
try
{
string dataString = Encoding.ASCII.GetString(dataBytes);
string[] data = dataString.Split(',');
IRServerInfo irServerInfo = new IRServerInfo();
irServerInfo.CanLearn = bool.Parse(data[0]);
irServerInfo.CanReceive = bool.Parse(data[1]);
irServerInfo.CanTransmit = bool.Parse(data[2]);
int portIndex = 3;
int portCount = int.Parse(data[portIndex]);
irServerInfo.Ports = new string[portCount];
for (int index = portIndex + 1; index <= portIndex + portCount; index++)
irServerInfo.Ports[index - (portIndex + 1)] = data[index];
return irServerInfo;
}
catch
{
return null;
}
}
private void ServerReceivedMessage(MessageManagerCombo combo)
{
IrssLog.Debug("Server message received: {0}, {1}", combo.Message.Type, combo.Message.Flags);
try
{
switch (combo.Message.Type)
{
#region ForwardRemoteEvent
case MessageType.ForwardRemoteEvent:
if (Settings.Mode == IRServerMode.RelayMode)
{
IrssMessage forward = new IrssMessage(MessageType.ForwardRemoteEvent, MessageFlags.Request,
combo.Message.GetDataAsBytes());
_client.Send(forward);
}
else
{
byte[] data = combo.Message.GetDataAsBytes();
if (Settings.AbstractRemoteMode)
{
// Decode message ...
string deviceName = combo.Message.MessageData[IrssMessage.DEVICE_NAME] as string;
string keyCode = combo.Message.MessageData[IrssMessage.KEY_CODE] as string;
// Check that the device maps are loaded for the forwarded device
bool foundDevice = false;
if (_receivePlugins != null)
{
foreach (PluginBase plugin in _receivePlugins)
{
if (plugin is IRemoteReceiver && plugin.Name.Equals(deviceName, StringComparison.OrdinalIgnoreCase))
{
foundDevice = true;
break;
}
}
}
// If the remote maps are not already loaded for this device then attempt to load them
if (!foundDevice)
foundDevice = LoadAbstractDeviceFiles(deviceName);
// If the device map is loaded then try to convert the button to abstract
if (foundDevice)
{
// Find abstract button mapping
string abstractButton = LookupAbstractButton(deviceName, keyCode);
if (String.IsNullOrEmpty(abstractButton))
{
IrssLog.Info("Abstract Remote Button mapped from forwarded remote event: {0}", abstractButton);
// Encode new message ...
data = IrssMessage.EncodeRemoteEventData("Abstract", abstractButton);
}
else
{
IrssLog.Info("Abstract Remote Button not found for forwarded remote event: {0} ({1})", deviceName,
keyCode);
}
}
}
IrssMessage forward = new IrssMessage(MessageType.RemoteEvent, MessageFlags.Notify, data);
SendToAllExcept(combo.Manager, forward);
}
break;
#endregion ForwardRemoteEvent
#region ForwardKeyboardEvent
case MessageType.ForwardKeyboardEvent:
if (Settings.Mode == IRServerMode.RelayMode)
{
IrssMessage forward = new IrssMessage(MessageType.ForwardKeyboardEvent, MessageFlags.Request,
combo.Message.GetDataAsBytes());
_client.Send(forward);
}
else
{
IrssMessage forward = new IrssMessage(MessageType.KeyboardEvent, MessageFlags.Notify,
combo.Message.GetDataAsBytes());
SendToAllExcept(combo.Manager, forward);
}
break;
#endregion ForwardKeyboardEvent
#region ForwardMouseEvent
case MessageType.ForwardMouseEvent:
if (Settings.Mode == IRServerMode.RelayMode)
{
IrssMessage forward = new IrssMessage(MessageType.ForwardMouseEvent, MessageFlags.Request,
combo.Message.GetDataAsBytes());
_client.Send(forward);
}
else
{
IrssMessage forward = new IrssMessage(MessageType.MouseEvent, MessageFlags.Notify,
combo.Message.GetDataAsBytes());
SendToAllExcept(combo.Manager, forward);
}
break;
#endregion ForwardMouseEvent
#region BlastIR
case MessageType.BlastIR:
{
IrssMessage response = new IrssMessage(MessageType.BlastIR, MessageFlags.Response);
if (Settings.Mode == IRServerMode.RelayMode)
{
response.Flags |= MessageFlags.Failure;
}
else
{
if (_registeredRepeaters.Count > 0)
SendToRepeaters(combo.Message);
if (BlastIR(combo.Message.GetDataAsBytes()))
response.Flags |= MessageFlags.Success;
else
response.Flags |= MessageFlags.Failure;
}
if ((combo.Message.Flags & MessageFlags.ForceNotRespond) != MessageFlags.ForceNotRespond)
SendTo(combo.Manager, response);
break;
}
#endregion BlastIR
#region LearnIR
case MessageType.LearnIR:
{
IrssMessage response = new IrssMessage(MessageType.LearnIR, MessageFlags.Response);
if (Settings.Mode == IRServerMode.RelayMode)
{
response.Flags |= MessageFlags.Failure;
}
else
{
byte[] bytes;
LearnStatus status = LearnIR(out bytes);
switch (status)
{
case LearnStatus.Success:
response.Flags |= MessageFlags.Success;
response.SetDataAsBytes(bytes);
break;
case LearnStatus.Failure:
response.Flags |= MessageFlags.Failure;
break;
case LearnStatus.Timeout:
response.Flags |= MessageFlags.Timeout;
break;
}
}
SendTo(combo.Manager, response);
break;
}
#endregion LearnIR
#region ServerShutdown
case MessageType.ServerShutdown:
if ((combo.Message.Flags & MessageFlags.Request) == MessageFlags.Request)
{
IrssLog.Info("Shutdown command received");
Stop();
}
break;
#endregion ServerShutdown
#region RegisterClient
case MessageType.RegisterClient:
{
IrssMessage response = new IrssMessage(MessageType.RegisterClient, MessageFlags.Response);
if (RegisterClient(combo.Manager))
{
IRServerInfo irServerInfo = new IRServerInfo();
if (_receivePlugins != null)
irServerInfo.CanReceive = true;
if (_transmitPlugin != null)
{
irServerInfo.CanLearn = (_transmitPlugin is ILearnIR);
irServerInfo.CanTransmit = true;
irServerInfo.Ports = ((ITransmitIR)_transmitPlugin).AvailablePorts;
}
response.SetDataAsBytes(irServerInfo.ToBytes());
response.Flags |= MessageFlags.Success;
}
else
{
response.Flags |= MessageFlags.Failure;
}
SendTo(combo.Manager, response);
break;
}
#endregion RegisterClient
#region UnregisterClient
case MessageType.UnregisterClient:
UnregisterClient(combo.Manager);
break;
#endregion UnregisterClient
#region RegisterRepeater
case MessageType.RegisterRepeater:
{
IrssMessage response = new IrssMessage(MessageType.RegisterRepeater, MessageFlags.Response);
if (RegisterRepeater(combo.Manager))
response.Flags |= MessageFlags.Success;
else
response.Flags |= MessageFlags.Failure;
SendTo(combo.Manager, response);
break;
}
#endregion RegisterRepeater
#region UnregisterRepeater
case MessageType.UnregisterRepeater:
UnregisterRepeater(combo.Manager);
break;
#endregion UnregisterRepeater
#region ActiveBlasters
case MessageType.ActiveBlasters:
{
IrssMessage response = new IrssMessage(MessageType.ActiveBlasters, MessageFlags.Response);
response.SetDataAsString(Settings.PluginNameTransmit);
SendTo(combo.Manager, response);
break;
}
#endregion ActiveBlasters
#region ActiveReceivers
case MessageType.ActiveReceivers:
{
IrssMessage response = new IrssMessage(MessageType.ActiveReceivers, MessageFlags.Response);
if (Settings.PluginNameReceive != null)
{
StringBuilder receivers = new StringBuilder();
for (int index = 0; index < Settings.PluginNameReceive.Length; index++)
{
receivers.Append(Settings.PluginNameReceive[index]);
if (index < Settings.PluginNameReceive.Length - 1)
receivers.Append(',');
}
response.SetDataAsString(receivers.ToString());
}
else
{
response.SetDataAsString(null);
}
SendTo(combo.Manager, response);
break;
}
#endregion ActiveReceivers
#region AvailableBlasters
case MessageType.AvailableBlasters:
{
IrssMessage response = new IrssMessage(MessageType.AvailableBlasters, MessageFlags.Response);
PluginBase[] plugins = BasicFunctions.AvailablePlugins();
StringBuilder blasters = new StringBuilder();
for (int index = 0; index < plugins.Length; index++)
{
PluginBase plugin = plugins[index];
if (plugin is ITransmitIR)
{
blasters.Append(plugin.Name);
blasters.Append(',');
}
}
if (blasters.Length == 0)
{
response.SetDataAsString(null);
}
else
{
blasters.Remove(blasters.Length - 1, 1);
response.SetDataAsString(blasters.ToString());
}
SendTo(combo.Manager, response);
break;
}
#endregion AvailableBlasters
#region AvailableReceivers
case MessageType.AvailableReceivers:
{
IrssMessage response = new IrssMessage(MessageType.AvailableReceivers, MessageFlags.Response);
PluginBase[] plugins = BasicFunctions.AvailablePlugins();
StringBuilder receivers = new StringBuilder();
for (int index = 0; index < plugins.Length; index++)
{
PluginBase plugin = plugins[index];
if (plugin is IRemoteReceiver || plugin is IKeyboardReceiver || plugin is IMouseReceiver)
{
receivers.Append(plugin.Name);
receivers.Append(',');
}
}
if (receivers.Length == 0)
{
response.SetDataAsString(null);
}
else
{
receivers.Remove(receivers.Length - 1, 1);
response.SetDataAsString(receivers.ToString());
}
SendTo(combo.Manager, response);
break;
}
#endregion AvailableReceivers
#region DetectedBlasters
case MessageType.DetectedBlasters:
{
IrssMessage response = new IrssMessage(MessageType.DetectedBlasters, MessageFlags.Response);
string[] detectedBlasters = Shared.DetectBlasters();
if (detectedBlasters != null && detectedBlasters.Length > 0)
{
StringBuilder blasters = new StringBuilder();
for (int index = 0; index < detectedBlasters.Length; index++)
{
blasters.Append(detectedBlasters[index]);
if (index < detectedBlasters.Length - 1)
blasters.Append(',');
}
response.SetDataAsString(blasters.ToString());
}
else
{
response.SetDataAsString(null);
}
SendTo(combo.Manager, response);
break;
}
#endregion DetectedBlasters
#region DetectedReceivers
case MessageType.DetectedReceivers:
{
IrssMessage response = new IrssMessage(MessageType.DetectedReceivers, MessageFlags.Response);
string[] detectedReceivers = Shared.DetectReceivers();
if (detectedReceivers != null && detectedReceivers.Length > 0)
{
StringBuilder receivers = new StringBuilder();
for (int index = 0; index < detectedReceivers.Length; index++)
{
receivers.Append(detectedReceivers[index]);
if (index < detectedReceivers.Length - 1)
receivers.Append(',');
}
response.SetDataAsString(receivers.ToString());
}
else
{
response.SetDataAsString(null);
}
SendTo(combo.Manager, response);
break;
}
#endregion DetectedReceivers
}
}
catch (Exception ex)
{
IrssLog.Error(ex);
IrssMessage response = new IrssMessage(MessageType.Error, MessageFlags.Notify, ex.Message);
SendTo(combo.Manager, response);
}
}
// --------------------------------------------------------------------------------------------------
#region Constructor
/// <summary>
/// Creates a Macro Editor windows form.
/// </summary>
/// <param name="name">The name of an existing macro (default: new macro).</param>
public MacroEditor(string name = "", IRServerInfo server = null, BlastIrDelegate blast = null, LearnIrDelegate learnIr=null, ProcessCommandDelegate processCommand=null, bool insertionEnabled = true)
{
if (name==null) name = "";
_insertionEnabled = insertionEnabled;
_editionEnabled = !IsOpen(name);
_OpenInstances.Add(name.ToLower());
_name = name;
_server = server;
_blast = blast;
_learnIr = learnIr;
_ProcessCommand = processCommand;
InitializeComponent();
textBoxName.Text = name;
buttonTest.Enabled = _ProcessCommand != null;
buttonOK.Visible = _insertionEnabled || _editionEnabled;
buttonOK.Enabled = _insertionEnabled;
_MacroNameValid = name != "";
buttonShortcut.Enabled = _MacroNameValid;
if (_editionEnabled && !_insertionEnabled || _name == "")
{ // Show save first
buttonOK.Enabled = false;
buttonOK.Text = "Save";
this.buttonOK.Image = global::IrssUtils.Properties.Resources.Save;
}
else
{
buttonOK.Enabled = _insertionEnabled;
}
if (_editionEnabled)
{
InitializeCommandManager();
}
else
{
// Relayout for Read-only mode
labelInvalid.Text = "Macro is already open for edition";
labelInvalid.Show();
textBoxName.Enabled = false;
groupBoxCommandSequence.Controls.Remove(splitContainerMain);
groupBoxCommandSequence.Controls.Add(panelActions);
this.MinimumSize = new System.Drawing.Size(310, this.Height);
this.Width = 350;
}
if (_name == "") return;
try
{
string fileName = Path.Combine(FolderMacros, name + Common.FileExtensionMacro);
string[] commands = IrssMacro.ReadFromFile(fileName);
foreach (var cmd in commands)
{
InsertCommand(cmd);
}
}
catch (Exception ex)
{
IrssLog.Error(ex);
MessageBox.Show(this, ex.Message, "Failed to load macro: " + name + Common.FileExtensionMacro, MessageBoxButtons.OK, MessageBoxIcon.Error);
textBoxName.Text = "";
}
_editedMacro = false;
}
//------------------------------------------------------------------------------------------------------------------
#region callbacks
/// <summary>
/// Socket-communication callback to receive message from the IRSS server.
/// </summary>
/// <param name="received">received message, defined mostly by a Type and Flags</param>
private void ReceivedMessage(IrssMessage received)
{
// default (most common) values
RemoteEventArgs args = new RemoteEventArgs();
args.Sender = RemoteEventArgs.IrServer;
args.Key = received.Type.ToString();
args.Data = received.Flags.ToString() + ": " + received.GetDataAsString();
try
{
switch (received.Type)
{
case MessageType.RegisterClient:
if ((received.Flags & MessageFlags.Success) == MessageFlags.Success)
{
Connected = true;
ServerInfo = IRServerInfo.FromBytes(received.GetDataAsBytes());
irss.Send(new IrssMessage(MessageType.ActiveReceivers, MessageFlags.Request));
irss.Send(new IrssMessage(MessageType.ActiveBlasters, MessageFlags.Request));
_connectedEvent.Set();
}
else if ((received.Flags & MessageFlags.Failure) == MessageFlags.Failure)
{
Connected = false;
}
break;
case MessageType.ActiveBlasters:
LogInfo(received.GetDataAsString());
break;
case MessageType.ActiveReceivers:
LogInfo(received.GetDataAsString());
break;
case MessageType.RemoteEvent:
// raise the event
args.Sender = received.MessageData[IrssMessage.DEVICE_NAME] as string;
args.Key = received.MessageData[IrssMessage.KEY_CODE] as string;
args.Data = "";
break;
case MessageType.LearnIR:
_learnSuccess = (received.Flags & MessageFlags.Success) == MessageFlags.Success;
if (_learnSuccess)
{
byte[] dataBytes = received.GetDataAsBytes();
if (_irFile != null && _irFile != "")
{
string DebugIRFile = Path.Combine(Common.FolderIRCommands, _irFile);
using (FileStream file = File.Create(DebugIRFile))
file.Write(dataBytes, 0, dataBytes.Length);
}
}
_learntEvent.Set();
break;
case MessageType.ServerShutdown:
Connected = false;
LogInfo("Disconnected by host " + ServerHost);
LogInfo(received.GetDataAsString());
break;
case MessageType.Error:
LogErr(received.GetDataAsString());
break;
}
}
catch (Exception ex)
{
LogErr(ex.Message);
args.Key = "Error";
args.Data = "ex.Message";
}
LogDebug(String.Format("rise RemoteEvent: Sender: {0} - Key: {1} - Data: {2}", args.Sender, args.Key, args.Data));
OnRemoteEvent(args);
}
