From 2e5244663ebf7e1e1cb1ededd2f89d557cd81f06 Mon Sep 17 00:00:00 2001 From: Heather Anderson Date: Sun, 9 Aug 2020 14:57:00 -0700 Subject: [PATCH] transition listener registration from member string name to member string pointer --- assignment-client/src/Agent.cpp | 7 +- assignment-client/src/AssignmentClient.cpp | 6 +- .../src/AssignmentClientMonitor.cpp | 3 +- assignment-client/src/assets/AssetServer.cpp | 15 +- assignment-client/src/audio/AudioMixer.cpp | 17 +- assignment-client/src/avatars/AvatarMixer.cpp | 40 ++-- .../src/entities/EntityServer.cpp | 3 +- .../src/messages/MessagesMixer.cpp | 9 +- assignment-client/src/octree/OctreeServer.cpp | 6 +- .../src/scripts/EntityScriptServer.cpp | 17 +- domain-server/src/DomainGatekeeper.cpp | 3 +- domain-server/src/DomainServer.cpp | 57 ++++-- .../src/DomainServerSettingsManager.h | 2 + interface/src/commerce/Wallet.cpp | 6 +- .../src/octree/OctreePacketProcessor.cpp | 3 +- .../ScreenshareScriptingInterface.cpp | 3 +- interface/src/ui/DomainConnectionModel.cpp | 3 +- .../ui/overlays/ContextOverlayInterface.cpp | 3 +- libraries/audio-client/src/AudioClient.cpp | 21 +- libraries/avatars/src/AvatarHashMap.cpp | 12 +- libraries/avatars/src/ClientTraitsHandler.cpp | 3 +- .../entities/src/EntityEditPacketSender.cpp | 3 +- .../src/EntityScriptServerLogClient.cpp | 3 +- .../entities/src/EntityScriptingInterface.cpp | 3 +- libraries/networking/src/AssetClient.cpp | 12 +- .../networking/src/EntityScriptClient.cpp | 3 +- libraries/networking/src/MessagesClient.cpp | 3 +- libraries/networking/src/NodeList.cpp | 42 ++-- libraries/networking/src/PacketReceiver.cpp | 180 +++++------------- libraries/networking/src/PacketReceiver.h | 98 +++++++++- libraries/networking/src/ResourceCache.cpp | 5 +- libraries/octree/src/OctreePersistThread.cpp | 3 +- 32 files changed, 343 insertions(+), 251 deletions(-) diff --git a/assignment-client/src/Agent.cpp b/assignment-client/src/Agent.cpp index 59e53bb2cb..a8ce7e30e5 100644 --- a/assignment-client/src/Agent.cpp +++ b/assignment-client/src/Agent.cpp @@ -112,11 +112,12 @@ Agent::Agent(ReceivedMessage& message) : packetReceiver.registerListenerForTypes( { PacketType::MixedAudio, PacketType::SilentAudioFrame }, - this, "handleAudioPacket"); + PacketReceiver::makeUnsourcedListenerReference(this, &Agent::handleAudioPacket)); packetReceiver.registerListenerForTypes( { PacketType::OctreeStats, PacketType::EntityData, PacketType::EntityErase }, - this, "handleOctreePacket"); - packetReceiver.registerListener(PacketType::SelectedAudioFormat, this, "handleSelectedAudioFormat"); + PacketReceiver::makeSourcedListenerReference(this, &Agent::handleOctreePacket)); + packetReceiver.registerListener(PacketType::SelectedAudioFormat, + PacketReceiver::makeUnsourcedListenerReference(this, &Agent::handleSelectedAudioFormat)); // 100Hz timer for audio const int TARGET_INTERVAL_MSEC = 10; // 10ms diff --git a/assignment-client/src/AssignmentClient.cpp b/assignment-client/src/AssignmentClient.cpp index ce724d7368..50eee258ab 100644 --- a/assignment-client/src/AssignmentClient.cpp +++ b/assignment-client/src/AssignmentClient.cpp @@ -118,8 +118,10 @@ AssignmentClient::AssignmentClient(Assignment::Type requestAssignmentType, QStri setUpStatusToMonitor(); } auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListener(PacketType::CreateAssignment, this, "handleCreateAssignmentPacket"); - packetReceiver.registerListener(PacketType::StopNode, this, "handleStopNodePacket"); + packetReceiver.registerListener(PacketType::CreateAssignment, + PacketReceiver::makeUnsourcedListenerReference(this, &AssignmentClient::handleCreateAssignmentPacket)); + packetReceiver.registerListener(PacketType::StopNode, + PacketReceiver::makeUnsourcedListenerReference(this, &AssignmentClient::handleStopNodePacket)); } void AssignmentClient::stopAssignmentClient() { diff --git a/assignment-client/src/AssignmentClientMonitor.cpp b/assignment-client/src/AssignmentClientMonitor.cpp index 4c7f71a7aa..68c0dfc9fd 100644 --- a/assignment-client/src/AssignmentClientMonitor.cpp +++ b/assignment-client/src/AssignmentClientMonitor.cpp @@ -72,7 +72,8 @@ AssignmentClientMonitor::AssignmentClientMonitor(const unsigned int numAssignmen auto nodeList = DependencyManager::set(listenPort); auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListener(PacketType::AssignmentClientStatus, this, "handleChildStatusPacket"); + packetReceiver.registerListener(PacketType::AssignmentClientStatus, + PacketReceiver::makeUnsourcedListenerReference(this, &AssignmentClientMonitor::handleChildStatusPacket)); adjustOSResources(std::max(_numAssignmentClientForks, _maxAssignmentClientForks)); // use QProcess to fork off a process for each of the child assignment clients diff --git a/assignment-client/src/assets/AssetServer.cpp b/assignment-client/src/assets/AssetServer.cpp index b3344e3832..ffb6747fd7 100644 --- a/assignment-client/src/assets/AssetServer.cpp +++ b/assignment-client/src/assets/AssetServer.cpp @@ -308,7 +308,8 @@ AssetServer::AssetServer(ReceivedMessage& message) : // Queue all requests until the Asset Server is fully setup auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListenerForTypes({ PacketType::AssetGet, PacketType::AssetGetInfo, PacketType::AssetUpload, PacketType::AssetMappingOperation }, this, "queueRequests"); + packetReceiver.registerListenerForTypes({ PacketType::AssetGet, PacketType::AssetGetInfo, PacketType::AssetUpload, PacketType::AssetMappingOperation }, + PacketReceiver::makeSourcedListenerReference(this, &AssetServer::queueRequests)); #ifdef Q_OS_WIN updateConsumedCores(); @@ -464,10 +465,14 @@ void AssetServer::completeSetup() { qCDebug(asset_server) << "Overriding temporary queuing packet handler."; // We're fully setup, override the request queueing handler and replay all requests auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListener(PacketType::AssetGet, this, "handleAssetGet"); - packetReceiver.registerListener(PacketType::AssetGetInfo, this, "handleAssetGetInfo"); - packetReceiver.registerListener(PacketType::AssetUpload, this, "handleAssetUpload"); - packetReceiver.registerListener(PacketType::AssetMappingOperation, this, "handleAssetMappingOperation"); + packetReceiver.registerListener(PacketType::AssetGet, + PacketReceiver::makeSourcedListenerReference(this, &AssetServer::handleAssetGet)); + packetReceiver.registerListener(PacketType::AssetGetInfo, + PacketReceiver::makeSourcedListenerReference(this, &AssetServer::handleAssetGetInfo)); + packetReceiver.registerListener(PacketType::AssetUpload, + PacketReceiver::makeSourcedListenerReference(this, &AssetServer::handleAssetUpload)); + packetReceiver.registerListener(PacketType::AssetMappingOperation, + PacketReceiver::makeSourcedListenerReference(this, &AssetServer::handleAssetMappingOperation)); replayRequests(); } diff --git a/assignment-client/src/audio/AudioMixer.cpp b/assignment-client/src/audio/AudioMixer.cpp index 161a6f4285..42a269c544 100644 --- a/assignment-client/src/audio/AudioMixer.cpp +++ b/assignment-client/src/audio/AudioMixer.cpp @@ -101,20 +101,23 @@ AudioMixer::AudioMixer(ReceivedMessage& message) : PacketType::InjectorGainSet, PacketType::AudioSoloRequest, PacketType::StopInjector }, - this, "queueAudioPacket"); + PacketReceiver::makeSourcedListenerReference(this, &AudioMixer::queueAudioPacket) + ); // packets whose consequences are global should be processed on the main thread - packetReceiver.registerListener(PacketType::MuteEnvironment, this, "handleMuteEnvironmentPacket"); - packetReceiver.registerListener(PacketType::NodeMuteRequest, this, "handleNodeMuteRequestPacket"); - packetReceiver.registerListener(PacketType::KillAvatar, this, "handleKillAvatarPacket"); + packetReceiver.registerListener(PacketType::MuteEnvironment, + PacketReceiver::makeSourcedListenerReference(this, &AudioMixer::handleMuteEnvironmentPacket)); + packetReceiver.registerListener(PacketType::NodeMuteRequest, + PacketReceiver::makeSourcedListenerReference(this, &AudioMixer::handleNodeMuteRequestPacket)); + packetReceiver.registerListener(PacketType::KillAvatar, + PacketReceiver::makeSourcedListenerReference(this, &AudioMixer::handleKillAvatarPacket)); packetReceiver.registerListenerForTypes({ PacketType::ReplicatedMicrophoneAudioNoEcho, PacketType::ReplicatedMicrophoneAudioWithEcho, PacketType::ReplicatedInjectAudio, - PacketType::ReplicatedSilentAudioFrame - }, - this, "queueReplicatedAudioPacket" + PacketType::ReplicatedSilentAudioFrame }, + PacketReceiver::makeUnsourcedListenerReference(this, &AudioMixer::queueReplicatedAudioPacket) ); connect(nodeList.data(), &NodeList::nodeKilled, this, &AudioMixer::handleNodeKilled); diff --git a/assignment-client/src/avatars/AvatarMixer.cpp b/assignment-client/src/avatars/AvatarMixer.cpp index 807f54953e..27b7d0d302 100644 --- a/assignment-client/src/avatars/AvatarMixer.cpp +++ b/assignment-client/src/avatars/AvatarMixer.cpp @@ -71,26 +71,38 @@ AvatarMixer::AvatarMixer(ReceivedMessage& message) : connect(DependencyManager::get().data(), &NodeList::nodeKilled, this, &AvatarMixer::handleAvatarKilled); auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListener(PacketType::AvatarData, this, "queueIncomingPacket"); - packetReceiver.registerListener(PacketType::AdjustAvatarSorting, this, "handleAdjustAvatarSorting"); - packetReceiver.registerListener(PacketType::AvatarQuery, this, "handleAvatarQueryPacket"); - packetReceiver.registerListener(PacketType::AvatarIdentity, this, "handleAvatarIdentityPacket"); - packetReceiver.registerListener(PacketType::KillAvatar, this, "handleKillAvatarPacket"); - packetReceiver.registerListener(PacketType::NodeIgnoreRequest, this, "handleNodeIgnoreRequestPacket"); - packetReceiver.registerListener(PacketType::RadiusIgnoreRequest, this, "handleRadiusIgnoreRequestPacket"); - packetReceiver.registerListener(PacketType::RequestsDomainListData, this, "handleRequestsDomainListDataPacket"); - packetReceiver.registerListener(PacketType::SetAvatarTraits, this, "queueIncomingPacket"); - packetReceiver.registerListener(PacketType::BulkAvatarTraitsAck, this, "queueIncomingPacket"); + packetReceiver.registerListener(PacketType::AvatarData, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::queueIncomingPacket)); + packetReceiver.registerListener(PacketType::AdjustAvatarSorting, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleAdjustAvatarSorting)); + packetReceiver.registerListener(PacketType::AvatarQuery, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleAvatarQueryPacket)); + packetReceiver.registerListener(PacketType::AvatarIdentity, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleAvatarIdentityPacket)); + packetReceiver.registerListener(PacketType::KillAvatar, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleKillAvatarPacket)); + packetReceiver.registerListener(PacketType::NodeIgnoreRequest, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleNodeIgnoreRequestPacket)); + packetReceiver.registerListener(PacketType::RadiusIgnoreRequest, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleRadiusIgnoreRequestPacket)); + packetReceiver.registerListener(PacketType::RequestsDomainListData, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleRequestsDomainListDataPacket)); + packetReceiver.registerListener(PacketType::SetAvatarTraits, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::queueIncomingPacket)); + packetReceiver.registerListener(PacketType::BulkAvatarTraitsAck, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::queueIncomingPacket)); packetReceiver.registerListenerForTypes({ PacketType::OctreeStats, PacketType::EntityData, PacketType::EntityErase }, - this, "handleOctreePacket"); - packetReceiver.registerListener(PacketType::ChallengeOwnership, this, "queueIncomingPacket"); + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::handleOctreePacket)); + packetReceiver.registerListener(PacketType::ChallengeOwnership, + PacketReceiver::makeSourcedListenerReference(this, &AvatarMixer::queueIncomingPacket)); packetReceiver.registerListenerForTypes({ PacketType::ReplicatedAvatarIdentity, PacketType::ReplicatedKillAvatar - }, this, "handleReplicatedPacket"); + }, PacketReceiver::makeUnsourcedListenerReference(this, &AvatarMixer::handleReplicatedPacket)); - packetReceiver.registerListener(PacketType::ReplicatedBulkAvatarData, this, "handleReplicatedBulkAvatarPacket"); + packetReceiver.registerListener(PacketType::ReplicatedBulkAvatarData, + PacketReceiver::makeUnsourcedListenerReference(this, &AvatarMixer::handleReplicatedBulkAvatarPacket)); auto nodeList = DependencyManager::get(); connect(nodeList.data(), &NodeList::packetVersionMismatch, this, &AvatarMixer::handlePacketVersionMismatch); diff --git a/assignment-client/src/entities/EntityServer.cpp b/assignment-client/src/entities/EntityServer.cpp index 4c4fcbf2dd..e68f95bda0 100644 --- a/assignment-client/src/entities/EntityServer.cpp +++ b/assignment-client/src/entities/EntityServer.cpp @@ -59,8 +59,7 @@ EntityServer::EntityServer(ReceivedMessage& message) : PacketType::ChallengeOwnership, PacketType::ChallengeOwnershipRequest, PacketType::ChallengeOwnershipReply }, - this, - "handleEntityPacket"); + PacketReceiver::makeSourcedListenerReference(this, &EntityServer::handleEntityPacket)); connect(&_dynamicDomainVerificationTimer, &QTimer::timeout, this, &EntityServer::startDynamicDomainVerification); _dynamicDomainVerificationTimer.setSingleShot(true); diff --git a/assignment-client/src/messages/MessagesMixer.cpp b/assignment-client/src/messages/MessagesMixer.cpp index d2127835f9..bcf4881fcf 100644 --- a/assignment-client/src/messages/MessagesMixer.cpp +++ b/assignment-client/src/messages/MessagesMixer.cpp @@ -25,9 +25,12 @@ MessagesMixer::MessagesMixer(ReceivedMessage& message) : ThreadedAssignment(mess { connect(DependencyManager::get().data(), &NodeList::nodeKilled, this, &MessagesMixer::nodeKilled); auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListener(PacketType::MessagesData, this, "handleMessages"); - packetReceiver.registerListener(PacketType::MessagesSubscribe, this, "handleMessagesSubscribe"); - packetReceiver.registerListener(PacketType::MessagesUnsubscribe, this, "handleMessagesUnsubscribe"); + packetReceiver.registerListener(PacketType::MessagesData, + PacketReceiver::makeSourcedListenerReference(this, &MessagesMixer::handleMessages)); + packetReceiver.registerListener(PacketType::MessagesSubscribe, + PacketReceiver::makeSourcedListenerReference(this, &MessagesMixer::handleMessagesSubscribe)); + packetReceiver.registerListener(PacketType::MessagesUnsubscribe, + PacketReceiver::makeSourcedListenerReference(this, &MessagesMixer::handleMessagesUnsubscribe)); } void MessagesMixer::nodeKilled(SharedNodePointer killedNode) { diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp index 63520262cd..f72ab0ac05 100644 --- a/assignment-client/src/octree/OctreeServer.cpp +++ b/assignment-client/src/octree/OctreeServer.cpp @@ -1122,8 +1122,10 @@ void OctreeServer::run() { void OctreeServer::domainSettingsRequestComplete() { auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListener(PacketType::OctreeDataNack, this, "handleOctreeDataNackPacket"); - packetReceiver.registerListener(getMyQueryMessageType(), this, "handleOctreeQueryPacket"); + packetReceiver.registerListener(PacketType::OctreeDataNack, + PacketReceiver::makeSourcedListenerReference(this, &OctreeServer::handleOctreeDataNackPacket)); + packetReceiver.registerListener(getMyQueryMessageType(), + PacketReceiver::makeSourcedListenerReference(this, &OctreeServer::handleOctreeQueryPacket)); qDebug(octree_server) << "Received domain settings"; diff --git a/assignment-client/src/scripts/EntityScriptServer.cpp b/assignment-client/src/scripts/EntityScriptServer.cpp index 7c3d491470..065ab12abc 100644 --- a/assignment-client/src/scripts/EntityScriptServer.cpp +++ b/assignment-client/src/scripts/EntityScriptServer.cpp @@ -83,13 +83,18 @@ EntityScriptServer::EntityScriptServer(ReceivedMessage& message) : ThreadedAssig auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); packetReceiver.registerListenerForTypes({ PacketType::OctreeStats, PacketType::EntityData, PacketType::EntityErase }, - this, "handleOctreePacket"); - packetReceiver.registerListener(PacketType::SelectedAudioFormat, this, "handleSelectedAudioFormat"); + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptServer::handleOctreePacket)); + packetReceiver.registerListener(PacketType::SelectedAudioFormat, + PacketReceiver::makeUnsourcedListenerReference(this, &EntityScriptServer::handleSelectedAudioFormat)); - packetReceiver.registerListener(PacketType::ReloadEntityServerScript, this, "handleReloadEntityServerScriptPacket"); - packetReceiver.registerListener(PacketType::EntityScriptGetStatus, this, "handleEntityScriptGetStatusPacket"); - packetReceiver.registerListener(PacketType::EntityServerScriptLog, this, "handleEntityServerScriptLogPacket"); - packetReceiver.registerListener(PacketType::EntityScriptCallMethod, this, "handleEntityScriptCallMethodPacket"); + packetReceiver.registerListener(PacketType::ReloadEntityServerScript, + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptServer::handleReloadEntityServerScriptPacket)); + packetReceiver.registerListener(PacketType::EntityScriptGetStatus, + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptServer::handleEntityScriptGetStatusPacket)); + packetReceiver.registerListener(PacketType::EntityServerScriptLog, + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptServer::handleEntityServerScriptLogPacket)); + packetReceiver.registerListener(PacketType::EntityScriptCallMethod, + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptServer::handleEntityScriptCallMethodPacket)); static const int LOG_INTERVAL = MSECS_PER_SECOND / 10; auto timer = new QTimer(this); diff --git a/domain-server/src/DomainGatekeeper.cpp b/domain-server/src/DomainGatekeeper.cpp index ead4002334..ef37b80d1b 100644 --- a/domain-server/src/DomainGatekeeper.cpp +++ b/domain-server/src/DomainGatekeeper.cpp @@ -17,7 +17,8 @@ #include #include -#include +#include +#include #include #include diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp index 41b0e98ec5..455a425330 100644 --- a/domain-server/src/DomainServer.cpp +++ b/domain-server/src/DomainServer.cpp @@ -765,32 +765,51 @@ void DomainServer::setupNodeListAndAssignments() { // register as the packet receiver for the types we want PacketReceiver& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::RequestAssignment, this, "processRequestAssignmentPacket"); - packetReceiver.registerListener(PacketType::DomainListRequest, this, "processListRequestPacket"); - packetReceiver.registerListener(PacketType::DomainServerPathQuery, this, "processPathQueryPacket"); - packetReceiver.registerListener(PacketType::NodeJsonStats, this, "processNodeJSONStatsPacket"); - packetReceiver.registerListener(PacketType::DomainDisconnectRequest, this, "processNodeDisconnectRequestPacket"); - packetReceiver.registerListener(PacketType::AvatarZonePresence, this, "processAvatarZonePresencePacket"); + packetReceiver.registerListener(PacketType::RequestAssignment, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processRequestAssignmentPacket)); + packetReceiver.registerListener(PacketType::DomainListRequest, + PacketReceiver::makeSourcedListenerReference(this, &DomainServer::processListRequestPacket)); + packetReceiver.registerListener(PacketType::DomainServerPathQuery, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processPathQueryPacket)); + packetReceiver.registerListener(PacketType::NodeJsonStats, + PacketReceiver::makeSourcedListenerReference(this, &DomainServer::processNodeJSONStatsPacket)); + packetReceiver.registerListener(PacketType::DomainDisconnectRequest, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processNodeDisconnectRequestPacket)); + packetReceiver.registerListener(PacketType::AvatarZonePresence, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processAvatarZonePresencePacket)); // NodeList won't be available to the settings manager when it is created, so call registerListener here - packetReceiver.registerListener(PacketType::DomainSettingsRequest, &_settingsManager, "processSettingsRequestPacket"); - packetReceiver.registerListener(PacketType::NodeKickRequest, &_settingsManager, "processNodeKickRequestPacket"); - packetReceiver.registerListener(PacketType::UsernameFromIDRequest, &_settingsManager, "processUsernameFromIDRequestPacket"); + packetReceiver.registerListener(PacketType::DomainSettingsRequest, + PacketReceiver::makeUnsourcedListenerReference(&_settingsManager, &DomainServerSettingsManager::processSettingsRequestPacket)); + packetReceiver.registerListener(PacketType::NodeKickRequest, + PacketReceiver::makeSourcedListenerReference(&_settingsManager, &DomainServerSettingsManager::processNodeKickRequestPacket)); + packetReceiver.registerListener(PacketType::UsernameFromIDRequest, + PacketReceiver::makeSourcedListenerReference(&_settingsManager, &DomainServerSettingsManager::processUsernameFromIDRequestPacket)); // register the gatekeeper for the packets it needs to receive - packetReceiver.registerListener(PacketType::DomainConnectRequest, &_gatekeeper, "processConnectRequestPacket"); - packetReceiver.registerListener(PacketType::ICEPing, &_gatekeeper, "processICEPingPacket"); - packetReceiver.registerListener(PacketType::ICEPingReply, &_gatekeeper, "processICEPingReplyPacket"); - packetReceiver.registerListener(PacketType::ICEServerPeerInformation, &_gatekeeper, "processICEPeerInformationPacket"); + packetReceiver.registerListener(PacketType::DomainConnectRequest, + PacketReceiver::makeUnsourcedListenerReference(&_gatekeeper, &DomainGatekeeper::processConnectRequestPacket)); + packetReceiver.registerListener(PacketType::ICEPing, + PacketReceiver::makeUnsourcedListenerReference(&_gatekeeper, &DomainGatekeeper::processICEPingPacket)); + packetReceiver.registerListener(PacketType::ICEPingReply, + PacketReceiver::makeUnsourcedListenerReference(&_gatekeeper, &DomainGatekeeper::processICEPingReplyPacket)); + packetReceiver.registerListener(PacketType::ICEServerPeerInformation, + PacketReceiver::makeUnsourcedListenerReference(&_gatekeeper, &DomainGatekeeper::processICEPeerInformationPacket)); - packetReceiver.registerListener(PacketType::ICEServerHeartbeatDenied, this, "processICEServerHeartbeatDenialPacket"); - packetReceiver.registerListener(PacketType::ICEServerHeartbeatACK, this, "processICEServerHeartbeatACK"); + packetReceiver.registerListener(PacketType::ICEServerHeartbeatDenied, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processICEServerHeartbeatDenialPacket)); + packetReceiver.registerListener(PacketType::ICEServerHeartbeatACK, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processICEServerHeartbeatACK)); - packetReceiver.registerListener(PacketType::OctreeDataFileRequest, this, "processOctreeDataRequestMessage"); - packetReceiver.registerListener(PacketType::OctreeDataPersist, this, "processOctreeDataPersistMessage"); + packetReceiver.registerListener(PacketType::OctreeDataFileRequest, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processOctreeDataRequestMessage)); + packetReceiver.registerListener(PacketType::OctreeDataPersist, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::processOctreeDataPersistMessage)); - packetReceiver.registerListener(PacketType::OctreeFileReplacement, this, "handleOctreeFileReplacementRequest"); - packetReceiver.registerListener(PacketType::DomainContentReplacementFromUrl, this, "handleDomainContentReplacementFromURLRequest"); + packetReceiver.registerListener(PacketType::OctreeFileReplacement, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::handleOctreeFileReplacementRequest)); + packetReceiver.registerListener(PacketType::DomainContentReplacementFromUrl, + PacketReceiver::makeUnsourcedListenerReference(this, &DomainServer::handleDomainContentReplacementFromURLRequest)); // set a custom packetVersionMatch as the verify packet operator for the udt::Socket nodeList->setPacketFilterOperator(&DomainServer::isPacketVerified); diff --git a/domain-server/src/DomainServerSettingsManager.h b/domain-server/src/DomainServerSettingsManager.h index 294e441ba4..d0c7812a99 100644 --- a/domain-server/src/DomainServerSettingsManager.h +++ b/domain-server/src/DomainServerSettingsManager.h @@ -211,6 +211,8 @@ private: /// guard read/write access from multiple threads to settings QReadWriteLock _settingsLock { QReadWriteLock::Recursive }; + + friend class DomainServer; }; #endif // hifi_DomainServerSettingsManager_h diff --git a/interface/src/commerce/Wallet.cpp b/interface/src/commerce/Wallet.cpp index c449874117..95533b0fb9 100644 --- a/interface/src/commerce/Wallet.cpp +++ b/interface/src/commerce/Wallet.cpp @@ -288,8 +288,10 @@ Wallet::Wallet() { auto& packetReceiver = nodeList->getPacketReceiver(); _passphrase = new QString(""); - packetReceiver.registerListener(PacketType::ChallengeOwnership, this, "handleChallengeOwnershipPacket"); - packetReceiver.registerListener(PacketType::ChallengeOwnershipRequest, this, "handleChallengeOwnershipPacket"); + packetReceiver.registerListener(PacketType::ChallengeOwnership, + PacketReceiver::makeSourcedListenerReference(this, &Wallet::handleChallengeOwnershipPacket)); + packetReceiver.registerListener(PacketType::ChallengeOwnershipRequest, + PacketReceiver::makeSourcedListenerReference(this, &Wallet::handleChallengeOwnershipPacket)); connect(ledger.data(), &Ledger::accountResult, this, [](QJsonObject result) { auto wallet = DependencyManager::get(); diff --git a/interface/src/octree/OctreePacketProcessor.cpp b/interface/src/octree/OctreePacketProcessor.cpp index bc3c1afdd5..c2823e364f 100644 --- a/interface/src/octree/OctreePacketProcessor.cpp +++ b/interface/src/octree/OctreePacketProcessor.cpp @@ -25,7 +25,8 @@ OctreePacketProcessor::OctreePacketProcessor(): auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); const PacketReceiver::PacketTypeList octreePackets = { PacketType::OctreeStats, PacketType::EntityData, PacketType::EntityErase, PacketType::EntityQueryInitialResultsComplete }; - packetReceiver.registerDirectListenerForTypes(octreePackets, this, "handleOctreePacket"); + packetReceiver.registerDirectListenerForTypes(octreePackets, + PacketReceiver::makeSourcedListenerReference(this, &OctreePacketProcessor::handleOctreePacket)); } OctreePacketProcessor::~OctreePacketProcessor() { } diff --git a/interface/src/scripting/ScreenshareScriptingInterface.cpp b/interface/src/scripting/ScreenshareScriptingInterface.cpp index 3bf8336fe4..54f3e195ee 100644 --- a/interface/src/scripting/ScreenshareScriptingInterface.cpp +++ b/interface/src/scripting/ScreenshareScriptingInterface.cpp @@ -42,7 +42,8 @@ ScreenshareScriptingInterface::ScreenshareScriptingInterface() { // This packet listener handles the packet containing information about the latest zone ID in which we are allowed to share. auto nodeList = DependencyManager::get(); PacketReceiver& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::AvatarZonePresence, this, "processAvatarZonePresencePacketOnClient"); + packetReceiver.registerListener(PacketType::AvatarZonePresence, + PacketReceiver::makeUnsourcedListenerReference(this, &ScreenshareScriptingInterface::processAvatarZonePresencePacketOnClient)); }; ScreenshareScriptingInterface::~ScreenshareScriptingInterface() { diff --git a/interface/src/ui/DomainConnectionModel.cpp b/interface/src/ui/DomainConnectionModel.cpp index 83aa18420c..596662a664 100644 --- a/interface/src/ui/DomainConnectionModel.cpp +++ b/interface/src/ui/DomainConnectionModel.cpp @@ -9,7 +9,8 @@ // #include "DomainConnectionModel.h" -#include +#include +#include #include #include diff --git a/interface/src/ui/overlays/ContextOverlayInterface.cpp b/interface/src/ui/overlays/ContextOverlayInterface.cpp index 0f1c8978f0..807eed89ba 100644 --- a/interface/src/ui/overlays/ContextOverlayInterface.cpp +++ b/interface/src/ui/overlays/ContextOverlayInterface.cpp @@ -81,7 +81,8 @@ ContextOverlayInterface::ContextOverlayInterface() { auto nodeList = DependencyManager::get(); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::ChallengeOwnershipReply, this, "handleChallengeOwnershipReplyPacket"); + packetReceiver.registerListener(PacketType::ChallengeOwnershipReply, + PacketReceiver::makeSourcedListenerReference(this, &ContextOverlayInterface::handleChallengeOwnershipReplyPacket)); _challengeOwnershipTimeoutTimer.setSingleShot(true); } diff --git a/libraries/audio-client/src/AudioClient.cpp b/libraries/audio-client/src/AudioClient.cpp index 4e8c88560b..5a255ffb82 100644 --- a/libraries/audio-client/src/AudioClient.cpp +++ b/libraries/audio-client/src/AudioClient.cpp @@ -369,13 +369,20 @@ AudioClient::AudioClient() { auto nodeList = DependencyManager::get(); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::AudioStreamStats, &_stats, "processStreamStatsPacket"); - packetReceiver.registerListener(PacketType::AudioEnvironment, this, "handleAudioEnvironmentDataPacket"); - packetReceiver.registerListener(PacketType::SilentAudioFrame, this, "handleAudioDataPacket"); - packetReceiver.registerListener(PacketType::MixedAudio, this, "handleAudioDataPacket"); - packetReceiver.registerListener(PacketType::NoisyMute, this, "handleNoisyMutePacket"); - packetReceiver.registerListener(PacketType::MuteEnvironment, this, "handleMuteEnvironmentPacket"); - packetReceiver.registerListener(PacketType::SelectedAudioFormat, this, "handleSelectedAudioFormat"); + packetReceiver.registerListener(PacketType::AudioStreamStats, + PacketReceiver::makeSourcedListenerReference(&_stats, &AudioIOStats::processStreamStatsPacket)); + packetReceiver.registerListener(PacketType::AudioEnvironment, + PacketReceiver::makeUnsourcedListenerReference(this, &AudioClient::handleAudioEnvironmentDataPacket)); + packetReceiver.registerListener(PacketType::SilentAudioFrame, + PacketReceiver::makeUnsourcedListenerReference(this, &AudioClient::handleAudioDataPacket)); + packetReceiver.registerListener(PacketType::MixedAudio, + PacketReceiver::makeUnsourcedListenerReference(this, &AudioClient::handleAudioDataPacket)); + packetReceiver.registerListener(PacketType::NoisyMute, + PacketReceiver::makeUnsourcedListenerReference(this, &AudioClient::handleNoisyMutePacket)); + packetReceiver.registerListener(PacketType::MuteEnvironment, + PacketReceiver::makeUnsourcedListenerReference(this, &AudioClient::handleMuteEnvironmentPacket)); + packetReceiver.registerListener(PacketType::SelectedAudioFormat, + PacketReceiver::makeUnsourcedListenerReference(this, &AudioClient::handleSelectedAudioFormat)); auto& domainHandler = nodeList->getDomainHandler(); connect(&domainHandler, &DomainHandler::disconnectedFromDomain, this, [this] { diff --git a/libraries/avatars/src/AvatarHashMap.cpp b/libraries/avatars/src/AvatarHashMap.cpp index d0b315b524..7ed93f346d 100644 --- a/libraries/avatars/src/AvatarHashMap.cpp +++ b/libraries/avatars/src/AvatarHashMap.cpp @@ -123,10 +123,14 @@ AvatarHashMap::AvatarHashMap() { auto nodeList = DependencyManager::get(); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::BulkAvatarData, this, "processAvatarDataPacket"); - packetReceiver.registerListener(PacketType::KillAvatar, this, "processKillAvatar"); - packetReceiver.registerListener(PacketType::AvatarIdentity, this, "processAvatarIdentityPacket"); - packetReceiver.registerListener(PacketType::BulkAvatarTraits, this, "processBulkAvatarTraits"); + packetReceiver.registerListener(PacketType::BulkAvatarData, + PacketReceiver::makeSourcedListenerReference(this, &AvatarHashMap::processAvatarDataPacket)); + packetReceiver.registerListener(PacketType::KillAvatar, + PacketReceiver::makeSourcedListenerReference(this, &AvatarHashMap::processKillAvatar)); + packetReceiver.registerListener(PacketType::AvatarIdentity, + PacketReceiver::makeSourcedListenerReference(this, &AvatarHashMap::processAvatarIdentityPacket)); + packetReceiver.registerListener(PacketType::BulkAvatarTraits, + PacketReceiver::makeSourcedListenerReference(this, &AvatarHashMap::processBulkAvatarTraits)); connect(nodeList.data(), &NodeList::uuidChanged, this, &AvatarHashMap::sessionUUIDChanged); diff --git a/libraries/avatars/src/ClientTraitsHandler.cpp b/libraries/avatars/src/ClientTraitsHandler.cpp index e133f178df..c2576bea2e 100644 --- a/libraries/avatars/src/ClientTraitsHandler.cpp +++ b/libraries/avatars/src/ClientTraitsHandler.cpp @@ -28,7 +28,8 @@ ClientTraitsHandler::ClientTraitsHandler(AvatarData* owningAvatar) : } }); - nodeList->getPacketReceiver().registerListener(PacketType::SetAvatarTraits, this, "processTraitOverride"); + nodeList->getPacketReceiver().registerListener(PacketType::SetAvatarTraits, + PacketReceiver::makeSourcedListenerReference(this, &ClientTraitsHandler::processTraitOverride)); } void ClientTraitsHandler::markTraitUpdated(AvatarTraits::TraitType updatedTrait) { diff --git a/libraries/entities/src/EntityEditPacketSender.cpp b/libraries/entities/src/EntityEditPacketSender.cpp index aaaf7d645a..3da019ce06 100644 --- a/libraries/entities/src/EntityEditPacketSender.cpp +++ b/libraries/entities/src/EntityEditPacketSender.cpp @@ -26,7 +26,8 @@ EntityEditPacketSender::EntityEditPacketSender() { auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerDirectListener(PacketType::EntityEditNack, this, "processEntityEditNackPacket"); + packetReceiver.registerDirectListener(PacketType::EntityEditNack, + PacketReceiver::makeSourcedListenerReference(this, &EntityEditPacketSender::processEntityEditNackPacket)); } void EntityEditPacketSender::processEntityEditNackPacket(QSharedPointer message, SharedNodePointer sendingNode) { diff --git a/libraries/entities/src/EntityScriptServerLogClient.cpp b/libraries/entities/src/EntityScriptServerLogClient.cpp index 5853c9585e..5d7d4017cd 100644 --- a/libraries/entities/src/EntityScriptServerLogClient.cpp +++ b/libraries/entities/src/EntityScriptServerLogClient.cpp @@ -14,7 +14,8 @@ EntityScriptServerLogClient::EntityScriptServerLogClient() { auto nodeList = DependencyManager::get(); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::EntityServerScriptLog, this, "handleEntityServerScriptLogPacket"); + packetReceiver.registerListener(PacketType::EntityServerScriptLog, + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptServerLogClient::handleEntityServerScriptLogPacket)); QObject::connect(nodeList.data(), &NodeList::nodeActivated, this, &EntityScriptServerLogClient::nodeActivated); QObject::connect(nodeList.data(), &NodeList::nodeKilled, this, &EntityScriptServerLogClient::nodeKilled); diff --git a/libraries/entities/src/EntityScriptingInterface.cpp b/libraries/entities/src/EntityScriptingInterface.cpp index fd83c99ca5..05947551ba 100644 --- a/libraries/entities/src/EntityScriptingInterface.cpp +++ b/libraries/entities/src/EntityScriptingInterface.cpp @@ -59,7 +59,8 @@ EntityScriptingInterface::EntityScriptingInterface(bool bidOnSimulationOwnership connect(nodeList.data(), &NodeList::canGetAndSetPrivateUserDataChanged, this, &EntityScriptingInterface::canGetAndSetPrivateUserDataChanged); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::EntityScriptCallMethod, this, "handleEntityScriptCallMethodPacket"); + packetReceiver.registerListener(PacketType::EntityScriptCallMethod, + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptingInterface::handleEntityScriptCallMethodPacket)); } void EntityScriptingInterface::queueEntityMessage(PacketType packetType, diff --git a/libraries/networking/src/AssetClient.cpp b/libraries/networking/src/AssetClient.cpp index 44f42caec2..bbd743cf95 100644 --- a/libraries/networking/src/AssetClient.cpp +++ b/libraries/networking/src/AssetClient.cpp @@ -43,10 +43,14 @@ AssetClient::AssetClient() { auto nodeList = DependencyManager::get(); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::AssetMappingOperationReply, this, "handleAssetMappingOperationReply"); - packetReceiver.registerListener(PacketType::AssetGetInfoReply, this, "handleAssetGetInfoReply"); - packetReceiver.registerListener(PacketType::AssetGetReply, this, "handleAssetGetReply", true); - packetReceiver.registerListener(PacketType::AssetUploadReply, this, "handleAssetUploadReply"); + packetReceiver.registerListener(PacketType::AssetMappingOperationReply, + PacketReceiver::makeSourcedListenerReference(this, &AssetClient::handleAssetMappingOperationReply)); + packetReceiver.registerListener(PacketType::AssetGetInfoReply, + PacketReceiver::makeSourcedListenerReference(this, &AssetClient::handleAssetGetInfoReply)); + packetReceiver.registerListener(PacketType::AssetGetReply, + PacketReceiver::makeSourcedListenerReference(this, &AssetClient::handleAssetGetReply), true); + packetReceiver.registerListener(PacketType::AssetUploadReply, + PacketReceiver::makeSourcedListenerReference(this, &AssetClient::handleAssetUploadReply)); connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &AssetClient::handleNodeKilled); connect(nodeList.data(), &LimitedNodeList::clientConnectionToNodeReset, diff --git a/libraries/networking/src/EntityScriptClient.cpp b/libraries/networking/src/EntityScriptClient.cpp index 1eab5bf2d7..fb98e8042b 100644 --- a/libraries/networking/src/EntityScriptClient.cpp +++ b/libraries/networking/src/EntityScriptClient.cpp @@ -34,7 +34,8 @@ EntityScriptClient::EntityScriptClient() { auto nodeList = DependencyManager::get(); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::EntityScriptGetStatusReply, this, "handleGetScriptStatusReply"); + packetReceiver.registerListener(PacketType::EntityScriptGetStatusReply, + PacketReceiver::makeSourcedListenerReference(this, &EntityScriptClient::handleGetScriptStatusReply)); connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &EntityScriptClient::handleNodeKilled); connect(nodeList.data(), &LimitedNodeList::clientConnectionToNodeReset, diff --git a/libraries/networking/src/MessagesClient.cpp b/libraries/networking/src/MessagesClient.cpp index d6f9d041ea..c883935cb4 100644 --- a/libraries/networking/src/MessagesClient.cpp +++ b/libraries/networking/src/MessagesClient.cpp @@ -28,7 +28,8 @@ MessagesClient::MessagesClient() { }); auto nodeList = DependencyManager::get(); auto& packetReceiver = nodeList->getPacketReceiver(); - packetReceiver.registerListener(PacketType::MessagesData, this, "handleMessagesPacket"); + packetReceiver.registerListener(PacketType::MessagesData, + PacketReceiver::makeSourcedListenerReference(this, &MessagesClient::handleMessagesPacket)); connect(nodeList.data(), &LimitedNodeList::nodeActivated, this, &MessagesClient::handleNodeActivated); } diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp index e02a8dd56e..076e94522f 100644 --- a/libraries/networking/src/NodeList.cpp +++ b/libraries/networking/src/NodeList.cpp @@ -139,20 +139,34 @@ NodeList::NodeList(char newOwnerType, int socketListenPort, int dtlsListenPort) startSTUNPublicSocketUpdate(); auto& packetReceiver = getPacketReceiver(); - packetReceiver.registerListener(PacketType::DomainList, this, "processDomainServerList"); - packetReceiver.registerListener(PacketType::Ping, this, "processPingPacket"); - packetReceiver.registerListener(PacketType::PingReply, this, "processPingReplyPacket"); - packetReceiver.registerListener(PacketType::ICEPing, this, "processICEPingPacket"); - packetReceiver.registerListener(PacketType::DomainServerAddedNode, this, "processDomainServerAddedNode"); - packetReceiver.registerListener(PacketType::DomainServerConnectionToken, this, "processDomainServerConnectionTokenPacket"); - packetReceiver.registerListener(PacketType::DomainConnectionDenied, &_domainHandler, "processDomainServerConnectionDeniedPacket"); - packetReceiver.registerListener(PacketType::DomainSettings, &_domainHandler, "processSettingsPacketList"); - packetReceiver.registerListener(PacketType::ICEServerPeerInformation, &_domainHandler, "processICEResponsePacket"); - packetReceiver.registerListener(PacketType::DomainServerRequireDTLS, &_domainHandler, "processDTLSRequirementPacket"); - packetReceiver.registerListener(PacketType::ICEPingReply, &_domainHandler, "processICEPingReplyPacket"); - packetReceiver.registerListener(PacketType::DomainServerPathResponse, this, "processDomainServerPathResponse"); - packetReceiver.registerListener(PacketType::DomainServerRemovedNode, this, "processDomainServerRemovedNode"); - packetReceiver.registerListener(PacketType::UsernameFromIDReply, this, "processUsernameFromIDReply"); + packetReceiver.registerListener(PacketType::DomainList, + PacketReceiver::makeUnsourcedListenerReference(this, &NodeList::processDomainServerList)); + packetReceiver.registerListener(PacketType::Ping, + PacketReceiver::makeSourcedListenerReference(this, &NodeList::processPingPacket)); + packetReceiver.registerListener(PacketType::PingReply, + PacketReceiver::makeSourcedListenerReference(this, &NodeList::processPingReplyPacket)); + packetReceiver.registerListener(PacketType::ICEPing, + PacketReceiver::makeUnsourcedListenerReference(this, &NodeList::processICEPingPacket)); + packetReceiver.registerListener(PacketType::DomainServerAddedNode, + PacketReceiver::makeUnsourcedListenerReference(this, &NodeList::processDomainServerAddedNode)); + packetReceiver.registerListener(PacketType::DomainServerConnectionToken, + PacketReceiver::makeUnsourcedListenerReference(this, &NodeList::processDomainServerConnectionTokenPacket)); + packetReceiver.registerListener(PacketType::DomainConnectionDenied, + PacketReceiver::makeUnsourcedListenerReference(&_domainHandler, &DomainHandler::processDomainServerConnectionDeniedPacket)); + packetReceiver.registerListener(PacketType::DomainSettings, + PacketReceiver::makeUnsourcedListenerReference(&_domainHandler, &DomainHandler::processSettingsPacketList)); + packetReceiver.registerListener(PacketType::ICEServerPeerInformation, + PacketReceiver::makeUnsourcedListenerReference(&_domainHandler, &DomainHandler::processICEResponsePacket)); + packetReceiver.registerListener(PacketType::DomainServerRequireDTLS, + PacketReceiver::makeUnsourcedListenerReference(&_domainHandler, &DomainHandler::processDTLSRequirementPacket)); + packetReceiver.registerListener(PacketType::ICEPingReply, + PacketReceiver::makeUnsourcedListenerReference(&_domainHandler, &DomainHandler::processICEPingReplyPacket)); + packetReceiver.registerListener(PacketType::DomainServerPathResponse, + PacketReceiver::makeUnsourcedListenerReference(this, &NodeList::processDomainServerPathResponse)); + packetReceiver.registerListener(PacketType::DomainServerRemovedNode, + PacketReceiver::makeUnsourcedListenerReference(this, &NodeList::processDomainServerRemovedNode)); + packetReceiver.registerListener(PacketType::UsernameFromIDReply, + PacketReceiver::makeUnsourcedListenerReference(this, &NodeList::processUsernameFromIDReply)); } qint64 NodeList::sendStats(QJsonObject statsObject, HifiSockAddr destination) { diff --git a/libraries/networking/src/PacketReceiver.cpp b/libraries/networking/src/PacketReceiver.cpp index 962ceab00f..80222d38a9 100644 --- a/libraries/networking/src/PacketReceiver.cpp +++ b/libraries/networking/src/PacketReceiver.cpp @@ -12,7 +12,8 @@ #include "PacketReceiver.h" -#include +#include +#include #include "DependencyManager.h" #include "NetworkLogging.h" @@ -25,85 +26,56 @@ PacketReceiver::PacketReceiver(QObject* parent) : QObject(parent) { qRegisterMetaType>(); } -bool PacketReceiver::registerListenerForTypes(PacketTypeList types, QObject* listener, const char* slot) { +bool PacketReceiver::ListenerReference::invokeWithQt(const QSharedPointer& receivedMessagePointer, const QSharedPointer& sourceNode) { + return QMetaObject::invokeMethod(getObject(), [=]() { + this->invokeDirectly(receivedMessagePointer, sourceNode); + }); +} + +bool PacketReceiver::registerListenerForTypes(PacketTypeList types, const ListenerReferencePointer& listener) { Q_ASSERT_X(!types.empty(), "PacketReceiver::registerListenerForTypes", "No types to register"); - Q_ASSERT_X(listener, "PacketReceiver::registerListenerForTypes", "No object to register"); - Q_ASSERT_X(slot, "PacketReceiver::registerListenerForTypes", "No slot to register"); + Q_ASSERT_X(listener, "PacketReceiver::registerListenerForTypes", "No listener to register"); - // Partition types based on whether they are sourced or not (non sourced in front) - auto middle = std::partition(std::begin(types), std::end(types), [](PacketType type) { - return PacketTypeEnum::getNonSourcedPackets().contains(type); - }); - - QMetaMethod nonSourcedMethod, sourcedMethod; - - // Check we have a valid method for non sourced types if any - if (middle != std::begin(types)) { - nonSourcedMethod = matchingMethodForListener(*std::begin(types), listener, slot); - if (!nonSourcedMethod.isValid()) { - return false; - } - } - - // Check we have a valid method for sourced types if any - if (middle != std::end(types)) { - sourcedMethod = matchingMethodForListener(*middle, listener, slot); - if (!sourcedMethod.isValid()) { - return false; - } - } - - // Register non sourced types - std::for_each(std::begin(types), middle, [this, &listener, &nonSourcedMethod](PacketType type) { - registerVerifiedListener(type, listener, nonSourcedMethod); - }); - - // Register sourced types - std::for_each(middle, std::end(types), [this, &listener, &sourcedMethod](PacketType type) { - registerVerifiedListener(type, listener, sourcedMethod); + std::for_each(std::begin(types), std::end(types), [this, &listener](PacketType type) { + registerVerifiedListener(type, listener); }); return true; } -void PacketReceiver::registerDirectListener(PacketType type, QObject* listener, const char* slot) { - Q_ASSERT_X(listener, "PacketReceiver::registerDirectListener", "No object to register"); - Q_ASSERT_X(slot, "PacketReceiver::registerDirectListener", "No slot to register"); +void PacketReceiver::registerDirectListener(PacketType type, const ListenerReferencePointer& listener) { + Q_ASSERT_X(listener, "PacketReceiver::registerDirectListener", "No listener to register"); - bool success = registerListener(type, listener, slot); + bool success = registerListener(type, listener); if (success) { QMutexLocker locker(&_directConnectSetMutex); // if we successfully registered, add this object to the set of objects that are directly connected - _directlyConnectedObjects.insert(listener); + _directlyConnectedObjects.insert(listener->getObject()); } } -void PacketReceiver::registerDirectListenerForTypes(PacketTypeList types, - QObject* listener, const char* slot) { - Q_ASSERT_X(listener, "PacketReceiver::registerDirectListenerForTypes", "No object to register"); - Q_ASSERT_X(slot, "PacketReceiver::registerDirectListenerForTypes", "No slot to register"); +void PacketReceiver::registerDirectListenerForTypes(PacketTypeList types, const ListenerReferencePointer& listener) { + Q_ASSERT_X(listener, "PacketReceiver::registerDirectListenerForTypes", "No listener to register"); // just call register listener for types to start - bool success = registerListenerForTypes(std::move(types), listener, slot); + bool success = registerListenerForTypes(std::move(types), listener); if (success) { QMutexLocker locker(&_directConnectSetMutex); // if we successfully registered, add this object to the set of objects that are directly connected - _directlyConnectedObjects.insert(listener); + _directlyConnectedObjects.insert(listener->getObject()); } } -bool PacketReceiver::registerListener(PacketType type, QObject* listener, const char* slot, - bool deliverPending) { - Q_ASSERT_X(listener, "PacketReceiver::registerListener", "No object to register"); - Q_ASSERT_X(slot, "PacketReceiver::registerListener", "No slot to register"); +bool PacketReceiver::registerListener(PacketType type, const ListenerReferencePointer& listener, bool deliverPending) { + Q_ASSERT_X(listener, "PacketReceiver::registerListener", "No listener to register"); - QMetaMethod matchingMethod = matchingMethodForListener(type, listener, slot); + bool matchingMethod = matchingMethodForListener(type, listener); - if (matchingMethod.isValid()) { + if (matchingMethod) { qCDebug(networking) << "Registering a packet listener for packet list type" << type; - registerVerifiedListener(type, listener, matchingMethod, deliverPending); + registerVerifiedListener(type, listener, deliverPending); return true; } else { qCWarning(networking) << "FAILED to Register a packet listener for packet list type" << type; @@ -111,62 +83,23 @@ bool PacketReceiver::registerListener(PacketType type, QObject* listener, const } } -QMetaMethod PacketReceiver::matchingMethodForListener(PacketType type, QObject* object, const char* slot) const { - Q_ASSERT_X(object, "PacketReceiver::matchingMethodForListener", "No object to call"); - Q_ASSERT_X(slot, "PacketReceiver::matchingMethodForListener", "No slot to call"); +bool PacketReceiver::matchingMethodForListener(PacketType type, const ListenerReferencePointer& listener) const { + Q_ASSERT_X(listener, "PacketReceiver::matchingMethodForListener", "No listener to call"); - // normalize the slot with the expected parameters - static const QString SIGNATURE_TEMPLATE("%1(%2)"); - static const QString NON_SOURCED_MESSAGE_LISTENER_PARAMETERS = "QSharedPointer"; + bool isSourced = listener->isSourced(); + bool isNonSourcedPacket = PacketTypeEnum::getNonSourcedPackets().contains(type); - QSet possibleSignatures { - SIGNATURE_TEMPLATE.arg(slot, NON_SOURCED_MESSAGE_LISTENER_PARAMETERS) - }; - - if (!PacketTypeEnum::getNonSourcedPackets().contains(type)) { - static const QString SOURCED_MESSAGE_LISTENER_PARAMETERS = "QSharedPointer,QSharedPointer"; - static const QString TYPEDEF_SOURCED_MESSAGE_LISTENER_PARAMETERS = "QSharedPointer,SharedNodePointer"; - - // a sourced packet must take the shared pointer to the ReceivedMessage but optionally could include - // a shared pointer to the node - possibleSignatures << SIGNATURE_TEMPLATE.arg(slot, TYPEDEF_SOURCED_MESSAGE_LISTENER_PARAMETERS); - possibleSignatures << SIGNATURE_TEMPLATE.arg(slot, SOURCED_MESSAGE_LISTENER_PARAMETERS); + assert(!isSourced || !isNonSourcedPacket); + if (isSourced && isNonSourcedPacket) { + qCDebug(networking) << "PacketReceiver::registerListener cannot support a sourced listener for type" << type; + return false; } - int methodIndex = -1; - - foreach(const QString& signature, possibleSignatures) { - QByteArray normalizedSlot = - QMetaObject::normalizedSignature(signature.toStdString().c_str()); - - // does the constructed normalized method exist? - methodIndex = object->metaObject()->indexOfSlot(normalizedSlot.toStdString().c_str()); - - if (methodIndex >= 0) { - break; - } - } - - if (methodIndex < 0) { - qCDebug(networking) << "PacketReceiver::registerListener expected a slot with one of the following signatures:" - << possibleSignatures.toList() << "- but such a slot was not found." - << "Could not complete listener registration for type" << type; - } - - Q_ASSERT(methodIndex >= 0); - - // return the converted QMetaMethod - if (methodIndex >= 0) { - return object->metaObject()->method(methodIndex); - } else { - // if somehow (scripting?) something bad gets in here at runtime that doesn't hit the asserts above - // return a non-valid QMetaMethod - return QMetaMethod(); - } + return true; } -void PacketReceiver::registerVerifiedListener(PacketType type, QObject* object, const QMetaMethod& slot, bool deliverPending) { - Q_ASSERT_X(object, "PacketReceiver::registerVerifiedListener", "No object to register"); +void PacketReceiver::registerVerifiedListener(PacketType type, const ListenerReferencePointer& listener, bool deliverPending) { + Q_ASSERT_X(listener, "PacketReceiver::registerVerifiedListener", "No listener to register"); QMutexLocker locker(&_packetListenerLock); if (_messageListenerMap.contains(type)) { @@ -175,7 +108,7 @@ void PacketReceiver::registerVerifiedListener(PacketType type, QObject* object, } // add the mapping - _messageListenerMap[type] = { QPointer(object), slot, deliverPending }; + _messageListenerMap[type] = { listener, deliverPending }; } void PacketReceiver::unregisterListener(QObject* listener) { @@ -188,7 +121,7 @@ void PacketReceiver::unregisterListener(QObject* listener) { auto it = _messageListenerMap.begin(); while (it != _messageListenerMap.end()) { - if (it.value().object == listener) { + if (it.value().listener->getObject() == listener) { it = _messageListenerMap.erase(it); } else { ++it; @@ -261,7 +194,7 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer recei QMutexLocker packetListenerLocker(&_packetListenerLock); auto it = _messageListenerMap.find(receivedMessage->getType()); - if (it != _messageListenerMap.end() && it->method.isValid()) { + if (it != _messageListenerMap.end() && !it->listener.isNull()) { auto listener = it.value(); @@ -271,36 +204,19 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer recei bool success = false; - Qt::ConnectionType connectionType; + bool isDirectConnect = false; // check if this is a directly connected listener { QMutexLocker directConnectLocker(&_directConnectSetMutex); - connectionType = _directlyConnectedObjects.contains(listener.object) ? Qt::DirectConnection : Qt::AutoConnection; + isDirectConnect = _directlyConnectedObjects.contains(listener.listener->getObject()); } - QMetaMethod metaMethod = listener.method; - - static const QByteArray QSHAREDPOINTER_NODE_NORMALIZED = QMetaObject::normalizedType("QSharedPointer"); - static const QByteArray SHARED_NODE_NORMALIZED = QMetaObject::normalizedType("SharedNodePointer"); - // one final check on the QPointer before we go to invoke - if (listener.object) { - if (metaMethod.parameterTypes().contains(SHARED_NODE_NORMALIZED)) { - success = metaMethod.invoke(listener.object, - connectionType, - Q_ARG(QSharedPointer, receivedMessage), - Q_ARG(SharedNodePointer, matchingNode)); - - } else if (metaMethod.parameterTypes().contains(QSHAREDPOINTER_NODE_NORMALIZED)) { - success = metaMethod.invoke(listener.object, - connectionType, - Q_ARG(QSharedPointer, receivedMessage), - Q_ARG(QSharedPointer, matchingNode)); - + if (listener.listener->getObject()) { + if (isDirectConnect) { + success = listener.listener->invokeDirectly(receivedMessage, matchingNode); } else { - success = metaMethod.invoke(listener.object, - connectionType, - Q_ARG(QSharedPointer, receivedMessage)); + success = listener.listener->invokeWithQt(receivedMessage, matchingNode); } } else { qCDebug(networking).nospace() << "Listener for packet " << receivedMessage->getType() @@ -310,19 +226,19 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer recei // if it exists, remove the listener from _directlyConnectedObjects { QMutexLocker directConnectLocker(&_directConnectSetMutex); - _directlyConnectedObjects.remove(listener.object); + _directlyConnectedObjects.remove(listener.listener->getObject()); } } if (!success) { qCDebug(networking).nospace() << "Error delivering packet " << receivedMessage->getType() << " to listener " - << listener.object << "::" << qPrintable(listener.method.methodSignature()); + << listener.listener->getObject(); } } else if (it == _messageListenerMap.end()) { qCWarning(networking) << "No listener found for packet type" << receivedMessage->getType(); // insert a dummy listener so we don't print this again - _messageListenerMap.insert(receivedMessage->getType(), { nullptr, QMetaMethod(), false }); + _messageListenerMap.insert(receivedMessage->getType(), { ListenerReferencePointer(), false }); } } diff --git a/libraries/networking/src/PacketReceiver.h b/libraries/networking/src/PacketReceiver.h index e29a0d6e5a..0bed88cff9 100644 --- a/libraries/networking/src/PacketReceiver.h +++ b/libraries/networking/src/PacketReceiver.h @@ -16,8 +16,6 @@ #include #include -#include -#include #include #include #include @@ -29,6 +27,7 @@ #include "udt/PacketHeaders.h" class EntityEditPacketSender; +class Node; class OctreePacketProcessor; namespace std { @@ -42,6 +41,22 @@ namespace std { class PacketReceiver : public QObject { Q_OBJECT +public: + class ListenerReference { + public: + virtual bool invokeDirectly(const QSharedPointer& receivedMessagePointer, const QSharedPointer& sourceNode) = 0; + bool invokeWithQt(const QSharedPointer& receivedMessagePointer, const QSharedPointer& sourceNode); + virtual bool isSourced() const = 0; + virtual QObject* getObject() const = 0; + }; + typedef QSharedPointer ListenerReferencePointer; + + template + static ListenerReferencePointer makeUnsourcedListenerReference(T* target, void (T::*slot)(QSharedPointer)); + + template + static ListenerReferencePointer makeSourcedListenerReference(T* target, void (T::*slot)(QSharedPointer, QSharedPointer)); + public: using PacketTypeList = std::vector; @@ -55,8 +70,8 @@ public: // If deliverPending is false, ReceivedMessage will only be delivered once all packets for the message have // been received. If deliverPending is true, ReceivedMessage will be delivered as soon as the first packet // for the message is received. - bool registerListener(PacketType type, QObject* listener, const char* slot, bool deliverPending = false); - bool registerListenerForTypes(PacketTypeList types, QObject* listener, const char* slot); + bool registerListener(PacketType type, const ListenerReferencePointer& listener, bool deliverPending = false); + bool registerListenerForTypes(PacketTypeList types, const ListenerReferencePointer& listener); void unregisterListener(QObject* listener); void handleVerifiedPacket(std::unique_ptr packet); @@ -64,9 +79,34 @@ public: void handleMessageFailure(HifiSockAddr from, udt::Packet::MessageNumber messageNumber); private: + template + class UnsourcedListenerReference : public ListenerReference { + public: + inline UnsourcedListenerReference(T* target, void (T::*slot)(QSharedPointer)); + virtual bool invokeDirectly(const QSharedPointer& receivedMessagePointer, const QSharedPointer& sourceNode); + virtual bool isSourced() const { return false; } + virtual QObject* getObject() const { return _target; } + + private: + QPointer _target; + void (T::*_slot)(QSharedPointer); + }; + + template + class SourcedListenerReference : public ListenerReference { + public: + inline SourcedListenerReference(T* target, void (T::*slot)(QSharedPointer, QSharedPointer)); + virtual bool invokeDirectly(const QSharedPointer& receivedMessagePointer, const QSharedPointer& sourceNode); + virtual bool isSourced() const { return true; } + virtual QObject* getObject() const { return _target; } + + private: + QPointer _target; + void (T::*_slot)(QSharedPointer, QSharedPointer); + }; + struct Listener { - QPointer object; - QMetaMethod method; + ListenerReferencePointer listener; bool deliverPending; }; @@ -74,11 +114,11 @@ private: // these are brutal hacks for now - ideally GenericThread / ReceivedPacketProcessor // should be changed to have a true event loop and be able to handle our QMetaMethod::invoke - void registerDirectListenerForTypes(PacketTypeList types, QObject* listener, const char* slot); - void registerDirectListener(PacketType type, QObject* listener, const char* slot); + void registerDirectListenerForTypes(PacketTypeList types, const ListenerReferencePointer& listener); + void registerDirectListener(PacketType type, const ListenerReferencePointer& listener); - QMetaMethod matchingMethodForListener(PacketType type, QObject* object, const char* slot) const; - void registerVerifiedListener(PacketType type, QObject* listener, const QMetaMethod& slot, bool deliverPending = false); + bool matchingMethodForListener(PacketType type, const ListenerReferencePointer& listener) const; + void registerVerifiedListener(PacketType type, const ListenerReferencePointer& listener, bool deliverPending = false); QMutex _packetListenerLock; QHash _messageListenerMap; @@ -93,4 +133,42 @@ private: friend class OctreePacketProcessor; }; +template +PacketReceiver::ListenerReferencePointer PacketReceiver::makeUnsourcedListenerReference(T* target, void (T::* slot)(QSharedPointer)) { + return QSharedPointer>::create(target, slot); +} + +template +PacketReceiver::ListenerReferencePointer PacketReceiver::makeSourcedListenerReference(T* target, void (T::* slot)(QSharedPointer, QSharedPointer)) { + return QSharedPointer>::create(target, slot); +} + +template +PacketReceiver::UnsourcedListenerReference::UnsourcedListenerReference(T* target, void (T::*slot)(QSharedPointer)) : + _target(target),_slot(slot) { +} + +template +bool PacketReceiver::UnsourcedListenerReference::invokeDirectly(const QSharedPointer& receivedMessagePointer, const QSharedPointer&) { + if (_target.isNull()) { + return false; + } + (_target->*_slot)(receivedMessagePointer); + return true; +} + +template +PacketReceiver::SourcedListenerReference::SourcedListenerReference(T* target, void (T::*slot)(QSharedPointer, QSharedPointer)) : + _target(target),_slot(slot) { +} + +template +bool PacketReceiver::SourcedListenerReference::invokeDirectly(const QSharedPointer& receivedMessagePointer, const QSharedPointer& sourceNode) { + if (_target.isNull()) { + return false; + } + (_target->*_slot)(receivedMessagePointer, sourceNode); + return true; +} + #endif // hifi_PacketReceiver_h diff --git a/libraries/networking/src/ResourceCache.cpp b/libraries/networking/src/ResourceCache.cpp index 88a4f5bf32..4ba456d859 100644 --- a/libraries/networking/src/ResourceCache.cpp +++ b/libraries/networking/src/ResourceCache.cpp @@ -16,8 +16,9 @@ #include #include -#include -#include +#include +#include +#include #include #include diff --git a/libraries/octree/src/OctreePersistThread.cpp b/libraries/octree/src/OctreePersistThread.cpp index dd2cc12d50..c4f24c552b 100644 --- a/libraries/octree/src/OctreePersistThread.cpp +++ b/libraries/octree/src/OctreePersistThread.cpp @@ -64,7 +64,8 @@ void OctreePersistThread::start() { cleanupOldReplacementBackups(); auto& packetReceiver = DependencyManager::get()->getPacketReceiver(); - packetReceiver.registerListener(PacketType::OctreeDataFileReply, this, "handleOctreeDataFileReply"); + packetReceiver.registerListener(PacketType::OctreeDataFileReply, + PacketReceiver::makeUnsourcedListenerReference(this, &OctreePersistThread::handleOctreeDataFileReply)); auto nodeList = DependencyManager::get(); const DomainHandler& domainHandler = nodeList->getDomainHandler();