- add ability to add activities to discord

- fixed a few discord bugs, some of them were really bogus, but the discord sdk isn't that stable (the c lib and the cpp wrapper)

Author: Totto16

src/application.cpp

@@ -1,7 +1,9 @@
 #include "application.hpp"
+#include "discord/core.hpp"
 #include "helper/sleep.hpp"
 #include "platform/capabilities.hpp"
 #include "scenes/scene.hpp"
+#include "types.h"
 
 #include <ranges>
 
@@ -56,6 +58,12 @@ void Application::run() {
         spdlog::warn("Error initializing the discord instance, it might not be running: {}", discord_instance.error());
     } else {
         m_discord_instance = std::move(discord_instance.value());
+        m_discord_instance->after_setup();
+
+        m_discord_instance->set_activity(
+                DiscordActivityWrapper("Selecting playmode", discord::ActivityType::Playing)
+                        .add_large_image("Playing OOPetris", constants::discord::ArtAsset::logo)
+        );
     }
 
 #endif
@@ -211,6 +219,14 @@ void Application::update() {
             break;
         }
     }
+
+#if defined(_HAVE_DISCORD_SDK)
+
+    if (m_discord_instance.has_value()) {
+        m_discord_instance->update();
+    }
+
+#endif
 }
 
 void Application::render() const {

src/discord/core.cpp

@@ -2,27 +2,46 @@
 
 #include "core.hpp"
 #include "helper/magic_enum_wrapper.hpp"
+#include "helper/utils.hpp"
 #include "types.h"
 
 #include <fmt/format.h>
 #include <spdlog/spdlog.h>
 
-DiscordInstance::DiscordInstance(discord::Core* core) : m_core{ core }, m_current_user{} {
 
+[[nodiscard]] std::string constants::discord ::get_asset_key(constants::discord::ArtAsset asset) {
 
+    switch (asset) {
+        case ArtAsset::logo:
+            return "logo";
+        default:
+            utils::unreachable();
+    }
+}
+
+DiscordInstance::DiscordInstance(discord::Core* core) : m_core{ core }, m_current_user{ nullptr } { }
+
+void DiscordInstance::after_setup() {
     m_core->UserManager().OnCurrentUserUpdate.Connect([this]() {
-        this->m_current_user = std::make_unique<discord::User>();
-        this->m_core->UserManager().GetCurrentUser(this->m_current_user.get());
+        auto* user = new discord::User; // NOLINT(cppcoreguidelines-owning-memory)
+        this->m_core->UserManager().GetCurrentUser(user);
+        this->m_current_user.reset(user);
+        spdlog::info(
+                "Current user updated: {}#{}", this->m_current_user->GetUsername(),
+                this->m_current_user->GetDiscriminator()
+        );
     });
 
-
-    m_core->ActivityManager().RegisterCommand(constants::discord::platform_dependent_launch_arguments);
+    auto result = m_core->ActivityManager().RegisterCommand(constants::discord::platform_dependent_launch_arguments);
+    if (result != discord::Result::Ok) {
+        spdlog::warn("ActivityManager: Failed to RegisterCommand: {}", magic_enum::enum_name(result));
+    };
 }
 
 [[nodiscard]] helper::expected<DiscordInstance, std::string> DiscordInstance::initialize() {
 
     discord::Core* core{};
-    auto result = discord::Core::Create(constants::discord::client_id, DiscordCreateFlags_NoRequireDiscord, &core);
+    auto result = discord::Core::Create(constants::discord::client_id, DiscordCreateFlags_Default, &core);
     if (core == nullptr) {
         return helper::unexpected<std::string>{
             fmt::format("Failed to instantiate discord core: {}", magic_enum::enum_name(result))
@@ -59,6 +78,96 @@ DiscordInstance::DiscordInstance(discord::Core* core) : m_core{ core }, m_curren
 }
 
 
+DiscordInstance::DiscordInstance(DiscordInstance&& old) noexcept
+    : m_core{ std::move(old.m_core) },
+      m_current_user{ std::move(old.m_current_user) } {
+    old.m_core = nullptr;
+    old.m_current_user = nullptr;
+}
+
+
+DiscordInstance& DiscordInstance::operator=(DiscordInstance&& other) noexcept {
+    if (this != &other) {
+
+        m_core = std::move(other.m_core);
+        m_current_user = std::move(other.m_current_user);
+
+        other.m_core = nullptr;
+        other.m_current_user = nullptr;
+    }
+    return *this;
+};
+
+DiscordInstance::~DiscordInstance() {
+    if (m_core != nullptr) {
+        clear_activity();
+    }
+}
+
 void DiscordInstance::update() {
     m_core->RunCallbacks();
 }
+
+
+void DiscordInstance::set_activity(const DiscordActivityWrapper& activity) {
+
+    m_core->ActivityManager().UpdateActivity(activity.get_raw(), [](discord::Result result) {
+        spdlog::info("Result to UpdateActivity: {}", magic_enum::enum_name(result));
+    });
+}
+
+
+void DiscordInstance::clear_activity(bool wait) {
+    bool received_callback = false;
+    m_core->ActivityManager().ClearActivity([&received_callback](discord::Result result) {
+        spdlog::info("Result to ClearActivity: {}", magic_enum::enum_name(result));
+        received_callback = true;
+    });
+
+    if (wait) {
+        while (not received_callback) {
+            this->update();
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+    }
+}
+
+
+DiscordActivityWrapper::DiscordActivityWrapper(const std::string& details, discord::ActivityType type) {
+
+
+    m_activity.SetDetails(details.c_str());
+    m_activity.SetType(type);
+}
+
+
+DiscordActivityWrapper&
+DiscordActivityWrapper::add_large_image(const std::string& text, constants::discord::ArtAsset asset) {
+    m_activity.GetAssets().SetLargeText(text.c_str());
+
+    const auto asset_key = constants::discord::get_asset_key(asset);
+    m_activity.GetAssets().SetLargeImage(asset_key.c_str());
+
+    return *this;
+}
+
+
+DiscordActivityWrapper&
+DiscordActivityWrapper::add_small_image(const std::string& text, constants::discord::ArtAsset asset) {
+    m_activity.GetAssets().SetSmallText(text.c_str());
+
+    const auto asset_key = constants::discord::get_asset_key(asset);
+    m_activity.GetAssets().SetSmallImage(asset_key.c_str());
+    return *this;
+}
+
+DiscordActivityWrapper& DiscordActivityWrapper::set_details(const std::string& text) {
+    m_activity.SetState(text.c_str());
+
+    return *this;
+}
+
+
+[[nodiscard]] const discord::Activity& DiscordActivityWrapper::get_raw() const {
+    return m_activity;
+}

src/discord/core.hpp

@@ -28,8 +28,31 @@ namespace constants::discord {
 #error "Unsupported platform"
 #endif
 
+    // manually synchronized to https://discord.com/developers/applications/1220147916371394650/rich-presence/assets
+    enum class ArtAsset { logo };
+
+    [[nodiscard]] std::string get_asset_key(ArtAsset asset);
+
+
 } // namespace constants::discord
 
+
+struct DiscordActivityWrapper {
+private:
+    discord::Activity m_activity{};
+
+public:
+    //TODO: Add support for party and invites / join / invitations / spectate
+
+    DiscordActivityWrapper(const std::string& details, discord::ActivityType type);
+
+    DiscordActivityWrapper& add_large_image(const std::string& text, constants::discord::ArtAsset asset);
+    DiscordActivityWrapper& add_small_image(const std::string& text, constants::discord::ArtAsset asset);
+    DiscordActivityWrapper& set_details(const std::string& text);
+
+    [[nodiscard]] const discord::Activity& get_raw() const;
+};
+
 struct DiscordInstance {
 private:
     std::unique_ptr<discord::Core> m_core;
@@ -40,5 +63,16 @@ struct DiscordInstance {
 public:
     [[nodiscard]] static helper::expected<DiscordInstance, std::string> initialize();
 
+    void after_setup();
+
+    DiscordInstance(DiscordInstance&& old) noexcept;
+    DiscordInstance& operator=(DiscordInstance&& other) noexcept;
+
+    ~DiscordInstance();
+
     void update();
+    void set_activity(const DiscordActivityWrapper& activity);
+
+private:
+    void clear_activity(bool wait = true);
 };