Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
samcake 2017-02-10 15:46:33 -08:00
commit 13d1642ace
6 changed files with 112 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
assignment-client/src/messages/MessagesMixer.cpp
View file

@ -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);
});
}

60
libraries/networking/src/MessagesClient.cpp
View file

@ -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);
message = QString::fromUtf8(messageData);
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);
emit messageReceived(channel, message, senderID, false);
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);
}

9
libraries/networking/src/MessagesClient.h
View file

@ -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 std::unique_ptr<NLPacketList> encodeMessagesPacket(QString channel, QString message, QUuid senderID);
static void decodeMessagesPacket(QSharedPointer<ReceivedMessage> receivedMessage, QString& channel,
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);

2
libraries/networking/src/udt/PacketHeaders.cpp
View file

@ -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:

4
libraries/networking/src/udt/PacketHeaders.h
View file

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

38
scripts/developer/tests/messagesTests.js Normal file
View file

@ -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);
});