private void WriteErrorOutput(object sender, EventArgs e) { var eventArgs = e as ScriptHubDataReceivedEventArgs; _errors.Add(eventArgs.Data); _logger.LogToFile(_currentScript.Name, eventArgs.Data); ErrorReceived.Invoke(sender, new ScriptHubDataReceivedEventArgs(eventArgs.Data)); }
private void ErrorMarshal(object o) { if (ErrorReceived == null) { return; } ErrorReceived.Invoke(this, (ZusiTcpException)o); }
public async Task ConnectAsync(Uri uri, CancellationToken cancellationToken) { if (IsConnected) { return; } using (var cts = new CancellationTokenSource(_options.ConnectTimeout)) { _socket = await _client.ConnectAsync(uri, cts.Token).ConfigureAwait(false); Connected.Invoke(this, EventArgs.Empty); } var recvTask = Task.Factory.StartNew(async() => { try { while (_socket.IsConnected && !cancellationToken.IsCancellationRequested) { var readStream = await _socket.ReadMessageAsync(cancellationToken).ConfigureAwait(false); if (readStream == null) { continue; // NOTE does stream need to be consumed? } using (var reader = new StreamReader(readStream, true)) { var message = await reader.ReadToEndAsync().ConfigureAwait(false); MessageReceived.Invoke(this, message); } } } catch (Exception e) { ErrorReceived.Invoke(this, e); } finally { Disconnected.Invoke(this, EventArgs.Empty); } }, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default); await recvTask.ConfigureAwait(false); }
private void ErrorOutput(object sender, DataReceivedEventArgs e) { if (e.Data == " ") { if (!string.IsNullOrEmpty(_currentError)) { if (ErrorReceived != null) { ErrorReceived.Invoke(sender, new ScriptHubDataReceivedEventArgs(_currentError)); } } _currentError = string.Empty; } else { _currentError += e.Data; } }
protected virtual void OnErrorReceived(ProgramOutputReceivedEventArgs e) { ErrorReceived?.Invoke(this, e); }
public void TestErrorReceived(SerialErrorReceivedEventArgs args) { ErrorReceived?.Invoke( this, args); }
public void Connect(Uri aURL, bool aIgnoreSSLErrors = false) { if (_ws != null && (_ws.State == WebSocketState.Connecting || _ws.State == WebSocketState.Open)) { throw new InvalidOperationException("Already connected!"); } _bpLogger.Trace("Opening connection"); _ws = new WebSocket(aURL.ToString()); _waitingMsgs.Clear(); _devices.Clear(); _counter = 1; _connectedOrFailed = new TaskCompletionSource <bool>(); _disconnected = new TaskCompletionSource <bool>(); _ws.Opened += OpenedHandler; _ws.Closed += ClosedHandler; _ws.Error += ErrorHandler; if (aIgnoreSSLErrors) { _ws.Security.AllowNameMismatchCertificate = true; _ws.Security.AllowUnstrustedCertificate = true; _ws.Security.AllowCertificateChainErrors = true; } _ws.Open(); _connecting = true; _connectedOrFailed.Task.Wait(); _connecting = false; if (_ws.State != WebSocketState.Open) { throw new Exception("Connection failed!"); } _bpLogger.Trace("Connected"); _ws.MessageReceived += MessageReceivedHandler; var res = SendMessage(new RequestServerInfo(_clientName)).Result; switch (res) { case ServerInfo si: if (si.MaxPingTime > 0) { _pingTimer = new Timer(OnPingTimer, null, 0, Convert.ToInt32(Math.Round(((double)si.MaxPingTime) / 2, 0))); } if (si.MessageVersion < 1) { throw new Exception("B******g Server's schema version (" + si.MessageVersion + ") is less than the client's (" + 1 + "). A newer server is required."); } // Get full device list and populate internal list var resp = SendMessage(new RequestDeviceList()).Result; if ((resp as DeviceList)?.Devices == null) { if (resp is Error) { _owningDispatcher.Send(_ => { ErrorReceived?.Invoke(this, new ErrorEventArgs(resp as Error)); }, null); } return; } foreach (var d in (resp as DeviceList).Devices) { if (_devices.ContainsKey(d.DeviceIndex)) { continue; } var device = new ButtplugClientDevice(d); if (_devices.TryAdd(d.DeviceIndex, device)) { _owningDispatcher.Send(_ => { DeviceAdded?.Invoke(this, new DeviceEventArgs(device, DeviceEventArgs.DeviceAction.ADDED)); }, null); } } break; case Error e: throw new Exception(e.ErrorMessage); default: throw new Exception("Unexpecte message returned: " + res.GetType()); } }
/// <summary> /// Fires when data is received from the chess engine. /// </summary> /// <param name="sender">Object that raised the event.</param> /// <param name="e">Event arguments received from the chess engine.</param> protected virtual void OnRaiseErrorReceived(object sender, ChessCommandReceivedEventArgs e) { ErrorReceived?.Invoke(sender, e); }
protected virtual void OnErrorReceived(ErrorEventArgs args) { Log.Error(args.Exception, "Socket connection"); ErrorReceived?.Invoke(new BitmextErrorEventArgs(args.Exception)); }
protected void SorterCallbackHandler(IntPtr buf, int buf_length) { // Process the data BEFORE we throw to the C# executor, otherwise // Rust will clean up the memory and we'll have nothing to read // from, meaning a null message at best and a crash at worst. Span <byte> byteArray; unsafe { byteArray = new Span <byte>(buf.ToPointer(), buf_length); } var server_message = ButtplugFFIServerMessage.Parser.ParseFrom(byteArray.ToArray()); // Run the response in the context of the C# executor, not the Rust // thread. This means that if something goes wrong we at least // aren't blocking a rust executor thread. Task.Run(() => { if (server_message.Id > 0) { _messageSorter.CheckMessage(server_message); } else if (server_message.Message.MsgCase == ButtplugFFIServerMessage.Types.FFIMessage.MsgOneofCase.ServerMessage) { if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.DeviceAdded) { var device_added_message = server_message.Message.ServerMessage.DeviceAdded; if (_devices.ContainsKey(device_added_message.Index)) { ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(new ButtplugDeviceException("A duplicate device index was received. This is most likely a bug, please file at https://github.com/buttplugio/b******g-rs-ffi"))); return; } var device_handle = ButtplugFFI.SendCreateDevice(_clientHandle, device_added_message.Index); var attribute_dict = new Dictionary <ServerMessage.Types.MessageAttributeType, ButtplugMessageAttributes>(); for (var i = 0; i < device_added_message.MessageAttributes.Count; ++i) { var attributes = device_added_message.MessageAttributes[i]; var device_message_attributes = new ButtplugMessageAttributes(attributes.FeatureCount, attributes.StepCount.ToArray(), attributes.Endpoints.ToArray(), attributes.MaxDuration.ToArray(), null, null); attribute_dict.Add(attributes.MessageType, device_message_attributes); } var device = new ButtplugClientDevice(_messageSorter, device_handle, device_added_message.Index, device_added_message.Name, attribute_dict, SorterCallbackDelegate, GCHandle.ToIntPtr(_indexHandle)); _devices.Add(device_added_message.Index, device); DeviceAdded?.Invoke(this, new DeviceAddedEventArgs(device)); } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.DeviceRemoved) { var device_removed_message = server_message.Message.ServerMessage.DeviceRemoved; if (!_devices.ContainsKey(device_removed_message.Index)) { // Device was removed from our dict before we could remove it ourselves. return; } try { var device = _devices[device_removed_message.Index]; _devices.Remove(device_removed_message.Index); DeviceRemoved?.Invoke(this, new DeviceRemovedEventArgs(device)); } catch (KeyNotFoundException) { ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(new ButtplugDeviceException($"Cannot remove device index {device_removed_message.Index}, device not found."))); } } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.Disconnect) { Connected = false; _devices.Clear(); ServerDisconnect?.Invoke(this, null); } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.Error) { var errorMsg = server_message.Message.ServerMessage.Error; var error = ButtplugException.FromError(errorMsg); if (error is ButtplugPingException) { PingTimeout?.Invoke(this, null); } ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(error)); } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.ScanningFinished) { IsScanning = false; ScanningFinished?.Invoke(this, null); } else { // We should probably do something here with unhandled events, but I'm not particularly sure what. I miss pattern matching. :( } } else { // We should probably do something here with unhandled events, but I'm not particularly sure what. I miss pattern matching. :( } }); }
protected virtual void OnErrorReceived(ErrorEventArgs args) { ErrorReceived?.Invoke(new BitmextErrorEventArgs(args.Exception)); }
void ErrorResponse(ErrorResponse status) { //fire the event ErrorReceived?.Invoke(this, new DataEventArg <ErrorResponse>(status)); }
public void HandleErrorReceived(object sender, ErrorReceivedEventArgs e) { ErrorReceived?.Invoke(this, e); }
private void Port_ErrorReceived(object sender, SerialErrorReceivedEventArgs e) { ErrorReceived?.Invoke(sender, e); }
private void OnErrorReceived(string errorMessage) { ErrorReceived?.Invoke(errorMessage); }
protected virtual void OnErrorReceived(string data) { ErrorReceived?.Invoke(this, data); }
private void OnMessage(object sender, MessageEventArgs e) { if (!e.IsText) { return; } var container = JsonConvert.DeserializeObject <MessageContainer>(e.Data); switch (container.Identifier) { case nameof(ConnectionResponse): var connectionResponse = ((JObject)container.Payload).ToObject(typeof(ConnectionResponse)) as ConnectionResponse; if (connectionResponse.Result == ResultCode.Failure) { Username = string.Empty; string source = string.Empty; ErrorReceived?.Invoke(this, new ErrorReceivedEventArgs(connectionResponse.Reason, connectionResponse.Date)); } if (!String.IsNullOrEmpty(Username)) { ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(Username, true, DateTime.Now, connectionResponse.ActiveUsers)); } break; case nameof(ConnectionBroadcast): var connectionBroadcast = ((JObject)container.Payload).ToObject(typeof(ConnectionBroadcast)) as ConnectionBroadcast; if (connectionBroadcast.Username != Username) { ConnectionReceived?.Invoke(this, new ConnectionReceivedEventArgs(connectionBroadcast.Username, connectionBroadcast.IsConnected, connectionBroadcast.Date)); } break; case nameof(MessageBroadcast): var messageBroadcast = ((JObject)container.Payload).ToObject(typeof(MessageBroadcast)) as MessageBroadcast; MessageReceived?.Invoke(this, new MessageReceivedEventArgs(messageBroadcast.Source, messageBroadcast.Target, messageBroadcast.Message, messageBroadcast.Groupname, messageBroadcast.Date)); break; case nameof(UserListResponse): var userListResponse = ((JObject)container.Payload).ToObject(typeof(UserListResponse)) as UserListResponse; UsersReceived?.Invoke(this, new UsersReceivedEventArgs(userListResponse.UserList)); break; case nameof(MessageHistoryResponse): var messageHistoryResponse = ((JObject)container.Payload).ToObject(typeof(MessageHistoryResponse)) as MessageHistoryResponse; MessageHistoryReceived?.Invoke(this, new MessageHistoryReceivedEventArgs(messageHistoryResponse.GroupMessages)); break; case nameof(FiltrationResponse): var filterResponse = ((JObject)container.Payload).ToObject(typeof(FiltrationResponse)) as FiltrationResponse; FilteredLogsReceived?.Invoke(this, new FilteredLogsReceivedEventArgs(filterResponse.FilteredLogs)); break; case nameof(GroupListResponse): var groupsListResponse = ((JObject)container.Payload).ToObject(typeof(GroupListResponse)) as GroupListResponse; GroupsReceived?.Invoke(this, new GroupsReceivedEventArgs(groupsListResponse.Groups)); break; case nameof(GroupBroadcast): var groupBroadcast = ((JObject)container.Payload).ToObject(typeof(GroupBroadcast)) as GroupBroadcast; GroupsReceived?.Invoke(this, new GroupsReceivedEventArgs(groupBroadcast.Groupname)); break; } }
public void RaiseErrorReceived(string message) { ErrorReceived?.Invoke(this, message); }
private async void wsReader(CancellationToken aToken) { var sb = new StringBuilder(); while (_ws != null && _ws.State == WebSocketState.Open && !aToken.IsCancellationRequested) { try { var buffer = new byte[5]; var segment = new ArraySegment <byte>(buffer); WebSocketReceiveResult result; try { result = await _ws.ReceiveAsync(segment, aToken); } catch (OperationCanceledException) { // If the operation is cancelled, just continue so we fall out of the loop continue; } var input = Encoding.UTF8.GetString(buffer, 0, result.Count); sb.Append(input); if (result.EndOfMessage) { var msgs = Deserialize(sb.ToString()); foreach (var msg in msgs) { if (msg.Id > 0 && _waitingMsgs.TryRemove(msg.Id, out TaskCompletionSource <ButtplugMessage> queued)) { queued.TrySetResult(msg); continue; } switch (msg) { case Log l: _owningDispatcher.Invoke(() => { Log?.Invoke(this, new LogEventArgs(l)); }); break; case DeviceAdded d: var dev = new ButtplugClientDevice(d); _devices.AddOrUpdate(d.DeviceIndex, dev, (idx, old) => dev); _owningDispatcher.Invoke(() => { DeviceAdded?.Invoke(this, new DeviceEventArgs(dev, DeviceAction.ADDED)); }); break; case DeviceRemoved d: if (_devices.TryRemove(d.DeviceIndex, out ButtplugClientDevice oldDev)) { _owningDispatcher.Invoke(() => { DeviceRemoved?.Invoke(this, new DeviceEventArgs(oldDev, DeviceAction.REMOVED)); }); } break; case ScanningFinished sf: _owningDispatcher.Invoke(() => { ScanningFinished?.Invoke(this, new ScanningFinishedEventArgs(sf)); }); break; case Error e: _owningDispatcher.Invoke(() => { ErrorReceived?.Invoke(this, new ErrorEventArgs(e)); }); break; } } sb.Clear(); } } catch (WebSocketException) { // Noop - WS probably closed on us during read } } }
protected virtual void OnErrorReceived(Exception ex) { ErrorReceived?.Invoke(this, ex); }
private void ConnectorErrorHandler(object aSender, ButtplugExceptionEventArgs aException) { ErrorReceived?.Invoke(this, aException); }
public async Task ConnectAsync(Uri uri, CancellationToken cancellationToken) { if (IsConnected) { return; } using (var cts = new CancellationTokenSource(_options.ConnectTimeout)) { _socket = await _client.ConnectAsync(uri, cts.Token).ConfigureAwait(false); Connected.Invoke(this, EventArgs.Empty); } var recvTask = Task.Factory.StartNew(async() => { try { while (_socket.IsConnected && !cancellationToken.IsCancellationRequested) { var readStream = await _socket.ReadMessageAsync(cancellationToken).ConfigureAwait(false); if (readStream == null) { continue; // NOTE does stream need to be consumed? } using (var reader = new StreamReader(readStream, true)) { var message = await reader.ReadToEndAsync().ConfigureAwait(false); MessageReceived.Invoke(this, message); } } } catch (Exception e) { ErrorReceived.Invoke(this, e); } finally { Disconnected.Invoke(this, EventArgs.Empty); _sendQueue.CompleteAdding(); } }, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default); var cts2 = new CancellationTokenSource(); var sendTask = Task.Factory.StartNew(async() => { try { foreach (var item in _sendQueue.GetConsumingEnumerable(cts2.Token)) { using (var output = _socket.CreateMessageWriter(WebSocketMessageType.Text)) using (var writer = new StreamWriter(output)) { writer.Write(item); } } } catch (Exception e) { ErrorReceived?.Invoke(this, e); } finally { // Setup a new send queue. _sendQueue = new BlockingCollection <string>(256); } }, cts2.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default); #pragma warning disable 4014 Task.WhenAll(recvTask, sendTask); #pragma warning restore 4014 }
protected virtual void OnErrorReceived(ErrorEventArgs e) => ErrorReceived?.Invoke(this, e);
private void OnErrorReceived(TLSerialErrorReceivedEventArgs e) { ErrorReceived?.Invoke(this, e); }
/// <summary> /// Triggers the <see cref="ErrorReceived"/> event. /// </summary> /// <param name="e">Passes <see cref="DiscoveryProtocolErrorArgs"/> to the event.</param> protected virtual void OnErrorReceived(DiscoveryProtocolErrorArgs e) { ErrorReceived?.Invoke(this, e); }
private void OnMessage(object sender, MessageEventArgs e) { if (!e.IsText) { return; } var container = JsonConvert.DeserializeObject <MessageContainer>(e.Data); switch (container.Identifier) { case nameof(ConnectionResponse): var connectionResponse = ((JObject)container.Payload).ToObject(typeof(ConnectionResponse)) as ConnectionResponse; if (connectionResponse.Result == ResultCodes.Failure) { Login = string.Empty; string source = string.Empty; ErrorReceived?.Invoke(this, new ErrorReceivedEventArgs(connectionResponse.Reason, connectionResponse.Date)); } if (!String.IsNullOrEmpty(Login)) { ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(Login, DateTime.Now, true, connectionResponse.OnlineClients)); } break; case nameof(ConnectionBroadcast): var connectionBroadcast = ((JObject)container.Payload).ToObject(typeof(ConnectionBroadcast)) as ConnectionBroadcast; if (connectionBroadcast.Login != Login) { ConnectionReceived?.Invoke(this, new ConnectionReceivedEventArgs(connectionBroadcast.Login, connectionBroadcast.IsConnected, connectionBroadcast.Date)); } break; case nameof(MessageBroadcast): var messageBroadcast = ((JObject)container.Payload).ToObject(typeof(MessageBroadcast)) as MessageBroadcast; MessageReceived?.Invoke(this, new MessageReceivedEventArgs(messageBroadcast.Source, messageBroadcast.Target, messageBroadcast.Message, messageBroadcast.Date, messageBroadcast.GroupName)); break; case nameof(ClientsListResponse): var clientsListResponse = ((JObject)container.Payload).ToObject(typeof(ClientsListResponse)) as ClientsListResponse; ClientsListReceived?.Invoke(this, new ClientsListReceivedEventArgs(clientsListResponse.Clients)); break; case nameof(ChatHistoryResponse): var chatHistoryResponse = ((JObject)container.Payload).ToObject(typeof(ChatHistoryResponse)) as ChatHistoryResponse; ChatHistoryReceived?.Invoke(this, new ChatHistoryReceivedEventArgs(chatHistoryResponse.ClientMessages)); break; case nameof(FilterResponse): var filterResponse = ((JObject)container.Payload).ToObject(typeof(FilterResponse)) as FilterResponse; FilteredMessagesReceived?.Invoke(this, new FilteredMessagesReceivedEventArgs(filterResponse.FilteredMessages)); break; case nameof(GroupsListResponse): var groupsListResponse = ((JObject)container.Payload).ToObject(typeof(GroupsListResponse)) as GroupsListResponse; GroupsReceived?.Invoke(this, new GroupsReceivedEventArgs(groupsListResponse.Groups)); break; case nameof(GroupBroadcast): var groupBroadcast = ((JObject)container.Payload).ToObject(typeof(GroupBroadcast)) as GroupBroadcast; GroupsReceived?.Invoke(this, new GroupsReceivedEventArgs(groupBroadcast.Group)); break; } }
/// <summary> /// Invokes youtube-dl with the specified parameters and options. /// </summary> /// <param name="urls">The video URLs to be passed to youtube-dl.</param> /// <param name="options">An OptionSet specifying the options to be passed to youtube-dl.</param> /// <param name="ct">A CancellationToken used to cancel the download.</param> /// <param name="progress">A progress provider used to get download progress information.</param> /// <returns>The exit code of the youtube-dl process.</returns> public async Task <int> RunAsync(string[] urls, OptionSet options, CancellationToken ct, IProgress <DownloadProgress> progress = null) { var tcs = new TaskCompletionSource <int>(); var process = new Process(); var startInfo = new ProcessStartInfo() { CreateNoWindow = true, UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true }; if (!String.IsNullOrEmpty(PythonPath)) { startInfo.FileName = PythonPath; startInfo.Arguments = $"\"{ExecutablePath}\" {ConvertToArgs(urls, options)}"; } else { startInfo.FileName = ExecutablePath; startInfo.Arguments = ConvertToArgs(urls, options); } process.EnableRaisingEvents = true; process.StartInfo = startInfo; var tcsOut = new TaskCompletionSource <bool>(); // this variable is used for tracking download states bool isDownloading = false; process.OutputDataReceived += (o, e) => { if (e.Data == null) { tcsOut.SetResult(true); return; } Match match; if ((match = rgxProgress.Match(e.Data)).Success) { if (match.Groups.Count > 1 && match.Groups[1].Length > 0) { float progValue = float.Parse(match.Groups[1].ToString(), CultureInfo.InvariantCulture) / 100.0f; Group totalGroup = match.Groups["total"]; string total = totalGroup.Success ? totalGroup.Value : null; Group speedGroup = match.Groups["speed"]; string speed = speedGroup.Success ? speedGroup.Value : null; Group etaGroup = match.Groups["eta"]; string eta = etaGroup.Success ? etaGroup.Value : null; progress?.Report( new DownloadProgress( DownloadState.Downloading, progress: progValue, totalDownloadSize: total, downloadSpeed: speed, eta: eta ) ); } else { progress?.Report(new DownloadProgress(DownloadState.Downloading)); } isDownloading = true; } else if ((match = rgxPlaylist.Match(e.Data)).Success) { var index = int.Parse(match.Groups[1].Value); progress?.Report(new DownloadProgress(DownloadState.PreProcessing, index: index)); isDownloading = false; } else if (isDownloading && (match = rgxPost.Match(e.Data)).Success) { progress?.Report(new DownloadProgress(DownloadState.PostProcessing, 1)); isDownloading = false; } Debug.WriteLine("[youtube-dl] " + e.Data); OutputReceived?.Invoke(this, e); }; var tcsError = new TaskCompletionSource <bool>(); process.ErrorDataReceived += (o, e) => { if (e.Data == null) { tcsError.SetResult(true); return; } Debug.WriteLine("[youtube-dl ERROR] " + e.Data); progress?.Report(new DownloadProgress(DownloadState.Error, data: e.Data)); ErrorReceived?.Invoke(this, e); }; process.Exited += async(sender, args) => { // Wait for output and error streams to finish await tcsOut.Task; await tcsError.Task; tcs.TrySetResult(process.ExitCode); process.Dispose(); }; ct.Register(() => { if (!tcs.Task.IsCompleted) { tcs.TrySetCanceled(); } try { if (!process.HasExited) { process.KillTree(); } } catch { } }); Debug.WriteLine("[youtube-dl] Arguments: " + process.StartInfo.Arguments); if (!await Task.Run(() => process.Start())) { tcs.TrySetException(new InvalidOperationException("Failed to start youtube-dl process.")); } process.BeginOutputReadLine(); process.BeginErrorReadLine(); progress?.Report(new DownloadProgress(DownloadState.PreProcessing)); return(await tcs.Task); }
private void RaiseError(string text) { ErrorReceived?.Invoke(this, new DriverEventArgs(DriverEventType.Error, text)); }
public void SorterCallback(UIntPtr buf, int buf_length) { Span <byte> byteArray; unsafe { byteArray = new Span <byte>(buf.ToPointer(), buf_length); } var server_message = ButtplugFFIServerMessage.Parser.ParseFrom(byteArray.ToArray()); if (server_message.Id > 0) { _messageSorter.CheckMessage(server_message); } else if (server_message.Message.MsgCase == ButtplugFFIServerMessage.Types.FFIMessage.MsgOneofCase.ServerMessage) { if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.DeviceAdded) { var device_added_message = server_message.Message.ServerMessage.DeviceAdded; if (_devices.ContainsKey(device_added_message.Index)) { ErrorReceived.Invoke(this, new ButtplugExceptionEventArgs(new ButtplugDeviceException("A duplicate device index was received. This is most likely a bug, please file at https://github.com/buttplugio/b******g-rs-ffi"))); return; } var device_handle = ButtplugFFI.SendCreateDevice(_clientHandle, device_added_message.Index); var attribute_dict = new Dictionary <ServerMessage.Types.MessageAttributeType, ButtplugMessageAttributes>(); for (var i = 0; i < device_added_message.MessageAttributes.Count; ++i) { var attributes = device_added_message.MessageAttributes[i]; var device_message_attributes = new ButtplugMessageAttributes(attributes.FeatureCount, attributes.StepCount.ToArray(), attributes.Endpoints.ToArray(), attributes.MaxDuration.ToArray(), null, null); attribute_dict.Add(attributes.MessageType, device_message_attributes); } var device = new ButtplugClientDevice(_messageSorter, device_handle, device_added_message.Index, device_added_message.Name, attribute_dict); _devices.Add(device_added_message.Index, device); DeviceAdded.Invoke(this, new DeviceAddedEventArgs(device)); } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.DeviceRemoved) { var device_removed_message = server_message.Message.ServerMessage.DeviceRemoved; var device = _devices[device_removed_message.Index]; _devices.Remove(device_removed_message.Index); DeviceRemoved.Invoke(this, new DeviceRemovedEventArgs(device)); } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.Disconnect) { Connected = false; _devices.Clear(); ServerDisconnect?.Invoke(this, null); } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.Error) { var errorMsg = server_message.Message.ServerMessage.Error; var error = ButtplugException.FromError(errorMsg); if (error is ButtplugPingException) { PingTimeout?.Invoke(this, null); } ErrorReceived?.Invoke(this, new ButtplugExceptionEventArgs(error)); } else if (server_message.Message.ServerMessage.MsgCase == ServerMessage.MsgOneofCase.ScanningFinished) { ScanningFinished?.Invoke(this, null); } else { // We should probably do something here with unhandled events, but I'm not particularly sure what. I miss pattern matching. :( } } else { // We should probably do something here with unhandled events, but I'm not particularly sure what. I miss pattern matching. :( } }
private void ProcessService_ErrorDataReceived(object sender, DataReceivedEventArgs e) { ConsoleAddText("ERROR! " + e.Data); ErrorReceived?.Invoke(this, new DriverEventArgs(DriverEventType.Error, e.Data)); }