Merge branch 'master' of https://github.com/highfidelity/hifi into ambient

assignment-client/src/messages/MessagesMixer.cpp

@@ -37,8 +37,10 @@ void MessagesMixer::nodeKilled(SharedNodePointer killedNode) {
 
 void MessagesMixer::handleMessages(QSharedPointer<ReceivedMessage> receivedMessage, SharedNodePointer senderNode) {
     QString channel, message;
+    QByteArray data;
     QUuid senderID;
-    MessagesClient::decodeMessagesPacket(receivedMessage, channel, message, senderID);
+    bool isText;
+    MessagesClient::decodeMessagesPacket(receivedMessage, channel, isText, message, data, senderID);
 
     auto nodeList = DependencyManager::get<NodeList>();
 
@@ -47,7 +49,8 @@ void MessagesMixer::handleMessages(QSharedPointer<ReceivedMessage> receivedMessa
         return node->getActiveSocket() && _channelSubscribers[channel].contains(node->getUUID());
     },
         [&](const SharedNodePointer& node) {
-        auto packetList = MessagesClient::encodeMessagesPacket(channel, message, senderID);
+        auto packetList = isText ? MessagesClient::encodeMessagesPacket(channel, message, senderID) :
+                                   MessagesClient::encodeMessagesDataPacket(channel, data, senderID);
         nodeList->sendPacketList(std::move(packetList), *node);
     });
 }

libraries/networking/src/MessagesClient.cpp

@@ -36,16 +36,23 @@ void MessagesClient::init() {
     }
 }
 
