Merge pull request #13432 from SimonWalton-HiFi/avatar-identity-request

Implement AvatarRequestIdentity and use if interface gets unknown avatar data

assignment-client/src/avatars/AvatarMixer.cpp

@@ -53,6 +53,7 @@ AvatarMixer::AvatarMixer(ReceivedMessage& message) :
     packetReceiver.registerListener(PacketType::NodeIgnoreRequest, this, "handleNodeIgnoreRequestPacket");
     packetReceiver.registerListener(PacketType::RadiusIgnoreRequest, this, "handleRadiusIgnoreRequestPacket");
     packetReceiver.registerListener(PacketType::RequestsDomainListData, this, "handleRequestsDomainListDataPacket");
+    packetReceiver.registerListener(PacketType::AvatarIdentityRequest, this, "handleAvatarIdentityRequestPacket");
 
     packetReceiver.registerListenerForTypes({
         PacketType::ReplicatedAvatarIdentity,
@@ -602,6 +603,31 @@ void AvatarMixer::handleAvatarIdentityPacket(QSharedPointer<ReceivedMessage> mes
     _handleAvatarIdentityPacketElapsedTime += (end - start);
 }
 
+void AvatarMixer::handleAvatarIdentityRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
+    if (message->getSize() < NUM_BYTES_RFC4122_UUID) {
+        qCDebug(avatars) << "Malformed AvatarIdentityRequest received from" << message->getSenderSockAddr().toString();
+        return;
+    }
+
+    QUuid avatarID(QUuid::fromRfc4122(message->getMessage()) );
+    if (!avatarID.isNull()) {
+        auto nodeList = DependencyManager::get<NodeList>();
+        auto node = nodeList->nodeWithUUID(avatarID);
+        if (node) {
+            QMutexLocker lock(&node->getMutex());
+            AvatarMixerClientData* avatarClientData = dynamic_cast<AvatarMixerClientData*>(node->getLinkedData());
+            if (avatarClientData) {
+                const AvatarData& avatarData = avatarClientData->getAvatar();
+                QByteArray serializedAvatar = avatarData.identityByteArray();
+                auto identityPackets = NLPacketList::create(PacketType::AvatarIdentity, QByteArray(), true, true);
+                identityPackets->write(serializedAvatar);
+                nodeList->sendPacketList(std::move(identityPackets), *senderNode);
+                ++_sumIdentityPackets;
+            }
+        }
+    }
+}
+
 void AvatarMixer::handleKillAvatarPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer node) {
     auto start = usecTimestampNow();
     handleAvatarKilled(node);

assignment-client/src/avatars/AvatarMixer.h

@@ -54,6 +54,7 @@ private slots:
     void handleRequestsDomainListDataPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleReplicatedPacket(QSharedPointer<ReceivedMessage> message);
     void handleReplicatedBulkAvatarPacket(QSharedPointer<ReceivedMessage> message);
+    void handleAvatarIdentityRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void domainSettingsRequestComplete();
     void handlePacketVersionMismatch(PacketType type, const HifiSockAddr& senderSockAddr, const QUuid& senderUUID);
     void start();

interface/src/Application.cpp

@@ -2123,6 +2123,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
             || ((rightHandPose.valid || lastRightHandPose.valid) && (rightHandPose != lastRightHandPose));
         lastLeftHandPose = leftHandPose;
         lastRightHandPose = rightHandPose;
+        properties["avatar_identity_requests_sent"] = DependencyManager::get<AvatarManager>()->getIdentityRequestsSent();
 
         UserActivityLogger::getInstance().logAction("stats", properties);
     });

interface/src/avatar/AvatarManager.cpp

@@ -15,6 +15,8 @@
 
 #include <QScriptEngine>
 
+#include "AvatarLogging.h"
+
 #if defined(__GNUC__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdouble-promotion"
@@ -54,6 +56,13 @@ static const quint64 MIN_TIME_BETWEEN_MY_AVATAR_DATA_SENDS = USECS_PER_SECOND /
 // We add _myAvatar into the hash with all the other AvatarData, and we use the default NULL QUid as the key.
 const QUuid MY_AVATAR_KEY;  // NULL key
 
+namespace {
+    // For an unknown avatar-data packet, wait this long before requesting the identity.
+    constexpr std::chrono::milliseconds REQUEST_UNKNOWN_IDENTITY_DELAY { 5 * 1000 };
+    constexpr int REQUEST_UNKNOWN_IDENTITY_TRANSMITS = 3;
+}
+using std::chrono::steady_clock;
+
 AvatarManager::AvatarManager(QObject* parent) :
     _avatarsToFade(),
     _myAvatar(new MyAvatar(qApp->thread()), [](MyAvatar* ptr) { ptr->deleteLater(); })
