/// <summary> /// Routes the message specified within the event arguments, invoking any associated delegates where possible. /// </summary> /// <param name="client">The Stream Deck client.</param> /// <param name="e">The <see cref="WebSocketMessageEventArgs" /> instance containing the event data.</param> public Task RouteAsync(StreamDeckClient client, WebSocketMessageEventArgs e) { // determine if there is an event specified, and a delegate handler var jArgs = JObject.Parse(e.Message); if (!jArgs.TryGetString(nameof(StreamDeckEventArgs.Event), out var @event) || !EventMethodCache.Value.TryGetValue(@event, out var @delegate)) { this.Logger?.LogWarning("Unrecognised event received from Elgato Stream Deck: {0}", @event); return(Task.CompletedTask); } // determine the owner of the delegate, based on the event args var owner = this.TryGetActionInfo(jArgs, out var actionInfo) ? this.GetActionOrClient(jArgs, actionInfo, client) : client; try { return((Task)@delegate.Invoke(owner, new[] { jArgs.ToObject(@delegate.GetParameters()[0].ParameterType) })); } catch (Exception ex) { throw new ActionInvokeException(actionInfo.context, ex); } }
private async Task OnExecuteAsync() { var cancellationTokenSource = new CancellationTokenSource(); var streamDeck = new StreamDeckClient(Port, PluginUuid, RegisterEvent, Info); streamDeck.KeyDownEventAsync += UpdateCounter; await streamDeck.RunAsync(cancellationTokenSource.Token); }
internal static async Task <(StreamDeckSoftwareEmulator emulator, StreamDeckClient client)> ConnectAsync(int port, string pluginUUID) { var emulator = new StreamDeckSoftwareEmulator(port, pluginUUID); string[] args = emulator.Start(); var sut = new StreamDeckClient(Assembly.GetExecutingAssembly(), args); sut.RunAsync(); await emulator.AwaitConnectionAsync(); return(emulator, sut); }
/// <summary> /// Defines the entry point of the application. /// </summary> /// <param name="args">The arguments.</param> public static void Main(string[] args) { #if DEBUG Debugger.Launch(); #endif using (var client = new StreamDeckClient(args)) { // register our custom action, and start the client client.RegisterAction("com.sharpdeck.testplugin.counter", () => new CounterAction(500)); client.Start(); } }
public static async Task Main(string[] args) { var client = new StreamDeckClient(args); await client.RunAsync(); }
/// <summary> /// Processes the parameters passed by StreamDeck and starts the registration process. /// </summary> /// <param name="args">The arguments as passed to the main() method.</param> public void Run(string[] args) { var portString = GetArgument(args, StreamDeckConsts.kESDSDKPortParameter); var pluginUUID = GetArgument(args, StreamDeckConsts.kESDSDKPluginUUIDParameter); var registerEvent = GetArgument(args, StreamDeckConsts.kESDSDKRegisterEventParameter); var infoString = GetArgument(args, StreamDeckConsts.kESDSDKInfoParameter); if (portString == null) { throw new StreamDeckMissingParameter($"{StreamDeckConsts.kESDSDKPortParameter} argument missing"); } if (pluginUUID == null) { throw new StreamDeckMissingParameter($"{StreamDeckConsts.kESDSDKPluginUUIDParameter} argument missing"); } if (registerEvent == null) { throw new StreamDeckMissingParameter($"{StreamDeckConsts.kESDSDKRegisterEventParameter} argument missing"); } if (infoString == null) { throw new StreamDeckMissingParameter($"{StreamDeckConsts.kESDSDKInfoParameter} argument missing"); } if (!int.TryParse(portString, out var port) || port < 0 || port > 65535) { throw new StreamDeckInvalidParameter("-port argument must be an integer between 0 and 65536"); } var info = JsonConvert.DeserializeObject <StreamDeckInfo>(infoString); var cancellationTokenSource = new CancellationTokenSource(); Console.CancelKeyPress += (sender, eventArgs) => { eventArgs.Cancel = true; Console.WriteLine("Closing connection..."); cancellationTokenSource.Cancel(); }; var loggerInstance = logger ?? (Debugger.IsAttached ? (IStreamDeckLogger) new DebugLogger() : new DevNullLogger()); using (var worker = new StreamDeckClient(loggerInstance, new StreamDeckEventHandlerFactory(this), port, pluginUUID, registerEvent, info)) { // ReSharper disable MethodSupportsCancellation - handled by StreamDeckWorker // ReSharper disable once AccessToDisposedClosure - not an issue, task is awaited var workerTask = Task.Run(async() => { await worker.Run(cancellationTokenSource.Token); }); try { workerTask.Wait(); } catch (AggregateException e) { if (e.InnerExceptions.Count != 1 || !(e.InnerExceptions[0] is TaskCanceledException)) { throw; } } catch (TaskCanceledException) { // This space intentionally left blank } // ReSharper restore MethodSupportsCancellation } }
private static async Task UpdateCounter(StreamDeckClient client, StreamDeckEventPayload args) { _counter++; await client.SetTitle(args.Context, _counter.ToString()); }