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); } }