mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-02-01 10:51:08 -05:00
Code Issues Packages Projects Releases Wiki Activity

Rework list handling in ResourceManager by having NetworkClient own its own list rather than sharing ResourceManager's list

Browse Source
This commit is contained in:
Adam Honse
2026-01-14 19:55:24 -06:00
parent d10614289c
commit 11c689130a
7 changed files with 85 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
DetectionManager.cpp
View File

@@ -1392,8 +1392,6 @@ void DetectionManager::ProcessCleanup()
{
WaitForDetection();
SignalUpdate(DETECTIONMANAGER_UPDATE_REASON_RGBCONTROLLER_LIST_CLEARED);
/*-----------------------------------------------------*\
| Make a copy of the list so that the controllers can |
| be deleted after the list is cleared |
@@ -1405,6 +1403,11 @@ void DetectionManager::ProcessCleanup()
\*-----------------------------------------------------*/
rgb_controllers.clear();
/*-----------------------------------------------------*\
| Signal the list cleared callback |
\*-----------------------------------------------------*/
SignalUpdate(DETECTIONMANAGER_UPDATE_REASON_RGBCONTROLLER_LIST_CLEARED);
/*-----------------------------------------------------*\
| Delete the controllers |
\*-----------------------------------------------------*/

110
NetworkClient.cpp
View File

@@ -36,7 +36,7 @@ const char yes = 1;
using namespace std::chrono_literals;
NetworkClient::NetworkClient(std::vector<RGBController *>& control) : controllers(control)
NetworkClient::NetworkClient()
{
port_ip = "127.0.0.1";
port_num = OPENRGB_SDK_PORT;
@@ -470,6 +470,11 @@ void NetworkClient::SettingsManager_SetSettings(std::string settings_json_str)
/*---------------------------------------------------------*\
| RGBController functions |
\*---------------------------------------------------------*/
std::vector<RGBController*>& NetworkClient::GetRGBControllers()
{
return(server_controllers);
}
void NetworkClient::SendRequest_RGBController_ClearSegments(unsigned int dev_idx, int zone)
{
if(change_in_progress)
@@ -839,26 +844,6 @@ void NetworkClient::ConnectionThreadFunction()
}
else
{
ControllerListMutex.lock();
/*-----------------------------------------*\
| All controllers received, add them to |
| master list |
\*-----------------------------------------*/
printf("Client: All controllers received, adding them to master list\r\n");
for(std::size_t controller_idx = 0; controller_idx < server_controllers.size(); controller_idx++)
{
controllers.push_back(server_controllers[controller_idx]);
}
ControllerListMutex.unlock();
/*-----------------------------------------*\
| Client info has changed, call the |
| callbacks |
\*-----------------------------------------*/
SignalNetworkClientUpdate(NETWORKCLIENT_UPDATE_REASON_DEVICE_LIST_UPDATED);
server_initialized = true;
}
}
@@ -1044,18 +1029,6 @@ listen_done:
ControllerListMutex.lock();
for(size_t server_controller_idx = 0; server_controller_idx < server_controllers.size(); server_controller_idx++)
{
for(size_t controller_idx = 0; controller_idx < controllers.size(); controller_idx++)
{
if(controllers[controller_idx] == server_controllers[server_controller_idx])
{
controllers.erase(controllers.begin() + controller_idx);
break;
}
}
}
std::vector<RGBController *> server_controllers_copy = server_controllers;
server_controllers.clear();
@@ -1067,9 +1040,9 @@ listen_done:
ControllerListMutex.unlock();
/*---------------------------------------------------------*\
| Client info has changed, call the callbacks |
\*---------------------------------------------------------*/
/*-----------------------------------------------------*\
| Client info has changed, call the callbacks |
\*-----------------------------------------------------*/
SignalNetworkClientUpdate(NETWORKCLIENT_UPDATE_REASON_CLIENT_DISCONNECTED);
}
@@ -1092,10 +1065,10 @@ void NetworkClient::ProcessReply_ControllerCount(unsigned int data_size, char *
void NetworkClient::ProcessReply_ControllerData(unsigned int data_size, char * data, unsigned int dev_idx)
{
/*---------------------------------------------------------*\
| Verify the controller description size (first 4 bytes of |
| data) matches the packet size in the header |
\*---------------------------------------------------------*/
/*-----------------------------------------------------*\
| Verify the controller description size (first 4 bytes |
| of data) matches the packet size in the header |
\*-----------------------------------------------------*/
if(data_size == *((unsigned int*)data))
{
data += sizeof(data_size);
@@ -1104,9 +1077,9 @@ void NetworkClient::ProcessReply_ControllerData(unsigned int data_size, char * d
new_controller->SetDeviceDescription((unsigned char *)data, GetProtocolVersion());
/*-----------------------------------------------------*\
| Mark this controller as remote owned |
\*-----------------------------------------------------*/
/*-------------------------------------------------*\
| Mark this controller as remote owned |
\*-------------------------------------------------*/
new_controller->flags &= ~CONTROLLER_FLAG_LOCAL;
new_controller->flags |= CONTROLLER_FLAG_REMOTE;
@@ -1115,6 +1088,11 @@ void NetworkClient::ProcessReply_ControllerData(unsigned int data_size, char * d
if(dev_idx >= server_controllers.size())
{
server_controllers.push_back(new_controller);
/*---------------------------------------------*\
| Signal list updated callback |
\*---------------------------------------------*/
SignalNetworkClientUpdate(NETWORKCLIENT_UPDATE_REASON_DEVICE_LIST_UPDATED);
}
else
{
@@ -1172,27 +1150,21 @@ void NetworkClient::ProcessRequest_DeviceListChanged()
{
change_in_progress = true;
/*---------------------------------------------------------*\
| Delete all controllers from the server's controller list |
\*---------------------------------------------------------*/
/*-----------------------------------------------------*\
| Delete all controllers from the server's controller |
| list |
\*-----------------------------------------------------*/
ControllerListMutex.lock();
for(size_t server_controller_idx = 0; server_controller_idx < server_controllers.size(); server_controller_idx++)
{
for(size_t controller_idx = 0; controller_idx < controllers.size(); controller_idx++)
{
if(controllers[controller_idx] == server_controllers[server_controller_idx])
{
controllers.erase(controllers.begin() + controller_idx);
break;
}
}
}
std::vector<RGBController *> server_controllers_copy = server_controllers;
server_controllers.clear();
/*-----------------------------------------------------*\
| Signal list updated callback |
\*-----------------------------------------------------*/
SignalNetworkClientUpdate(NETWORKCLIENT_UPDATE_REASON_DEVICE_LIST_UPDATED);
for(size_t server_controller_idx = 0; server_controller_idx < server_controllers_copy.size(); server_controller_idx++)
{
delete server_controllers_copy[server_controller_idx];
@@ -1200,16 +1172,16 @@ void NetworkClient::ProcessRequest_DeviceListChanged()
ControllerListMutex.unlock();
/*---------------------------------------------------------*\
| Client info has changed, call the callbacks |
\*---------------------------------------------------------*/
/*-----------------------------------------------------*\
| Client info has changed, call the callbacks |
\*-----------------------------------------------------*/
SignalNetworkClientUpdate(NETWORKCLIENT_UPDATE_REASON_DEVICE_LIST_UPDATED);
/*---------------------------------------------------------*\
| Mark server as uninitialized and reset server |
| initialization state so that it restarts the list |
| requesting process |
\*---------------------------------------------------------*/
/*-----------------------------------------------------*\
| Mark server as uninitialized and reset server |
| initialization state so that it restarts the list |
| requesting process |
\*-----------------------------------------------------*/
controller_data_requested = false;
controller_data_received = false;
requested_controllers = 0;
@@ -1291,9 +1263,9 @@ void NetworkClient::ProcessRequest_ServerString(unsigned int data_size, char * d
{
server_name.assign(data, data_size);
/*---------------------------------------------------------*\
| Client info has changed, call the callbacks |
\*---------------------------------------------------------*/
/*-----------------------------------------------------*\
| Client info has changed, call the callbacks |
\*-----------------------------------------------------*/
SignalNetworkClientUpdate(NETWORKCLIENT_UPDATE_REASON_SERVER_STRING_RECEIVED);
}

8
NetworkClient.h
View File

@@ -46,7 +46,7 @@ enum
class NetworkClient
{
public:
NetworkClient(std::vector<RGBController *>& control);
NetworkClient();
~NetworkClient();
/*-----------------------------------------------------*\
@@ -105,6 +105,8 @@ public:
/*-----------------------------------------------------*\
| RGBController functions |
\*-----------------------------------------------------*/
std::vector<RGBController*>& GetRGBControllers();
void SendRequest_RGBController_ClearSegments(unsigned int dev_idx, int zone);
void SendRequest_RGBController_AddSegment(unsigned int dev_idx, unsigned char * data, unsigned int size);
void SendRequest_RGBController_ResizeZone(unsigned int dev_idx, int zone, int new_size);
@@ -121,8 +123,6 @@ public:
void WaitOnControllerData();
std::vector<RGBController *> server_controllers;
private:
/*-----------------------------------------------------*\
| Client state variables |
@@ -182,7 +182,7 @@ private:
| Controller list |
\*-----------------------------------------------------*/
std::mutex ControllerListMutex;
std::vector<RGBController *>& controllers;
std::vector<RGBController *> server_controllers;
/*-----------------------------------------------------*\
| Detection variables |

94
ResourceManager.cpp
View File

@@ -49,11 +49,8 @@ static void ResourceManagerDetectionCallback(void * this_ptr, unsigned int updat
case DETECTIONMANAGER_UPDATE_REASON_RGBCONTROLLER_REGISTERED:
case DETECTIONMANAGER_UPDATE_REASON_RGBCONTROLLER_UNREGISTERED:
this_obj->UpdateDeviceList();
break;
case DETECTIONMANAGER_UPDATE_REASON_RGBCONTROLLER_LIST_CLEARED:
this_obj->ClearLocalDevices();
this_obj->UpdateDeviceList();
break;
case DETECTIONMANAGER_UPDATE_REASON_DETECTION_PROGRESS_CHANGED:
@@ -449,78 +446,41 @@ void ResourceManager::StopDeviceDetection()
//TODO: Call DetectionManager::AbortDetection() or send SDK command if local client
}
void ResourceManager::ClearLocalDevices()
{
DeviceListChangeMutex.lock();
/*-----------------------------------------------------*\
| Remove hardware controllers from controller list |
\*-----------------------------------------------------*/
std::vector<RGBController*>& rgb_controllers_hw = DetectionManager::get()->GetRGBControllers();
for(std::size_t hw_controller_idx = 0; hw_controller_idx < rgb_controllers_hw.size(); hw_controller_idx++)
{
for(std::size_t controller_idx = 0; controller_idx < rgb_controllers.size(); controller_idx++)
{
if(rgb_controllers[controller_idx] == rgb_controllers_hw[hw_controller_idx])
{
rgb_controllers.erase(rgb_controllers.begin() + controller_idx);
break;
}
}
}
DeviceListChangeMutex.unlock();
/*-----------------------------------------------------*\
| Signal device list update |
\*-----------------------------------------------------*/
SignalResourceManagerUpdate(RESOURCEMANAGER_UPDATE_REASON_DEVICE_LIST_UPDATED);
}
void ResourceManager::UpdateDeviceList()
{
DeviceListChangeMutex.lock();
/*-----------------------------------------------------*\
| Clear the controller list |
\*-----------------------------------------------------*/
rgb_controllers.clear();
/*-----------------------------------------------------*\
| Insert hardware controllers into controller list |
\*-----------------------------------------------------*/
std::vector<RGBController*>& rgb_controllers_hw = DetectionManager::get()->GetRGBControllers();
std::vector<RGBController*> rgb_controllers_hw = DetectionManager::get()->GetRGBControllers();
for(std::size_t hw_controller_idx = 0; hw_controller_idx < rgb_controllers_hw.size(); hw_controller_idx++)
for(std::size_t rgb_controller_idx = 0; rgb_controller_idx < rgb_controllers_hw.size(); rgb_controller_idx++)
{
/*-------------------------------------------------*\
| Check if the controller is already in the list |
| at the correct index |
\*-------------------------------------------------*/
if(hw_controller_idx < rgb_controllers.size())
{
if(rgb_controllers[hw_controller_idx] == rgb_controllers_hw[hw_controller_idx])
{
continue;
}
}
/*-------------------------------------------------*\
| If not, check if the controller is already in the |
| list at a different index |
\*-------------------------------------------------*/
for(std::size_t controller_idx = 0; controller_idx < rgb_controllers.size(); controller_idx++)
{
if(rgb_controllers[controller_idx] == rgb_controllers_hw[hw_controller_idx])
{
rgb_controllers.erase(rgb_controllers.begin() + controller_idx);
rgb_controllers.insert(rgb_controllers.begin() + hw_controller_idx, rgb_controllers_hw[hw_controller_idx]);
break;
}
}
/*-------------------------------------------------*\
| If it still hasn't been found, add it to the list |
\*-------------------------------------------------*/
rgb_controllers.insert(rgb_controllers.begin() + hw_controller_idx, rgb_controllers_hw[hw_controller_idx]);
rgb_controllers.push_back(rgb_controllers_hw[rgb_controller_idx]);
}
/*-----------------------------------------------------*\
| Insert client controllers into controller list |
\*-----------------------------------------------------*/
for(std::size_t client_idx = 0; client_idx < clients.size(); client_idx++)
{
std::vector<RGBController*> rgb_controllers_client = clients[client_idx]->GetRGBControllers();
for(std::size_t rgb_controller_idx = 0; rgb_controller_idx < rgb_controllers_client.size(); rgb_controller_idx++)
{
rgb_controllers.push_back(rgb_controllers_client[rgb_controller_idx]);
}
}
/*-----------------------------------------------------*\
| Signal list has changed |
\*-----------------------------------------------------*/
DeviceListChangeMutex.unlock();
/*-----------------------------------------------------*\
@@ -606,7 +566,7 @@ bool ResourceManager::AttemptLocalConnection()
bool success = false;
auto_connection_client = new NetworkClient(ResourceManager::get()->GetRGBControllers());
auto_connection_client = new NetworkClient();
std::string titleString = "OpenRGB ";
titleString.append(VERSION_STRING);
@@ -703,7 +663,7 @@ void ResourceManager::Initialize(bool tryConnect, bool detectDevices, bool start
{
for(unsigned int client_idx = 0; client_idx < client_settings["clients"].size(); client_idx++)
{
NetworkClient * client = new NetworkClient(rgb_controllers);
NetworkClient * client = new NetworkClient();
std::string titleString = "OpenRGB ";
titleString.append(VERSION_STRING);

1
ResourceManager.h
View File

@@ -88,7 +88,6 @@ public:
std::string GetDetectionString();
void StopDeviceDetection();
void RescanDevices();
void ClearLocalDevices();
void UpdateDeviceList();
void WaitForDetection();

2
cli.cpp
View File

@@ -1355,7 +1355,7 @@ unsigned int cli_pre_detection(int argc, char* argv[])
\*---------------------------------------------------------*/
else if(option == "--client")
{
NetworkClient * client = new NetworkClient(ResourceManager::get()->GetRGBControllers());
NetworkClient * client = new NetworkClient();
std::size_t pos = argument.find(":");
std::string ip = argument.substr(0, pos);

14
qt/OpenRGBClientInfoPage/OpenRGBClientInfoPage.cpp
View File

@@ -214,19 +214,19 @@ void OpenRGBClientInfoPage::UpdateInfo()
/*-----------------------------------------------------*\
| Add child items for each device in the client |
\*-----------------------------------------------------*/
for(std::size_t dev_idx = 0; dev_idx < ResourceManager::get()->GetClients()[client_idx]->server_controllers.size(); dev_idx++)
for(std::size_t dev_idx = 0; dev_idx < ResourceManager::get()->GetClients()[client_idx]->GetRGBControllers().size(); dev_idx++)
{
/*-----------------------------------------------------*\
| Create child tree widget items and display the device |
| names in them |
\*-----------------------------------------------------*/
QTreeWidgetItem* new_item = new QTreeWidgetItem(new_top_item);
new_item->setText(0, QString::fromStdString(ResourceManager::get()->GetClients()[client_idx]->server_controllers[dev_idx]->GetName()));
new_item->setText(0, QString::fromStdString(ResourceManager::get()->GetClients()[client_idx]->GetRGBControllers()[dev_idx]->GetName()));
/*-----------------------------------------------------*\
| Add child items for each zone in the device |
\*-----------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < ResourceManager::get()->GetClients()[client_idx]->server_controllers[dev_idx]->GetZoneCount(); zone_idx++)
for(std::size_t zone_idx = 0; zone_idx < ResourceManager::get()->GetClients()[client_idx]->GetRGBControllers()[dev_idx]->GetZoneCount(); zone_idx++)
{
/*-----------------------------------------------------*\
| Create child tree widget items and display the zone |
@@ -234,11 +234,11 @@ void OpenRGBClientInfoPage::UpdateInfo()
\*-----------------------------------------------------*/
QTreeWidgetItem* new_child = new QTreeWidgetItem();
std::string zone_str = ResourceManager::get()->GetClients()[client_idx]->server_controllers[dev_idx]->GetZoneName(zone_idx) + ", ";
zone_str.append(std::to_string(ResourceManager::get()->GetClients()[client_idx]->server_controllers[dev_idx]->GetZoneLEDsCount(zone_idx)));
std::string zone_str = ResourceManager::get()->GetClients()[client_idx]->GetRGBControllers()[dev_idx]->GetZoneName(zone_idx) + ", ";
zone_str.append(std::to_string(ResourceManager::get()->GetClients()[client_idx]->GetRGBControllers()[dev_idx]->GetZoneLEDsCount(zone_idx)));
zone_str.append(" LEDs, ");
// TODO : translate
switch(ResourceManager::get()->GetClients()[client_idx]->server_controllers[dev_idx]->GetZoneType(zone_idx))
switch(ResourceManager::get()->GetClients()[client_idx]->GetRGBControllers()[dev_idx]->GetZoneType(zone_idx))
{
case ZONE_TYPE_SINGLE:
zone_str.append("Single");
@@ -272,7 +272,7 @@ void OpenRGBClientInfoPage::on_ClientConnectButton_clicked()
/*-----------------------------------------------------*\
| Create a new client and set name, IP, and port values |
\*-----------------------------------------------------*/
NetworkClient * rgb_client = new NetworkClient(ResourceManager::get()->GetRGBControllers());
NetworkClient * rgb_client = new NetworkClient();
std::string titleString = "OpenRGB ";
titleString.append(VERSION_STRING);