private void HandleDisconnect()
{
LogManager.Instance.Add("Client has disconnected. Server might have shutdown.", LogLevel.Medium);
ServerDisconnect?.Invoke();
Dispose();
TryConnect();
}
void ReleaseDesignerOutlets()
{
if (ServerConnect != null)
{
ServerConnect.Dispose();
ServerConnect = null;
}
if (ServerDisconnect != null)
{
ServerDisconnect.Dispose();
ServerDisconnect = null;
}
if (ServicesSpotifyForceAuthentication != null)
{
ServicesSpotifyForceAuthentication.Dispose();
ServicesSpotifyForceAuthentication = null;
}
if (ServicesDiscordForceAuthentication != null)
{
ServicesDiscordForceAuthentication.Dispose();
ServicesDiscordForceAuthentication = null;
}
if (ServicesStreamlabsForceAuthentication != null)
{
ServicesStreamlabsForceAuthentication.Dispose();
ServicesStreamlabsForceAuthentication = null;
}
}
/// <summary>
/// 通知断线
/// </summary>
public void NotifyDisconnection()
{
try
{
ServerDisconnect?.Invoke();
}
catch (Exception ex)
{
throw ex;
}
}
public async Task DisconnectAsync()
{
if (!Connected)
{
return;
}
_connector.MessageReceived -= MessageReceivedHandler;
await _connector.DisconnectAsync().ConfigureAwait(false);
ServerDisconnect?.Invoke(this, new EventArgs());
}
public JSONSocketServer(int Port = 9999)
{
IPEndPoint IP = new IPEndPoint(IPAddress.Any, Port);
ListenerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ListenerSocket.Bind(IP);
_OnDisconnect += OnDisconnectDefualt;
ListenerThread = new Thread(new ParameterizedThreadStart(ListenLoop));
ListenerThread.Start(this);
}
/// <summary>
/// Connects to a TCP host
/// </summary>
/// <param name="host">the server to connect to</param>
/// <param name="port">the port to use</param>
/// <param name="separator">what signals the end of a message?</param>
public ClientSocket(string host, int port, string separator, ServerDisconnect discon, ServerMessage mess)
{
IPHostEntry hostip = Dns.GetHostEntry(host);
IPAddress ip = hostip.AddressList.First(addr => addr.AddressFamily == AddressFamily.InterNetwork);
IPEndPoint endpoint = new IPEndPoint(ip, port);
//TODO: Allow different modes like UDP
sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.separator = separator;
this.serverDisconnect = discon;
this.serverMessage = mess;
sock.Connect(endpoint);
t = new Thread(new ThreadStart(WaitForServer));
t.Start();
}
/// <summary>
/// Connects to a TCP host
/// </summary>
/// <param name="host">the server to connect to</param>
/// <param name="port">the port to use</param>
/// <param name="separator">what signals the end of a message?</param>
public ClientSocket(string host, int port, string separator, ServerDisconnect discon, ServerMessage mess)
{
IPHostEntry hostip = Dns.GetHostEntry(host);
IPAddress ip = hostip.AddressList.First(addr => addr.AddressFamily == AddressFamily.InterNetwork);
IPEndPoint endpoint = new IPEndPoint(ip, port);
//TODO: Allow different modes like UDP
sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.separator = separator;
this.serverDisconnect = discon;
this.serverMessage = mess;
sock.Connect(endpoint);
t = new Thread(new ThreadStart(WaitForServer));
t.Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="ButtplugClient"/> class.
/// </summary>
/// <param name="aClientName">The name of the client (used by the server for UI and permissions).</param>
/// <param name="aConnector">Connector for the client.</param>
public ButtplugClient([NotNull] string aClientName, [NotNull] IButtplugClientConnector aConnector)
{
ButtplugUtils.ArgumentNotNull(aConnector, nameof(aConnector));
Name = aClientName;
_connector = aConnector;
_connector.Disconnected += (aObj, aEventArgs) =>
{
ServerDisconnect?.Invoke(aObj, aEventArgs);
};
_connector.InvalidMessageReceived += ConnectorErrorHandler;
_bpLogManager = new ButtplugLogManager();
_connector.LogManager = _bpLogManager;
_bpLogger = _bpLogManager.GetLogger(GetType());
_bpLogger.Info("Finished setting up ButtplugClient");
}
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;
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;
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. :(
}
}
public void OnServerDisconnect(Message message)
{
ServerDisconnect response = (ServerDisconnect)message.GetPb(typeof(ServerDisconnect));
clientCore.onServerDisconnect(response.result, response.playerId);
}
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. :(
}
});
}
private void InvokeServerDisconnectEvent()
{
ServerDisconnect?.Invoke(this, EventArgs.Empty);
}