@@ -118,6 +127,7 @@ void AvatarManager::updateMyAvatar(float deltaTime) {
         _lastSendAvatarDataTime = now;
         _myAvatarSendRate.increment();
     }
+
 }
 
 
@@ -286,6 +296,28 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
 
     simulateAvatarFades(deltaTime);
 
+    // Check on avatars with pending identities:
+    steady_clock::time_point now = steady_clock::now();
+    QWriteLocker writeLock(&_hashLock);
+    for (auto pendingAvatar = _pendingAvatars.begin(); pendingAvatar != _pendingAvatars.end(); ++pendingAvatar) {
+        if (now - pendingAvatar->creationTime >= REQUEST_UNKNOWN_IDENTITY_DELAY) {
+            // Too long without an ID
+            sendIdentityRequest(pendingAvatar->avatar->getID());
+            if (++pendingAvatar->transmits >= REQUEST_UNKNOWN_IDENTITY_TRANSMITS) {
+                qCDebug(avatars) << "Requesting identity for unknown avatar (final request)" <<
+                    pendingAvatar->avatar->getID().toString();
+
+                pendingAvatar = _pendingAvatars.erase(pendingAvatar);
+                if (pendingAvatar == _pendingAvatars.end()) {
+                    break;
+                }
+            } else {
+                pendingAvatar->creationTime = now;
+                qCDebug(avatars) << "Requesting identity for unknown avatar" << pendingAvatar->avatar->getID().toString();
+            }
+        }
+    }
+
     _avatarSimulationTime = (float)(usecTimestampNow() - startTime) / (float)USECS_PER_MSEC;
 }
 
@@ -298,6 +330,20 @@ void AvatarManager::postUpdate(float deltaTime, const render::ScenePointer& scen
     }
 }
 
