have domain-server using full networking heartbeat with ice-server

domain-server/src/DomainServer.cpp

@@ -327,24 +327,39 @@ void DomainServer::setupAutomaticNetworking() {
     QString automaticNetworkValue =
         _settingsManager.valueOrDefaultValueForKeyPath(METAVERSE_AUTOMATIC_NETWORKING_KEY_PATH).toString();
     
-    if (automaticNetworkValue == IP_ONLY_AUTOMATIC_NETWORKING_VALUE) {
+    if (automaticNetworkValue == IP_ONLY_AUTOMATIC_NETWORKING_VALUE ||
+        automaticNetworkValue == FULL_AUTOMATIC_NETWORKING_VALUE) {
         
         LimitedNodeList* nodeList = LimitedNodeList::getInstance();
         const QUuid& domainID = nodeList->getSessionUUID();
         
         if (!domainID.isNull()) {
             qDebug() << "domain-server" << automaticNetworkValue << "automatic networking enabled for ID"
-            << uuidStringWithoutCurlyBraces(domainID) << "via" << _oauthProviderURL.toString();
+                << uuidStringWithoutCurlyBraces(domainID) << "via" << _oauthProviderURL.toString();
             
             const int STUN_IP_ADDRESS_CHECK_INTERVAL_MSECS = 30 * 1000;
+            const int STUN_REFLEXIVE_KEEPALIVE_INTERVAL_MSECS = 10 * 1000;
             
-            // setup our timer to check our IP via stun every 30 seconds
+            // setup our timer to check our IP via stun every X seconds
             QTimer* dynamicIPTimer = new QTimer(this);
             connect(dynamicIPTimer, &QTimer::timeout, this, &DomainServer::requestCurrentPublicSocketViaSTUN);
-            dynamicIPTimer->start(STUN_IP_ADDRESS_CHECK_INTERVAL_MSECS);
             
-            // send public socket changes to the data server so nodes can find us at our new IP
+            if (automaticNetworkValue == IP_ONLY_AUTOMATIC_NETWORKING_VALUE) {
-            connect(nodeList, &LimitedNodeList::publicSockAddrChanged, this, &DomainServer::performIPAddressUpdate);
+                dynamicIPTimer->start(STUN_IP_ADDRESS_CHECK_INTERVAL_MSECS);
+                
+                // send public socket changes to the data server so nodes can find us at our new IP
+                connect(nodeList, &LimitedNodeList::publicSockAddrChanged, this, &DomainServer::performIPAddressUpdate);
+            } else {
+                dynamicIPTimer->start(STUN_REFLEXIVE_KEEPALIVE_INTERVAL_MSECS);
+                
+                // setup a timer to heartbeat with the ice-server every so often
+                QTimer* iceHeartbeatTimer = new QTimer(this);
+                connect(iceHeartbeatTimer, &QTimer::timeout, this, &DomainServer::sendHearbeatToIceServer);
+                iceHeartbeatTimer->start(ICE_HEARBEAT_INTERVAL_MSECS);
+                
+                // call our sendHeartbeaToIceServer immediately anytime a public address changes
+                connect(nodeList, &LimitedNodeList::publicSockAddrChanged, this, &DomainServer::sendHearbeatToIceServer);
+            }
             
             // attempt to update our sockets now
             requestCurrentPublicSocketViaSTUN();
@@ -968,6 +983,10 @@ void DomainServer::updateNetworkingInfoWithDataServer(const QString& newSetting,
                                                        domainUpdateJSON.toUtf8());
 }
 
+void DomainServer::sendHearbeatToIceServer() {
+    LimitedNodeList::getInstance()->sendHeartbeatToIceServer();
+}
+
 void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr) {
     LimitedNodeList* nodeList = LimitedNodeList::getInstance();
 

domain-server/src/DomainServer.h

@@ -64,6 +64,7 @@ private slots:
     
     void requestCurrentPublicSocketViaSTUN();
     void performIPAddressUpdate(const HifiSockAddr& newPublicSockAddr);
+    void sendHearbeatToIceServer();
 private:
     void setupNodeListAndAssignments(const QUuid& sessionUUID = QUuid::createUuid());
     bool optionallySetupOAuth();

libraries/networking/src/LimitedNodeList.cpp

@@ -618,3 +618,24 @@ bool LimitedNodeList::processSTUNResponse(const QByteArray& packet) {
     
     return false;
 }
+
+void LimitedNodeList::sendHeartbeatToIceServer(QUuid headerID, const QUuid& connectionRequestID) {
+    
+    if (headerID.isNull()) {
+        headerID = _sessionUUID;
+    }
+    
+    QByteArray iceRequestByteArray = byteArrayWithPopulatedHeader(PacketTypeIceServerHeartbeat, headerID);
+    QDataStream iceDataStream(&iceRequestByteArray, QIODevice::Append);
+    
+    iceDataStream << _publicSockAddr << HifiSockAddr(QHostAddress(getHostOrderLocalAddress()), _nodeSocket.localPort());
+    
+    if (!connectionRequestID.isNull()) {
+        iceDataStream << connectionRequestID;
+        
+        qDebug() << "Sending packet to ICE server to request connection info for peer with ID"
+            << uuidStringWithoutCurlyBraces(connectionRequestID);
+    }
+    
+    _nodeSocket.writeDatagram(iceRequestByteArray, QHostAddress::LocalHost, ICE_SERVER_DEFAULT_PORT);
+}

libraries/networking/src/LimitedNodeList.h

@@ -106,6 +106,8 @@ public:
     
     virtual void sendSTUNRequest();
     virtual bool processSTUNResponse(const QByteArray& packet);
+    
+    void sendHeartbeatToIceServer(QUuid headerID = QUuid(), const QUuid& connectRequestID = QUuid());
 public slots:
     void reset();
     void eraseAllNodes();

libraries/networking/src/NetworkPeer.h

@@ -19,6 +19,7 @@
 
 const QString ICE_SERVER_HOSTNAME = "localhost";
 const int ICE_SERVER_DEFAULT_PORT = 7337;
+const int ICE_HEARBEAT_INTERVAL_MSECS = 2 * 1000;
 
 class NetworkPeer : public QObject {
 public:

libraries/networking/src/NodeList.cpp

@@ -304,16 +304,7 @@ void NodeList::sendICERequestForDomainConnection() {
     
     static QUuid iceUUID = QUuid::createUuid();
     
-    QByteArray iceRequestByteArray = byteArrayWithPopulatedHeader(PacketTypeIceServerHeartbeat, iceUUID);
+    LimitedNodeList::sendHeartbeatToIceServer(iceUUID, _domainHandler.getUUID());
-    QDataStream iceDataStream(&iceRequestByteArray, QIODevice::Append);
-    
-    iceDataStream << _publicSockAddr << HifiSockAddr(QHostAddress(getHostOrderLocalAddress()), _nodeSocket.localPort());
-    iceDataStream << _domainHandler.getUUID();
-    
-    qDebug() << "Sending packet to ICE server to request connection info for peer with ID"
-        << uuidStringWithoutCurlyBraces(_domainHandler.getUUID());
-    
-    _nodeSocket.writeDatagram(iceRequestByteArray, QHostAddress::LocalHost, ICE_SERVER_DEFAULT_PORT);
 }
 
 int NodeList::processDomainServerList(const QByteArray& packet) {