hayodea/salmanoff
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

livoxProto1: udpCmdDemux now consults per-device handler registry

Browse Source 
Device class objects now have a per-Device unordered_map of handlers
keyed by cmd_set+cmd_id.
This commit is contained in:
Hayodea Hekol
2025-10-22 07:28:00 -04:00
parent 10afec2532
commit 8e1d609ca1
3 changed files with 64 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files
commonLibs/livoxProto1/device.cpp
+35 -28
View File
@@ -1743,11 +1743,11 @@ void Device::cleanupPcloudDataSocket()
pcloudDataActive.store(false);
}
void Device::handleUdpDgram(const uint8_t *data, ssize_t bytesReceived,
const struct sockaddr_in &senderAddr)
void Device::handleUdpDgram(
const uint8_t *data, ssize_t bytesReceived,
const struct sockaddr_in &senderAddr
)
{
(void)senderAddr;
// Check minimum size for any valid protocol message
if (bytesReceived < static_cast<ssize_t>(
sizeof(comms::Header) + sizeof(comms::Command)))
@@ -1760,37 +1760,44 @@ void Device::handleUdpDgram(const uint8_t *data, ssize_t bytesReceived,
uint8_t cmd_set = data[sizeof(comms::Header)];
uint8_t cmd_id = data[sizeof(comms::Header) + 1];
// Route based on command type
if (cmd_set == 0x00 && cmd_id == 0x01)
// Look for a registered handler for this command
auto key = std::make_pair(cmd_set, cmd_id);
auto it = udpCommandHandlers.find(key);
if (it != udpCommandHandlers.end())
{
// Handshake ACK - check if we have enough data for HandshakeResponse
if (bytesReceived >= static_cast<ssize_t>(
sizeof(comms::HandshakeResponse)))
// Found a registered handler, invoke it
try
{
std::cout << __func__ << ": Received handshake ACK from "
<< discoveredDevice.deviceIdentifier << std::endl;
it->second(data, bytesReceived, senderAddr);
}
}
else if (cmd_set == 0x00 && cmd_id == 0x03)
{
// Heartbeat ACK - check if we have enough data for HeartbeatMessage
if (bytesReceived >= static_cast<ssize_t>(
sizeof(comms::HeartbeatMessage)))
catch (const std::exception& e)
{
// Empty intentionally.
}
}
else if (cmd_set == 0x00 && cmd_id == 0x04)
{
// Sampling response - check if we have enough data for SamplingResponse
if (bytesReceived >= static_cast<ssize_t>(
sizeof(comms::SamplingResponse)))
{
std::cout << __func__ << ": Received sampling response from "
<< discoveredDevice.deviceIdentifier << std::endl;
std::cerr << __func__ << ": Exception in command handler for "
<< discoveredDevice.deviceIdentifier
<< " cmd_set=" << (int)cmd_set
<< " cmd_id=" << (int)cmd_id
<< ": " << e.what() << std::endl;
}
}
// Unknown command types are silently ignored
}
void Device::registerUdpCommandHandler(
uint8_t cmd_set, uint8_t cmd_id,
std::function<void(
const uint8_t* data, ssize_t bytesReceived,
const struct sockaddr_in& senderAddr)> handler
)
{
auto key = std::make_pair(cmd_set, cmd_id);
udpCommandHandlers[key] = std::move(handler);
}
void Device::unregisterUdpCommandHandler(uint8_t cmd_set, uint8_t cmd_id)
{
auto key = std::make_pair(cmd_set, cmd_id);
udpCommandHandlers.erase(key);
}
} // namespace livoxProto1