+void AvatarManager::sendIdentityRequest(const QUuid& avatarID) const {
+    auto nodeList = DependencyManager::get<NodeList>();
+    nodeList->eachMatchingNode(
+        [&](const SharedNodePointer& node)->bool {
+        return node->getType() == NodeType::AvatarMixer && node->getActiveSocket();
+    },
+        [&](const SharedNodePointer& node) {
+        auto packet = NLPacket::create(PacketType::AvatarIdentityRequest, NUM_BYTES_RFC4122_UUID, true);
+        packet->write(avatarID.toRfc4122());
+        nodeList->sendPacket(std::move(packet), *node);
+        ++_identityRequestsSent;
+    });
+}
+
 void AvatarManager::simulateAvatarFades(float deltaTime) {
     if (_avatarsToFade.empty()) {
         return;

interface/src/avatar/AvatarManager.h

@@ -82,6 +82,7 @@ public:
 
     void updateMyAvatar(float deltaTime);
     void updateOtherAvatars(float deltaTime);
+    void sendIdentityRequest(const QUuid& avatarID) const;
 
     void postUpdate(float deltaTime, const render::ScenePointer& scene);
 
@@ -157,6 +158,7 @@ public:
     Q_INVOKABLE void setAvatarSortCoefficient(const QString& name, const QScriptValue& value);
 
     float getMyAvatarSendRate() const { return _myAvatarSendRate.rate(); }
+    int getIdentityRequestsSent() const { return _identityRequestsSent; }
 
 public slots:
 
@@ -194,6 +196,7 @@ private:
     int _numAvatarsNotUpdated { 0 };
     float _avatarSimulationTime { 0.0f };
     bool _shouldRender { true };
+    mutable int _identityRequestsSent { 0 };
 };
 
 #endif // hifi_AvatarManager_h

libraries/avatars/src/AvatarData.h

@@ -401,7 +401,6 @@ class AvatarData : public QObject, public SpatiallyNestable {
     Q_PROPERTY(float sensorToWorldScale READ getSensorToWorldScale)
 
 public:
-
     virtual QString getName() const override { return QString("Avatar:") + _displayName; }
 
     static const QString FRAME_NAME;

libraries/avatars/src/AvatarHashMap.cpp

@@ -89,11 +89,15 @@ AvatarSharedPointer AvatarHashMap::addAvatar(const QUuid& sessionUUID, const QWe
     return avatar;
 }
 
-AvatarSharedPointer AvatarHashMap::newOrExistingAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {
+AvatarSharedPointer AvatarHashMap::newOrExistingAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer,
+    bool& isNew) {
     QWriteLocker locker(&_hashLock);
     auto avatar = _avatarHash.value(sessionUUID);
     if (!avatar) {
         avatar = addAvatar(sessionUUID, mixerWeakPointer);
+        isNew = true;
+    } else {
+        isNew = false;
     }
     return avatar;
 }
@@ -125,8 +129,13 @@ AvatarSharedPointer AvatarHashMap::parseAvatarData(QSharedPointer<ReceivedMessag
     // make sure this isn't our own avatar data or for a previously ignored node
     auto nodeList = DependencyManager::get<NodeList>();
 
+    bool isNewAvatar;
     if (sessionUUID != _lastOwnerSessionUUID && (!nodeList->isIgnoringNode(sessionUUID) || nodeList->getRequestsDomainListData())) {
-        auto avatar = newOrExistingAvatar(sessionUUID, sendingNode);
+        auto avatar = newOrExistingAvatar(sessionUUID, sendingNode, isNewAvatar);
+        if (isNewAvatar) {
+            QWriteLocker locker(&_hashLock);
+            _pendingAvatars.insert(sessionUUID, { std::chrono::steady_clock::now(), 0, avatar });
+        }
 
         // have the matching (or new) avatar parse the data from the packet
         int bytesRead = avatar->parseDataFromBuffer(byteArray);
@@ -157,6 +166,7 @@ void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<ReceivedMessage>
 
     {
         QReadLocker locker(&_hashLock);
+        _pendingAvatars.remove(identityUUID);
         auto me = _avatarHash.find(EMPTY);
         if ((me != _avatarHash.end()) && (identityUUID == me.value()->getSessionUUID())) {
             // We add MyAvatar to _avatarHash with an empty UUID. Code relies on this. In order to correctly handle an
@@ -168,7 +178,8 @@ void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<ReceivedMessage>
     
     if (!nodeList->isIgnoringNode(identityUUID) || nodeList->getRequestsDomainListData()) {
         // mesh URL for a UUID, find avatar in our list
-        auto avatar = newOrExistingAvatar(identityUUID, sendingNode);
+        bool isNewAvatar;
+        auto avatar = newOrExistingAvatar(identityUUID, sendingNode, isNewAvatar);
         bool identityChanged = false;
         bool displayNameChanged = false;
         bool skeletonModelUrlChanged = false;
@@ -189,6 +200,7 @@ void AvatarHashMap::processKillAvatar(QSharedPointer<ReceivedMessage> message, S
 void AvatarHashMap::removeAvatar(const QUuid& sessionUUID, KillAvatarReason removalReason) {
     QWriteLocker locker(&_hashLock);
 
+    _pendingAvatars.remove(sessionUUID);
     auto removedAvatar = _avatarHash.take(sessionUUID);
 
     if (removedAvatar) {

libraries/avatars/src/AvatarHashMap.h

@@ -19,6 +19,7 @@
 
 #include <functional>
 #include <memory>
+#include <chrono>
 
 #include <glm/glm.hpp>
 
@@ -145,13 +146,21 @@ protected:
     virtual AvatarSharedPointer parseAvatarData(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
     virtual AvatarSharedPointer newSharedAvatar();
     virtual AvatarSharedPointer addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);
-    AvatarSharedPointer newOrExistingAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);
+    AvatarSharedPointer newOrExistingAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer,
+        bool& isNew);
     virtual AvatarSharedPointer findAvatar(const QUuid& sessionUUID) const; // uses a QReadLocker on the hashLock
     virtual void removeAvatar(const QUuid& sessionUUID, KillAvatarReason removalReason = KillAvatarReason::NoReason);
 
     virtual void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar, KillAvatarReason removalReason = KillAvatarReason::NoReason);
 
     AvatarHash _avatarHash;
+    struct PendingAvatar {
+        std::chrono::steady_clock::time_point creationTime;
+        int transmits;
+        AvatarSharedPointer avatar;
+    };
+    using AvatarPendingHash = QHash<QUuid, PendingAvatar>;
+    AvatarPendingHash _pendingAvatars;
     mutable QReadWriteLock _hashLock;
 
 private:

libraries/networking/src/udt/PacketHeaders.cpp

@@ -92,6 +92,8 @@ PacketVersion versionForPacketType(PacketType packetType) {
             return static_cast<PacketVersion>(PingVersion::IncludeConnectionID);
         case PacketType::AvatarQuery:
             return static_cast<PacketVersion>(AvatarQueryVersion::ConicalFrustums);
+        case PacketType::AvatarIdentityRequest:
+            return 22;
         default:
             return 21;
     }

libraries/networking/src/udt/PacketHeaders.h

@@ -57,7 +57,7 @@ public:
         ICEServerQuery,
         OctreeStats,
         UNUSED_PACKET_TYPE_1,
-        UNUSED_PACKET_TYPE_2,
+        AvatarIdentityRequest,
         AssignmentClientStatus,
         NoisyMute,
         AvatarIdentity,

tools/dissectors/1-hfudt.lua

@@ -87,7 +87,7 @@ local packet_types = {
   [23] = "ICEServerQuery",
   [24] = "OctreeStats",
   [25] = "Jurisdiction",
-  [26] = "JurisdictionRequest",
+  [26] = "AvatarIdentityRequest",
   [27] = "AssignmentClientStatus",
   [28] = "NoisyMute",
   [29] = "AvatarIdentity",