feat: Live Emote Updates for 7TV (#4090)

Co-authored-by: Rasmus Karlsson <rasmus.karlsson@pajlada.com>
2022-11-13 12:07:41 +01:00
parent 8fa89b4073
commit 39f7d8ac4c
35 changed files with 1833 additions and 54 deletions
@@ -0,0 +1,69 @@
+#include <utility>
+
+#include "providers/seventv/eventapi/SeventvEventAPIClient.hpp"
+
+#include "providers/twitch/PubSubHelpers.hpp"
+
+namespace chatterino {
+
+SeventvEventAPIClient::SeventvEventAPIClient(
+    liveupdates::WebsocketClient &websocketClient,
+    liveupdates::WebsocketHandle handle,
+    std::chrono::milliseconds heartbeatInterval)
+    : BasicPubSubClient<SeventvEventAPISubscription>(websocketClient,
+                                                     std::move(handle))
+    , lastHeartbeat_(std::chrono::steady_clock::now())
+    , heartbeatInterval_(heartbeatInterval)
+{
+}
+
+void SeventvEventAPIClient::onConnectionEstablished()
+{
+    this->lastHeartbeat_.store(std::chrono::steady_clock::now(),
+                               std::memory_order_release);
+    this->checkHeartbeat();
+}
+
+void SeventvEventAPIClient::setHeartbeatInterval(int intervalMs)
+{
+    qCDebug(chatterinoSeventvEventAPI)
+        << "Setting expected heartbeat interval to" << intervalMs << "ms";
+    this->heartbeatInterval_ = std::chrono::milliseconds(intervalMs);
+}
+
+void SeventvEventAPIClient::handleHeartbeat()
+{
+    this->lastHeartbeat_.store(std::chrono::steady_clock::now(),
+                               std::memory_order_release);
+}
+
+void SeventvEventAPIClient::checkHeartbeat()
+{
+    // Following the heartbeat docs, a connection is dead
+    // after three missed heartbeats.
+    // https://github.com/SevenTV/EventAPI/tree/ca4ff15cc42b89560fa661a76c5849047763d334#heartbeat
+    assert(this->isStarted());
+    if ((std::chrono::steady_clock::now() - this->lastHeartbeat_.load()) >
+        3 * this->heartbeatInterval_)
+    {
+        qCDebug(chatterinoSeventvEventAPI)
+            << "Didn't receive a heartbeat in time, disconnecting!";
+        this->close("Didn't receive a heartbeat in time");
+
+        return;
+    }
+
+    auto self = std::dynamic_pointer_cast<SeventvEventAPIClient>(
+        this->shared_from_this());
+
+    runAfter(this->websocketClient_.get_io_service(), this->heartbeatInterval_,
+             [self](auto) {
+                 if (!self->isStarted())
+                 {
+                     return;
+                 }
+                 self->checkHeartbeat();
+             });
+}
+
+}  // namespace chatterino
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "providers/liveupdates/BasicPubSubClient.hpp"
+#include "providers/seventv/eventapi/SeventvEventAPISubscription.hpp"
+
+namespace chatterino {
+
+class SeventvEventAPIClient
+    : public BasicPubSubClient<SeventvEventAPISubscription>
+{
+public:
+    SeventvEventAPIClient(liveupdates::WebsocketClient &websocketClient,
+                          liveupdates::WebsocketHandle handle,
+                          std::chrono::milliseconds heartbeatInterval);
+
+    void setHeartbeatInterval(int intervalMs);
+    void handleHeartbeat();
+
+protected:
+    void onConnectionEstablished() override;
+
+private:
+    void checkHeartbeat();
+
+    std::atomic<std::chrono::time_point<std::chrono::steady_clock>>
+        lastHeartbeat_;
+    // This will be set once on the welcome message.
+    std::chrono::milliseconds heartbeatInterval_;
+
+    friend class SeventvEventAPI;
+};
+
+}  // namespace chatterino
@@ -0,0 +1,97 @@
+#include <utility>
+
+#include "providers/seventv/eventapi/SeventvEventAPIDispatch.hpp"
+
+namespace chatterino {
+
+SeventvEventAPIDispatch::SeventvEventAPIDispatch(QJsonObject obj)
+    : type(magic_enum::enum_cast<SeventvEventAPISubscriptionType>(
+               obj["type"].toString().toStdString())
+               .value_or(SeventvEventAPISubscriptionType::INVALID))
+    , body(obj["body"].toObject())
+    , id(this->body["id"].toString())
+    , actorName(this->body["actor"].toObject()["display_name"].toString())
+{
+}
+
+SeventvEventAPIEmoteAddDispatch::SeventvEventAPIEmoteAddDispatch(
+    const SeventvEventAPIDispatch &dispatch, QJsonObject emote)
+    : emoteSetID(dispatch.id)
+    , actorName(dispatch.actorName)
+    , emoteJson(std::move(emote))
+    , emoteID(this->emoteJson["id"].toString())
+{
+}
+
+bool SeventvEventAPIEmoteAddDispatch::validate() const
+{
+    bool validValues =
+        !this->emoteSetID.isEmpty() && !this->emoteJson.isEmpty();
+    if (!validValues)
+    {
+        return false;
+    }
+    bool validActiveEmote = this->emoteJson.contains("id") &&
+                            this->emoteJson.contains("name") &&
+                            this->emoteJson.contains("data");
+    if (!validActiveEmote)
+    {
+        return false;
+    }
+    auto emoteData = this->emoteJson["data"].toObject();
+    return emoteData.contains("name") && emoteData.contains("host") &&
+           emoteData.contains("owner");
+}
+
+SeventvEventAPIEmoteRemoveDispatch::SeventvEventAPIEmoteRemoveDispatch(
+    const SeventvEventAPIDispatch &dispatch, QJsonObject emote)
+    : emoteSetID(dispatch.id)
+    , actorName(dispatch.actorName)
+    , emoteName(emote["name"].toString())
+    , emoteID(emote["id"].toString())
+{
+}
+
+bool SeventvEventAPIEmoteRemoveDispatch::validate() const
+{
+    return !this->emoteSetID.isEmpty() && !this->emoteName.isEmpty() &&
+           !this->emoteID.isEmpty();
+}
+
+SeventvEventAPIEmoteUpdateDispatch::SeventvEventAPIEmoteUpdateDispatch(
+    const SeventvEventAPIDispatch &dispatch, QJsonObject oldValue,
+    QJsonObject value)
+    : emoteSetID(dispatch.id)
+    , actorName(dispatch.actorName)
+    , emoteID(value["id"].toString())
+    , oldEmoteName(oldValue["name"].toString())
+    , emoteName(value["name"].toString())
+{
+}
+
+bool SeventvEventAPIEmoteUpdateDispatch::validate() const
+{
+    return !this->emoteSetID.isEmpty() && !this->emoteID.isEmpty() &&
+           !this->oldEmoteName.isEmpty() && !this->emoteName.isEmpty() &&
+           this->oldEmoteName != this->emoteName;
+}
+
+SeventvEventAPIUserConnectionUpdateDispatch::
+    SeventvEventAPIUserConnectionUpdateDispatch(
+        const SeventvEventAPIDispatch &dispatch, const QJsonObject &update,
+        size_t connectionIndex)
+    : userID(dispatch.id)
+    , actorName(dispatch.actorName)
+    , oldEmoteSetID(update["old_value"].toObject()["id"].toString())
+    , emoteSetID(update["value"].toObject()["id"].toString())
+    , connectionIndex(connectionIndex)
+{
+}
+
+bool SeventvEventAPIUserConnectionUpdateDispatch::validate() const
+{
+    return !this->userID.isEmpty() && !this->oldEmoteSetID.isEmpty() &&
+           !this->emoteSetID.isEmpty();
+}
+
+}  // namespace chatterino
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "providers/seventv/eventapi/SeventvEventAPISubscription.hpp"
+
+#include <QJsonObject>
+#include <QString>
+
+namespace chatterino {
+
+// https://github.com/SevenTV/EventAPI/tree/ca4ff15cc42b89560fa661a76c5849047763d334#message-payload
+struct SeventvEventAPIDispatch {
+    SeventvEventAPISubscriptionType type;
+    QJsonObject body;
+    QString id;
+    // it's okay for this to be empty
+    QString actorName;
+
+    SeventvEventAPIDispatch(QJsonObject obj);
+};
+
+struct SeventvEventAPIEmoteAddDispatch {
+    QString emoteSetID;
+    QString actorName;
+    QJsonObject emoteJson;
+    QString emoteID;
+
+    SeventvEventAPIEmoteAddDispatch(const SeventvEventAPIDispatch &dispatch,
+                                    QJsonObject emote);
+
+    bool validate() const;
+};
+
+struct SeventvEventAPIEmoteRemoveDispatch {
+    QString emoteSetID;
+    QString actorName;
+    QString emoteName;
+    QString emoteID;
+
+    SeventvEventAPIEmoteRemoveDispatch(const SeventvEventAPIDispatch &dispatch,
+                                       QJsonObject emote);
+
+    bool validate() const;
+};
+
+struct SeventvEventAPIEmoteUpdateDispatch {
+    QString emoteSetID;
+    QString actorName;
+    QString emoteID;
+    QString oldEmoteName;
+    QString emoteName;
+
+    SeventvEventAPIEmoteUpdateDispatch(const SeventvEventAPIDispatch &dispatch,
+                                       QJsonObject oldValue, QJsonObject value);
+
+    bool validate() const;
+};
+
+struct SeventvEventAPIUserConnectionUpdateDispatch {
+    QString userID;
+    QString actorName;
+    QString oldEmoteSetID;
+    QString emoteSetID;
+    size_t connectionIndex;
+
+    SeventvEventAPIUserConnectionUpdateDispatch(
+        const SeventvEventAPIDispatch &dispatch, const QJsonObject &update,
+        size_t connectionIndex);
+
+    bool validate() const;
+};
+
+}  // namespace chatterino
@@ -0,0 +1,11 @@
+#include "providers/seventv/eventapi/SeventvEventAPIMessage.hpp"
+
+namespace chatterino {
+
+SeventvEventAPIMessage::SeventvEventAPIMessage(QJsonObject _json)
+    : data(_json["d"].toObject())
+    , op(SeventvEventAPIOpcode(_json["op"].toInt()))
+{
+}
+
+}  // namespace chatterino
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "providers/seventv/SeventvEventAPI.hpp"
+
+#include <boost/optional.hpp>
+#include <magic_enum.hpp>
+
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QString>
+
+namespace chatterino {
+
+struct SeventvEventAPIMessage {
+    QJsonObject data;
+
+    SeventvEventAPIOpcode op;
+
+    SeventvEventAPIMessage(QJsonObject _json);
+
+    template <class InnerClass>
+    boost::optional<InnerClass> toInner();
+};
+
+template <class InnerClass>
+boost::optional<InnerClass> SeventvEventAPIMessage::toInner()
+{
+    return InnerClass{this->data};
+}
+
+static boost::optional<SeventvEventAPIMessage> parseSeventvEventAPIBaseMessage(
+    const QString &blob)
+{
+    QJsonDocument jsonDoc(QJsonDocument::fromJson(blob.toUtf8()));
+
+    if (jsonDoc.isNull())
+    {
+        return boost::none;
+    }
+
+    return SeventvEventAPIMessage(jsonDoc.object());
+}
+
+}  // namespace chatterino
@@ -0,0 +1,77 @@
+#include "providers/seventv/eventapi/SeventvEventAPISubscription.hpp"
+
+#include <QJsonDocument>
+#include <QJsonObject>
+
+namespace {
+
+using namespace chatterino;
+
+const char *typeToString(SeventvEventAPISubscriptionType type)
+{
+    switch (type)
+    {
+        case SeventvEventAPISubscriptionType::UpdateEmoteSet:
+            return "emote_set.update";
+        case SeventvEventAPISubscriptionType::UpdateUser:
+            return "user.update";
+        default:
+            return "";
+    }
+}
+
+QJsonObject createDataJson(const char *typeName, const QString &condition)
+{
+    QJsonObject data;
+    data["type"] = typeName;
+    {
+        QJsonObject conditionObj;
+        conditionObj["object_id"] = condition;
+        data["condition"] = conditionObj;
+    }
+    return data;
+}
+
+}  // namespace
+
+namespace chatterino {
+
+bool SeventvEventAPISubscription::operator==(
+    const SeventvEventAPISubscription &rhs) const
+{
+    return std::tie(this->condition, this->type) ==
+           std::tie(rhs.condition, rhs.type);
+}
+
+bool SeventvEventAPISubscription::operator!=(
+    const SeventvEventAPISubscription &rhs) const
+{
+    return !(rhs == *this);
+}
+
+QByteArray SeventvEventAPISubscription::encodeSubscribe() const
+{
+    const auto *typeName = typeToString(this->type);
+    QJsonObject root;
+    root["op"] = (int)SeventvEventAPIOpcode::Subscribe;
+    root["d"] = createDataJson(typeName, this->condition);
+    return QJsonDocument(root).toJson();
+}
+
+QByteArray SeventvEventAPISubscription::encodeUnsubscribe() const
+{
+    const auto *typeName = typeToString(this->type);
+    QJsonObject root;
+    root["op"] = (int)SeventvEventAPIOpcode::Unsubscribe;
+    root["d"] = createDataJson(typeName, this->condition);
+    return QJsonDocument(root).toJson();
+}
+
+QDebug &operator<<(QDebug &dbg, const SeventvEventAPISubscription &subscription)
+{
+    dbg << "SeventvEventAPISubscription{ condition:" << subscription.condition
+        << "type:" << (int)subscription.type << '}';
+    return dbg;
+}
+
+}  // namespace chatterino
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <magic_enum.hpp>
+
+#include <QByteArray>
+#include <QHash>
+#include <QString>
+
+namespace chatterino {
+
+// https://github.com/SevenTV/EventAPI/tree/ca4ff15cc42b89560fa661a76c5849047763d334#subscription-types
+enum class SeventvEventAPISubscriptionType {
+    UpdateEmoteSet,
+    UpdateUser,
+
+    INVALID,
+};
+
+// https://github.com/SevenTV/EventAPI/tree/ca4ff15cc42b89560fa661a76c5849047763d334#opcodes
+enum class SeventvEventAPIOpcode {
+    Dispatch = 0,
+    Hello = 1,
+    Heartbeat = 2,
+    Reconnect = 4,
+    Ack = 5,
+    Error = 6,
+    EndOfStream = 7,
+    Identify = 33,
+    Resume = 34,
+    Subscribe = 35,
+    Unsubscribe = 36,
+    Signal = 37,
+};
+
+struct SeventvEventAPISubscription {
+    bool operator==(const SeventvEventAPISubscription &rhs) const;
+    bool operator!=(const SeventvEventAPISubscription &rhs) const;
+    QString condition;
+    SeventvEventAPISubscriptionType type;
+
+    QByteArray encodeSubscribe() const;
+    QByteArray encodeUnsubscribe() const;
+
+    friend QDebug &operator<<(QDebug &dbg,
+                              const SeventvEventAPISubscription &subscription);
+};
+
+}  // namespace chatterino
+
+template <>
+constexpr magic_enum::customize::customize_t magic_enum::customize::enum_name<
+    chatterino::SeventvEventAPISubscriptionType>(
+    chatterino::SeventvEventAPISubscriptionType value) noexcept
+{
+    switch (value)
+    {
+        case chatterino::SeventvEventAPISubscriptionType::UpdateEmoteSet:
+            return "emote_set.update";
+        case chatterino::SeventvEventAPISubscriptionType::UpdateUser:
+            return "user.update";
+
+        default:
+            return default_tag;
+    }
+}
+
+namespace std {
+
+template <>
+struct hash<chatterino::SeventvEventAPISubscription> {
+    size_t operator()(const chatterino::SeventvEventAPISubscription &sub) const
+    {
+        return (size_t)qHash(sub.condition, qHash((int)sub.type));
+    }
+};
+
+}  // namespace std