-void MessagesClient::decodeMessagesPacket(QSharedPointer<ReceivedMessage> receivedMessage, QString& channel, QString& message, QUuid& senderID) {
+void MessagesClient::decodeMessagesPacket(QSharedPointer<ReceivedMessage> receivedMessage, QString& channel, 
+                                                bool& isText, QString& message, QByteArray& data, QUuid& senderID) {
     quint16 channelLength;
     receivedMessage->readPrimitive(&channelLength);
     auto channelData = receivedMessage->read(channelLength);
     channel = QString::fromUtf8(channelData);
 
+    receivedMessage->readPrimitive(&isText);
+
     quint16 messageLength;
     receivedMessage->readPrimitive(&messageLength);
     auto messageData = receivedMessage->read(messageLength);
+    if (isText) {
         message = QString::fromUtf8(messageData);
+    } else {
+        data = messageData;
+    }
 
     QByteArray bytesSenderID = receivedMessage->read(NUM_BYTES_RFC4122_UUID);
     if (bytesSenderID.length() == NUM_BYTES_RFC4122_UUID) {
@@ -64,6 +71,9 @@ std::unique_ptr<NLPacketList> MessagesClient::encodeMessagesPacket(QString chann
     packetList->writePrimitive(channelLength);
     packetList->write(channelUtf8);
 
+    bool isTextMessage = true;
+    packetList->writePrimitive(isTextMessage);
+
     auto messageUtf8 = message.toUtf8();
     quint16 messageLength = messageUtf8.length();
     packetList->writePrimitive(messageLength);
@@ -74,12 +84,38 @@ std::unique_ptr<NLPacketList> MessagesClient::encodeMessagesPacket(QString chann
     return packetList;
 }
 
+std::unique_ptr<NLPacketList> MessagesClient::encodeMessagesDataPacket(QString channel, QByteArray data, QUuid senderID) {
+    auto packetList = NLPacketList::create(PacketType::MessagesData, QByteArray(), true, true);
+
+    auto channelUtf8 = channel.toUtf8();
+    quint16 channelLength = channelUtf8.length();
+    packetList->writePrimitive(channelLength);
+    packetList->write(channelUtf8);
+
+    bool isTextMessage = false;
+    packetList->writePrimitive(isTextMessage);
+
+    quint16 dataLength = data.length();
+    packetList->writePrimitive(dataLength);
+    packetList->write(data);
+
+    packetList->write(senderID.toRfc4122());
+
+    return packetList;
+}
+
 
 void MessagesClient::handleMessagesPacket(QSharedPointer<ReceivedMessage> receivedMessage, SharedNodePointer senderNode) {
     QString channel, message;
+    QByteArray data;
+    bool isText { false };
     QUuid senderID;
-    decodeMessagesPacket(receivedMessage, channel, message, senderID);
+    decodeMessagesPacket(receivedMessage, channel, isText, message, data, senderID);
+    if (isText) {
         emit messageReceived(channel, message, senderID, false);
+    } else {
+        emit dataReceived(channel, data, senderID, false);
+    }
 }
 
 void MessagesClient::sendMessage(QString channel, QString message, bool localOnly) {
@@ -98,6 +134,22 @@ void MessagesClient::sendMessage(QString channel, QString message, bool localOnl
     }
 }
 
+void MessagesClient::sendData(QString channel, QByteArray data, bool localOnly) {
+    auto nodeList = DependencyManager::get<NodeList>();
+    if (localOnly) {
+        QUuid senderID = nodeList->getSessionUUID();
+        emit dataReceived(channel, data, senderID, true);
+    } else {
+        SharedNodePointer messagesMixer = nodeList->soloNodeOfType(NodeType::MessagesMixer);
+
+        if (messagesMixer) {
+            QUuid senderID = nodeList->getSessionUUID();
+            auto packetList = encodeMessagesDataPacket(channel, data, senderID);
+            nodeList->sendPacketList(std::move(packetList), *messagesMixer);
+        }
+    }
+}
+
 void MessagesClient::sendLocalMessage(QString channel, QString message) {
     sendMessage(channel, message, true);
 }

libraries/networking/src/MessagesClient.h

@@ -14,6 +14,7 @@
 #define hifi_MessagesClient_h
 
 #include <QString>
+#include <QByteArray>
 
 #include <DependencyManager.h>
 
@@ -31,15 +32,19 @@ public:
 
     Q_INVOKABLE void sendMessage(QString channel, QString message, bool localOnly = false);
     Q_INVOKABLE void sendLocalMessage(QString channel, QString message);
+    Q_INVOKABLE void sendData(QString channel, QByteArray data, bool localOnly = false);
     Q_INVOKABLE void subscribe(QString channel);
     Q_INVOKABLE void unsubscribe(QString channel);
 
-    static void decodeMessagesPacket(QSharedPointer<ReceivedMessage> receivedMessage, QString& channel, QString& message, QUuid& senderID);
+    static void decodeMessagesPacket(QSharedPointer<ReceivedMessage> receivedMessage, QString& channel, 
-    static std::unique_ptr<NLPacketList> encodeMessagesPacket(QString channel, QString message, QUuid senderID);
+                                           bool& isText, QString& message, QByteArray& data, QUuid& senderID);
 
+    static std::unique_ptr<NLPacketList> encodeMessagesPacket(QString channel, QString message, QUuid senderID);
+    static std::unique_ptr<NLPacketList> encodeMessagesDataPacket(QString channel, QByteArray data, QUuid senderID);
 
 signals:
     void messageReceived(QString channel, QString message, QUuid senderUUID, bool localOnly);
+    void dataReceived(QString channel, QByteArray data, QUuid senderUUID, bool localOnly);
 
 private slots:
     void handleMessagesPacket(QSharedPointer<ReceivedMessage> receivedMessage, SharedNodePointer senderNode);

libraries/networking/src/udt/PacketHeaders.cpp

@@ -57,6 +57,8 @@ PacketVersion versionForPacketType(PacketType packetType) {
         case PacketType::BulkAvatarData:
         case PacketType::KillAvatar:
             return static_cast<PacketVersion>(AvatarMixerPacketVersion::VariableAvatarData);
+        case PacketType::MessagesData:
+            return static_cast<PacketVersion>(MessageDataVersion::TextOrBinaryData);
         case PacketType::ICEServerHeartbeat:
             return 18; // ICE Server Heartbeat signing
         case PacketType::AssetGetInfo:

libraries/networking/src/udt/PacketHeaders.h

@@ -263,4 +263,8 @@ enum class AudioVersion : PacketVersion {
     HighDynamicRangeVolume,
 };
 
+enum class MessageDataVersion : PacketVersion {
+    TextOrBinaryData = 18
+};
+
 #endif // hifi_PacketHeaders_h

scripts/developer/tests/messagesTests.js

@@ -0,0 +1,38 @@
+
+var channelName = "com.highfidelity.example.dataMessages";
+
+Messages.subscribe(channelName);
+
+//messageReceived(QString channel, QString message, QUuid senderUUID, bool localOnly);
+Messages.messageReceived.connect(function(channel, message, sender, local) {
+    print("message recieved on ", channel, " message:", message, " from:", sender, " local:", local);
+});
+
+Messages.dataReceived.connect(function(channel, data, sender, local) {
+    var int8data = new Int8Array(data);
+    var dataAsString = "";
+    for (var i = 0; i < int8data.length; i++) {
+        if (i > 0) {
+            dataAsString += ", ";
+        }
+        dataAsString += int8data[i];
+    }
+    print("data recieved on ", channel, " from:", sender, " local:", local, "length of data:", int8data.length, " data:", dataAsString);
+});
+
+var counter = 0;
+Script.update.connect(function(){
+    counter++;
+    if (counter == 100) {
+        Messages.sendMessage(channelName, "foo");
+    } else if (counter == 200) {
+        var data = new Int8Array([0,1,10,2,20,3,30]);
+        print("about to call sendData() data.length:", data.length);
+        Messages.sendData(channelName, data.buffer);
+        counter = 0;
+    }
+});
+
+Script.scriptEnding.connect(function(){
+    Messages.unsubscribe(channelName);
+});