Rename and refactor websocket helpers

2026-08-14 21:31:45 -05:00 · 2024-04-23 23:05:58 +02:00
parent d71c87535f
commit ab922f6735
8 changed files with 170 additions and 136 deletions
--- a/plugins/base/macro-action-websocket.cpp
+++ b/plugins/base/macro-action-websocket.cpp
@@ -151,7 +151,7 @@ MacroActionWebsocketEdit::MacroActionWebsocketEdit(
 	  _apiType(new QComboBox(this)),
 	  _messageType(new QComboBox(this)),
 	  _message(new VariableTextEdit(this)),
-	  _connection(new ConnectionSelection(this)),
+	  _connection(new WSConnectionSelection(this)),
 	  _editLayout(new QHBoxLayout()),
 	  _settingsConflict(new QLabel())
 {
--- a/plugins/base/macro-action-websocket.hpp
+++ b/plugins/base/macro-action-websocket.hpp
@@ -37,7 +37,7 @@ public:
 	API _api = API::SCENE_SWITCHER;
 	MessageType _type = MessageType::REQUEST;
 	StringVariable _message = obs_module_text("AdvSceneSwitcher.enterText");
-	std::weak_ptr<Connection> _connection;
+	std::weak_ptr<WSConnection> _connection;

 private:
 	void SendRequest(const std::string &msg);
@@ -84,7 +84,7 @@ private:
 	QComboBox *_apiType;
 	QComboBox *_messageType;
 	VariableTextEdit *_message;
-	ConnectionSelection *_connection;
+	WSConnectionSelection *_connection;
 	QHBoxLayout *_editLayout;
 	QLabel *_settingsConflict;

--- a/plugins/base/macro-condition-websocket.cpp
+++ b/plugins/base/macro-condition-websocket.cpp
@@ -131,7 +131,7 @@ void MacroConditionWebsocket::SetConnection(const std::string &connectionName)
 	_messageBuffer = connection->RegisterForEvents();
 }

-std::weak_ptr<Connection> MacroConditionWebsocket::GetConnection() const
+std::weak_ptr<WSConnection> MacroConditionWebsocket::GetConnection() const
 {
 	return _connection;
 }
@@ -159,7 +159,7 @@ MacroConditionWebsocketEdit::MacroConditionWebsocketEdit(
 	  _conditions(new QComboBox(this)),
 	  _message(new VariableTextEdit(this)),
 	  _regex(new RegexConfigWidget(parent)),
-	  _connection(new ConnectionSelection(this)),
+	  _connection(new WSConnectionSelection(this)),
 	  _editLayout(new QHBoxLayout())
 {
 	populateConditionSelection(_conditions);
--- a/plugins/base/macro-condition-websocket.hpp
+++ b/plugins/base/macro-condition-websocket.hpp
@@ -30,7 +30,7 @@ public:
 	void SetType(Type);
 	Type GetType() const { return _type; }
 	void SetConnection(const std::string &);
-	std::weak_ptr<Connection> GetConnection() const;
+	std::weak_ptr<WSConnection> GetConnection() const;
 	StringVariable _message = obs_module_text("AdvSceneSwitcher.enterText");
 	RegexConfig _regex;

@@ -38,7 +38,7 @@ private:
 	void SetupTempVars();

 	Type _type = Type::REQUEST;
-	std::weak_ptr<Connection> _connection;
+	std::weak_ptr<WSConnection> _connection;

 	WebsocketMessageBuffer _messageBuffer;
 	std::chrono::high_resolution_clock::time_point _lastCheck{};
@@ -82,7 +82,7 @@ private:
 	QComboBox *_conditions;
 	VariableTextEdit *_message;
 	RegexConfigWidget *_regex;
-	ConnectionSelection *_connection;
+	WSConnectionSelection *_connection;
 	QHBoxLayout *_editLayout;
 	bool _loading = true;
 };
--- a/plugins/base/utils/connection-manager.cpp
+++ b/plugins/base/utils/connection-manager.cpp
@@ -9,7 +9,7 @@
 #include <QAction>
 #include <QMenu>

-Q_DECLARE_METATYPE(advss::Connection *);
+Q_DECLARE_METATYPE(advss::WSConnection *);

 namespace advss {

@@ -55,7 +55,7 @@ static void loadConnections(obs_data_t *obj)

 	for (size_t i = 0; i < count; i++) {
 		obs_data_t *array_obj = obs_data_array_item(connectionArray, i);
-		auto con = Connection::Create();
+		auto con = WSConnection::Create();
 		connections.emplace_back(con);
 		connections.back()->Load(array_obj);
 		obs_data_release(array_obj);
@@ -63,10 +63,11 @@ static void loadConnections(obs_data_t *obj)
 	obs_data_array_release(connectionArray);
 }

-Connection::Connection(bool useCustomURI, std::string customURI,
-		       std::string name, std::string address, uint64_t port,
-		       std::string pass, bool connectOnStart, bool reconnect,
-		       int reconnectDelay, bool useOBSWebsocketProtocol)
+WSConnection::WSConnection(bool useCustomURI, std::string customURI,
+			   std::string name, std::string address, uint64_t port,
+			   std::string pass, bool connectOnStart,
+			   bool reconnect, int reconnectDelay,
+			   bool useOBSWebsocketProtocol)
 	: Item(name),
 	  _useCustomURI(useCustomURI),
 	  _customURI(customURI),
@@ -81,7 +82,7 @@ Connection::Connection(bool useCustomURI, std::string customURI,
 {
 }

-Connection::Connection(const Connection &other) : Item(other)
+WSConnection::WSConnection(const WSConnection &other) : Item(other)
 {
 	_useCustomURI = other._useCustomURI;
 	_customURI = other._customURI;
@@ -96,7 +97,7 @@ Connection::Connection(const Connection &other) : Item(other)
 	_client.UseOBSWebsocketProtocol(_useOBSWSProtocol);
 }

-Connection &Connection::operator=(const Connection &other)
+WSConnection &WSConnection::operator=(const WSConnection &other)
 {
 	if (this != &other) {
 		_useCustomURI = other._useCustomURI;
@@ -115,7 +116,7 @@ Connection &Connection::operator=(const Connection &other)
 	return *this;
 }

-Connection::~Connection()
+WSConnection::~WSConnection()
 {
 	_client.Disconnect();
 }
@@ -125,7 +126,7 @@ static std::string constructUri(std::string addr, int port)
 	return "ws://" + addr + ":" + std::to_string(port);
 }

-std::string Connection::GetURI()
+std::string WSConnection::GetURI() const
 {
 	if (_useCustomURI) {
 		return _customURI;
@@ -133,16 +134,16 @@ std::string Connection::GetURI()
 	return constructUri(_address, _port);
 }

-void Connection::Reconnect()
+void WSConnection::Reconnect()
 {
 	_client.Disconnect();
 	_client.Connect(GetURI(), _password, _reconnect, _reconnectDelay);
 }

-void Connection::SendMsg(const std::string &msg)
+void WSConnection::SendMsg(const std::string &msg)
 {
 	const auto status = _client.GetStatus();
-	if (status == WSConnection::Status::DISCONNECTED) {
+	if (status == WSClientConnection::Status::DISCONNECTED) {
 		_client.Connect(GetURI(), _password, _reconnect,
 				_reconnectDelay);
 		blog(LOG_WARNING,
@@ -151,12 +152,12 @@ void Connection::SendMsg(const std::string &msg)
 		return;
 	}

-	if (status == WSConnection::Status::AUTHENTICATED) {
+	if (status == WSClientConnection::Status::AUTHENTICATED) {
 		_client.SendRequest(msg);
 	}
 }

-void Connection::Load(obs_data_t *obj)
+void WSConnection::Load(obs_data_t *obj)
 {
 	Item::Load(obj);

@@ -184,7 +185,7 @@ void Connection::Load(obs_data_t *obj)
 	}
 }

-void Connection::Save(obs_data_t *obj) const
+void WSConnection::Save(obs_data_t *obj) const
 {
 	Item::Save(obj);
 	obs_data_set_bool(obj, "useCustomURI", _useCustomURI);
@@ -199,50 +200,50 @@ void Connection::Save(obs_data_t *obj) const
 	obs_data_set_int(obj, "version", 1);
 }

-WebsocketMessageBuffer Connection::RegisterForEvents()
+WebsocketMessageBuffer WSConnection::RegisterForEvents()
 {
 	return _client.RegisterForEvents();
 }

-void Connection::UseOBSWebsocketProtocol(bool useOBSWSProtocol)
+void WSConnection::UseOBSWebsocketProtocol(bool useOBSWSProtocol)
 {
 	_useOBSWSProtocol = useOBSWSProtocol;
 	_client.UseOBSWebsocketProtocol(useOBSWSProtocol);
 }

-Connection *GetConnectionByName(const QString &name)
+WSConnection *GetConnectionByName(const QString &name)
 {
 	return GetConnectionByName(name.toStdString());
 }

-Connection *GetConnectionByName(const std::string &name)
+WSConnection *GetConnectionByName(const std::string &name)
 {
 	for (auto &con : connections) {
 		if (con->Name() == name) {
-			return dynamic_cast<Connection *>(con.get());
+			return dynamic_cast<WSConnection *>(con.get());
 		}
 	}
 	return nullptr;
 }

-std::weak_ptr<Connection> GetWeakConnectionByName(const std::string &name)
+std::weak_ptr<WSConnection> GetWeakConnectionByName(const std::string &name)
 {
 	for (const auto &c : connections) {
 		if (c->Name() == name) {
-			std::weak_ptr<Connection> wp =
-				std::dynamic_pointer_cast<Connection>(c);
+			std::weak_ptr<WSConnection> wp =
+				std::dynamic_pointer_cast<WSConnection>(c);
 			return wp;
 		}
 	}
-	return std::weak_ptr<Connection>();
+	return std::weak_ptr<WSConnection>();
 }

-std::weak_ptr<Connection> GetWeakConnectionByQString(const QString &name)
+std::weak_ptr<WSConnection> GetWeakConnectionByQString(const QString &name)
 {
 	return GetWeakConnectionByName(name.toStdString());
 }

-std::string GetWeakConnectionName(std::weak_ptr<Connection> connection)
+std::string GetWeakConnectionName(std::weak_ptr<WSConnection> connection)
 {
 	auto con = connection.lock();
 	if (!con) {
@@ -268,40 +269,45 @@ static bool ConnectionNameAvailable(const std::string &name)

 static bool AskForSettingsWrapper(QWidget *parent, Item &settings)
 {
-	Connection &ConnectionSettings = dynamic_cast<Connection &>(settings);
-	return ConnectionSettingsDialog::AskForSettings(parent,
-							ConnectionSettings);
+	WSConnection &ConnectionSettings =
+		dynamic_cast<WSConnection &>(settings);
+	return WSConnectionSettingsDialog::AskForSettings(parent,
+							  ConnectionSettings);
 }

-ConnectionSelection::ConnectionSelection(QWidget *parent)
-	: ItemSelection(connections, Connection::Create, AskForSettingsWrapper,
+WSConnectionSelection::WSConnectionSelection(QWidget *parent)
+	: ItemSelection(connections, WSConnection::Create,
+			AskForSettingsWrapper,
 			"AdvSceneSwitcher.connection.select",
 			"AdvSceneSwitcher.connection.add",
 			"AdvSceneSwitcher.item.nameNotAvailable",
 			"AdvSceneSwitcher.connection.configure", parent)
 {
 	// Connect to slots
-	QWidget::connect(
-		window(),
-		SIGNAL(ConnectionRenamed(const QString &, const QString &)),
-		this, SLOT(RenameItem(const QString &, const QString &)));
-	QWidget::connect(window(), SIGNAL(ConnectionAdded(const QString &)),
-			 this, SLOT(AddItem(const QString &)));
-	QWidget::connect(window(), SIGNAL(ConnectionRemoved(const QString &)),
-			 this, SLOT(RemoveItem(const QString &)));
+	QWidget::connect(ConnectionSelectionSignalManager::Instance(),
+			 SIGNAL(Rename(const QString &, const QString &)), this,
+			 SLOT(RenameItem(const QString &, const QString &)));
+	QWidget::connect(ConnectionSelectionSignalManager::Instance(),
+			 SIGNAL(Add(const QString &)), this,
+			 SLOT(AddItem(const QString &)));
+	QWidget::connect(ConnectionSelectionSignalManager::Instance(),
+			 SIGNAL(Remove(const QString &)), this,
+			 SLOT(RemoveItem(const QString &)));

 	// Forward signals
-	QWidget::connect(
-		this, SIGNAL(ItemRenamed(const QString &, const QString &)),
-		window(),
-		SIGNAL(ConnectionRenamed(const QString &, const QString &)));
-	QWidget::connect(this, SIGNAL(ItemAdded(const QString &)), window(),
-			 SIGNAL(ConnectionAdded(const QString &)));
-	QWidget::connect(this, SIGNAL(ItemRemoved(const QString &)), window(),
-			 SIGNAL(ConnectionRemoved(const QString &)));
+	QWidget::connect(this,
+			 SIGNAL(ItemRenamed(const QString &, const QString &)),
+			 ConnectionSelectionSignalManager::Instance(),
+			 SIGNAL(Rename(const QString &, const QString &)));
+	QWidget::connect(this, SIGNAL(ItemAdded(const QString &)),
+			 ConnectionSelectionSignalManager::Instance(),
+			 SIGNAL(Add(const QString &)));
+	QWidget::connect(this, SIGNAL(ItemRemoved(const QString &)),
+			 ConnectionSelectionSignalManager::Instance(),
+			 SIGNAL(Remove(const QString &)));
 }

-void ConnectionSelection::SetConnection(const std::string &con)
+void WSConnectionSelection::SetConnection(const std::string &con)
 {
 	if (!!GetConnectionByName(con)) {
 		SetItem(con);
@@ -310,8 +316,8 @@ void ConnectionSelection::SetConnection(const std::string &con)
 	}
 }

-void ConnectionSelection::SetConnection(
-	const std::weak_ptr<Connection> &connection_)
+void WSConnectionSelection::SetConnection(
+	const std::weak_ptr<WSConnection> &connection_)
 {
 	auto connection = connection_.lock();
 	if (connection) {
@@ -321,8 +327,8 @@ void ConnectionSelection::SetConnection(
 	}
 }

-ConnectionSettingsDialog::ConnectionSettingsDialog(QWidget *parent,
-						   const Connection &settings)
+WSConnectionSettingsDialog::WSConnectionSettingsDialog(
+	QWidget *parent, const WSConnection &settings)
 	: ItemSettingsDialog(settings, connections,
 			     "AdvSceneSwitcher.connection.select",
 			     "AdvSceneSwitcher.connection.add",
@@ -449,7 +455,7 @@ ConnectionSettingsDialog::ConnectionSettingsDialog(QWidget *parent,
 	UseCustomURIChanged(settings._useCustomURI);
 }

-void ConnectionSettingsDialog::UseCustomURIChanged(int state)
+void WSConnectionSettingsDialog::UseCustomURIChanged(int state)
 {
 	SetGridLayoutRowVisible(_layout, _addressRow, !state);
 	SetGridLayoutRowVisible(_layout, _portRow, !state);
@@ -459,33 +465,33 @@ void ConnectionSettingsDialog::UseCustomURIChanged(int state)
 	updateGeometry();
 }

-void ConnectionSettingsDialog::ProtocolChanged(int state)
+void WSConnectionSettingsDialog::ProtocolChanged(int state)
 {
 	_password->setEnabled(state);
 	_showPassword->setEnabled(state);
 }

-void ConnectionSettingsDialog::ReconnectChanged(int state)
+void WSConnectionSettingsDialog::ReconnectChanged(int state)
 {
 	_reconnectDelay->setEnabled(state);
 }

-void ConnectionSettingsDialog::SetStatus()
+void WSConnectionSettingsDialog::SetStatus()
 {
 	switch (_testConnection.GetStatus()) {
-	case WSConnection::Status::DISCONNECTED:
+	case WSClientConnection::Status::DISCONNECTED:
 		_status->setText(obs_module_text(
 			"AdvSceneSwitcher.connection.status.disconnected"));
 		break;
-	case WSConnection::Status::CONNECTING:
+	case WSClientConnection::Status::CONNECTING:
 		_status->setText(obs_module_text(
 			"AdvSceneSwitcher.connection.status.connecting"));
 		break;
-	case WSConnection::Status::CONNECTED:
+	case WSClientConnection::Status::CONNECTED:
 		_status->setText(obs_module_text(
 			"AdvSceneSwitcher.connection.status.connected"));
 		break;
-	case WSConnection::Status::AUTHENTICATED:
+	case WSClientConnection::Status::AUTHENTICATED:
 		_status->setText(obs_module_text(
 			"AdvSceneSwitcher.connection.status.authenticated"));
 		break;
@@ -494,19 +500,19 @@ void ConnectionSettingsDialog::SetStatus()
 	}
 }

-void ConnectionSettingsDialog::ShowPassword()
+void WSConnectionSettingsDialog::ShowPassword()
 {
 	SetButtonIcon(_showPassword, ":res/images/visible.svg");
 	_password->setEchoMode(QLineEdit::Normal);
 }

-void ConnectionSettingsDialog::HidePassword()
+void WSConnectionSettingsDialog::HidePassword()
 {
 	SetButtonIcon(_showPassword, ":res/images/invisible.svg");
 	_password->setEchoMode(QLineEdit::PasswordEchoOnEdit);
 }

-void ConnectionSettingsDialog::TestConnection()
+void WSConnectionSettingsDialog::TestConnection()
 {
 	_testConnection.UseOBSWebsocketProtocol(_useOBSWSProtocol->isChecked());
 	_testConnection.Disconnect();
@@ -517,14 +523,14 @@ void ConnectionSettingsDialog::TestConnection()
 	_testConnection.Connect(uri, _password->text().toStdString(), false);
 	_statusTimer.setInterval(1000);
 	QWidget::connect(&_statusTimer, &QTimer::timeout, this,
-			 &ConnectionSettingsDialog::SetStatus);
+			 &WSConnectionSettingsDialog::SetStatus);
 	_statusTimer.start();
 }

-bool ConnectionSettingsDialog::AskForSettings(QWidget *parent,
-					      Connection &settings)
+bool WSConnectionSettingsDialog::AskForSettings(QWidget *parent,
+						WSConnection &settings)
 {
-	ConnectionSettingsDialog dialog(parent, settings);
+	WSConnectionSettingsDialog dialog(parent, settings);
 	dialog.setWindowTitle(obs_module_text("AdvSceneSwitcher.windowTitle"));
 	if (dialog.exec() != DialogCode::Accepted) {
 		return false;
@@ -544,4 +550,16 @@ bool ConnectionSettingsDialog::AskForSettings(QWidget *parent,
 	return true;
 }

+ConnectionSelectionSignalManager::ConnectionSelectionSignalManager(
+	QObject *parent)
+	: QObject(parent)
+{
+}
+
+ConnectionSelectionSignalManager *ConnectionSelectionSignalManager::Instance()
+{
+	static ConnectionSelectionSignalManager manager;
+	return &manager;
+}
+
 } // namespace advss
--- a/plugins/base/utils/connection-manager.hpp
+++ b/plugins/base/utils/connection-manager.hpp
@@ -18,22 +18,22 @@

 namespace advss {

-class ConnectionSelection;
-class ConnectionSettingsDialog;
+class WSConnectionSelection;
+class WSConnectionSettingsDialog;

-class Connection : public Item {
+class WSConnection : public Item {
 public:
-	Connection(bool useCustomURI, std::string customURI, std::string name,
-		   std::string address, uint64_t port, std::string pass,
-		   bool connectOnStart, bool reconnect, int reconnectDelay,
-		   bool useOBSWebsocketProtocol);
-	Connection() = default;
-	Connection(const Connection &);
-	Connection &operator=(const Connection &);
-	~Connection();
+	WSConnection(bool useCustomURI, std::string customURI, std::string name,
+		     std::string address, uint64_t port, std::string pass,
+		     bool connectOnStart, bool reconnect, int reconnectDelay,
+		     bool useOBSWebsocketProtocol);
+	WSConnection() = default;
+	WSConnection(const WSConnection &);
+	WSConnection &operator=(const WSConnection &);
+	~WSConnection();
 	static std::shared_ptr<Item> Create()
 	{
-		return std::make_shared<Connection>();
+		return std::make_shared<WSConnection>();
 	}

 	void Reconnect();
@@ -43,10 +43,11 @@ public:
 	std::string GetName() const { return _name; }
 	WebsocketMessageBuffer RegisterForEvents();
 	bool IsUsingOBSProtocol() const { return _useOBSWSProtocol; }
+	std::string GetURI() const;
+	uint64_t GetPort() const { return _port; }

 private:
 	void UseOBSWebsocketProtocol(bool);
-	std::string GetURI();

 	bool _useCustomURI = false;
 	std::string _customURI = "ws://localhost:4455";
@@ -58,25 +59,18 @@ private:
 	int _reconnectDelay = 3;
 	bool _useOBSWSProtocol = true;

-	WSConnection _client;
+	WSClientConnection _client;

-	friend ConnectionSelection;
-	friend ConnectionSettingsDialog;
+	friend WSConnectionSelection;
+	friend WSConnectionSettingsDialog;
 };

-Connection *GetConnectionByName(const QString &);
-Connection *GetConnectionByName(const std::string &);
-std::weak_ptr<Connection> GetWeakConnectionByName(const std::string &name);
-std::weak_ptr<Connection> GetWeakConnectionByQString(const QString &name);
-std::string GetWeakConnectionName(std::weak_ptr<Connection>);
-std::deque<std::shared_ptr<Item>> &GetConnections();
-
-class ConnectionSettingsDialog : public ItemSettingsDialog {
+class WSConnectionSettingsDialog : public ItemSettingsDialog {
 	Q_OBJECT

 public:
-	ConnectionSettingsDialog(QWidget *parent, const Connection &);
-	static bool AskForSettings(QWidget *parent, Connection &settings);
+	WSConnectionSettingsDialog(QWidget *parent, const WSConnection &);
+	static bool AskForSettings(QWidget *parent, WSConnection &settings);

 private slots:
 	void UseCustomURIChanged(int);
@@ -103,20 +97,39 @@ private:
 	QGridLayout *_layout;

 	QTimer _statusTimer;
-	WSConnection _testConnection;
+	WSClientConnection _testConnection;

 	int _customURIRow = -1;
 	int _addressRow = -1;
 	int _portRow = -1;
 };

-class ConnectionSelection : public ItemSelection {
+class WSConnectionSelection : public ItemSelection {
 	Q_OBJECT

 public:
-	ConnectionSelection(QWidget *parent = 0);
+	WSConnectionSelection(QWidget *parent = 0);
 	void SetConnection(const std::string &);
-	void SetConnection(const std::weak_ptr<Connection> &);
+	void SetConnection(const std::weak_ptr<WSConnection> &);
 };

+class ConnectionSelectionSignalManager : public QObject {
+	Q_OBJECT
+public:
+	ConnectionSelectionSignalManager(QObject *parent = nullptr);
+	static ConnectionSelectionSignalManager *Instance();
+
+signals:
+	void Rename(const QString &, const QString &);
+	void Add(const QString &);
+	void Remove(const QString &);
+};
+
+WSConnection *GetConnectionByName(const QString &);
+WSConnection *GetConnectionByName(const std::string &);
+std::weak_ptr<WSConnection> GetWeakConnectionByName(const std::string &name);
+std::weak_ptr<WSConnection> GetWeakConnectionByQString(const QString &name);
+std::string GetWeakConnectionName(std::weak_ptr<WSConnection>);
+std::deque<std::shared_ptr<Item>> &GetConnections();
+
 } // namespace advss
--- a/plugins/base/utils/websocket-helpers.cpp
+++ b/plugins/base/utils/websocket-helpers.cpp
@@ -86,7 +86,7 @@ static void registerWebsocketVendor()
 	}
 }

-WSConnection::WSConnection(bool useOBSProtocol) : QObject(nullptr)
+WSClientConnection::WSClientConnection(bool useOBSProtocol) : QObject(nullptr)
 {
 	_client.get_alog().clear_channels(
 		websocketpp::log::alevel::frame_header |
@@ -98,15 +98,15 @@ WSConnection::WSConnection(bool useOBSProtocol) : QObject(nullptr)
 #endif

 	UseOBSWebsocketProtocol(useOBSProtocol);
-	_client.set_close_handler(bind(&WSConnection::OnClose, this, _1));
+	_client.set_close_handler(bind(&WSClientConnection::OnClose, this, _1));
 }

-WSConnection::~WSConnection()
+WSClientConnection::~WSClientConnection()
 {
 	Disconnect();
 }

-void WSConnection::ConnectThread()
+void WSClientConnection::ConnectThread()
 {
 	do {
 		std::unique_lock<std::mutex> lck(_waitMtx);
@@ -144,8 +144,9 @@ void WSConnection::ConnectThread()
 	_status = Status::DISCONNECTED;
 }

-void WSConnection::Connect(const std::string &uri, const std::string &pass,
-			   bool reconnect, int reconnectDelay)
+void WSClientConnection::Connect(const std::string &uri,
+				 const std::string &pass, bool reconnect,
+				 int reconnectDelay)
 {
 	std::lock_guard<std::mutex> lock(_connectMtx);
 	if (_status != Status::DISCONNECTED) {
@@ -161,11 +162,11 @@ void WSConnection::Connect(const std::string &uri, const std::string &pass,
 	if (_thread.joinable()) {
 		_thread.join();
 	}
-	_thread = std::thread(&WSConnection::ConnectThread, this);
+	_thread = std::thread(&WSClientConnection::ConnectThread, this);
 	blog(LOG_INFO, "connect to '%s' started", uri.c_str());
 }

-void WSConnection::Disconnect()
+void WSClientConnection::Disconnect()
 {
 	std::lock_guard<std::mutex> lock(_connectMtx);
 	_disconnect = true;
@@ -218,46 +219,46 @@ std::string ConstructVendorRequestMessage(const std::string &message)
 	return result;
 }

-void WSConnection::SendRequest(const std::string &msg)
+void WSClientConnection::SendRequest(const std::string &msg)
 {
 	Send(msg);
 }

-WebsocketMessageBuffer WSConnection::RegisterForEvents()
+WebsocketMessageBuffer WSClientConnection::RegisterForEvents()
 {
 	return _dispatcher.RegisterClient();
 }

-WSConnection::Status WSConnection::GetStatus() const
+WSClientConnection::Status WSClientConnection::GetStatus() const
 {
 	return _status;
 }

-void WSConnection::UseOBSWebsocketProtocol(bool useOBSProtocol)
+void WSClientConnection::UseOBSWebsocketProtocol(bool useOBSProtocol)
 {
-	_client.set_open_handler(bind(useOBSProtocol
-					      ? &WSConnection::OnOBSOpen
-					      : &WSConnection::OnGenericOpen,
-				      this, _1));
+	_client.set_open_handler(
+		bind(useOBSProtocol ? &WSClientConnection::OnOBSOpen
+				    : &WSClientConnection::OnGenericOpen,
+		     this, _1));
 	_client.set_message_handler(
-		bind(useOBSProtocol ? &WSConnection::OnOBSMessage
-				    : &WSConnection::OnGenericMessage,
+		bind(useOBSProtocol ? &WSClientConnection::OnOBSMessage
+				    : &WSClientConnection::OnGenericMessage,
 		     this, _1, _2));
 }

-void WSConnection::OnGenericOpen(connection_hdl)
+void WSClientConnection::OnGenericOpen(connection_hdl)
 {
 	blog(LOG_INFO, "connection to %s opened", _uri.c_str());
 	_status = Status::AUTHENTICATED;
 }

-void WSConnection::OnOBSOpen(connection_hdl)
+void WSClientConnection::OnOBSOpen(connection_hdl)
 {
 	blog(LOG_INFO, "connection to %s opened", _uri.c_str());
 	_status = Status::CONNECTING;
 }

-void WSConnection::HandleHello(obs_data_t *helloMsg)
+void WSClientConnection::HandleHello(obs_data_t *helloMsg)
 {
 	_status = Status::CONNECTED;

@@ -293,7 +294,7 @@ void WSConnection::HandleHello(obs_data_t *helloMsg)
 	Send(response);
 }

-void WSConnection::HandleEvent(obs_data_t *msg)
+void WSClientConnection::HandleEvent(obs_data_t *msg)
 {
 	auto d = obs_data_get_obj(msg, "d");
 	auto eventData = obs_data_get_obj(d, "eventData");
@@ -319,7 +320,7 @@ void WSConnection::HandleEvent(obs_data_t *msg)
 	obs_data_release(d);
 }

-void WSConnection::HandleResponse(obs_data_t *response)
+void WSClientConnection::HandleResponse(obs_data_t *response)
 {
 	auto data = obs_data_get_obj(response, "d");
 	auto id = obs_data_get_string(data, "requestId");
@@ -333,7 +334,8 @@ void WSConnection::HandleResponse(obs_data_t *response)
 	obs_data_release(data);
 }

-void WSConnection::OnGenericMessage(connection_hdl, client::message_ptr message)
+void WSClientConnection::OnGenericMessage(connection_hdl,
+					  client::message_ptr message)
 {
 	if (!message) {
 		return;
@@ -347,7 +349,8 @@ void WSConnection::OnGenericMessage(connection_hdl, client::message_ptr message)
 	vblog(LOG_INFO, "received event msg \"%s\"", payload.c_str());
 }

-void WSConnection::OnOBSMessage(connection_hdl, client::message_ptr message)
+void WSClientConnection::OnOBSMessage(connection_hdl,
+				      client::message_ptr message)
 {
 	if (!message) {
 		return;
@@ -392,7 +395,7 @@ void WSConnection::OnOBSMessage(connection_hdl, client::message_ptr message)
 	obs_data_release(json);
 }

-void WSConnection::Send(const std::string &msg)
+void WSClientConnection::Send(const std::string &msg)
 {
 	if (_connection.expired()) {
 		return;
@@ -408,7 +411,7 @@ void WSConnection::Send(const std::string &msg)
 	vblog(LOG_INFO, "sent message to '%s':\n%s", _uri.c_str(), msg.c_str());
 }

-void WSConnection::OnClose(connection_hdl)
+void WSClientConnection::OnClose(connection_hdl)
 {
 	blog(LOG_INFO, "client-connection to %s closed.", _uri.c_str());
 	_status = Status::DISCONNECTED;
--- a/plugins/base/utils/websocket-helpers.hpp
+++ b/plugins/base/utils/websocket-helpers.hpp
@@ -30,13 +30,13 @@ void SendWebsocketEvent(const std::string &);
 std::string ConstructVendorRequestMessage(const std::string &message);
 [[nodiscard]] WebsocketMessageBuffer RegisterForWebsocketMessages();

-class WSConnection : public QObject {
+class WSClientConnection : public QObject {
 	using server = websocketpp::server<websocketpp::config::asio>;
 	using client = websocketpp::client<websocketpp::config::asio_client>;

 public:
-	explicit WSConnection(bool useOBSProtocol = true);
-	virtual ~WSConnection();
+	explicit WSClientConnection(bool useOBSProtocol = true);
+	virtual ~WSClientConnection();

 	void Connect(const std::string &uri, const std::string &pass,
 		     bool _reconnect, int reconnectDelay = 10);