Discord integration

.gitignore

@@ -28,3 +28,4 @@ debian/jellyfin-media-player.substvars
 dist.zip
 obj-x86_64-linux-gnu/
 deployment/dist
+.vscode/

bundle/win/Bundle.wxs

@@ -246,7 +246,7 @@
         <MsiProperty Name="ADDDESKTOPSHORTCUT" Value="[AddDesktopShortcut]" />
       </MsiPackage>
       <ExePackage Id="vcredist_repair"
-                  SourceFile="C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Redist\MSVC\v142\vcredist_x64.exe"
+                  SourceFile="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Redist\MSVC\v142\vcredist_x64.exe"
                   Name="vcredist_x64.exe"
                   InstallCommand="/repair /quiet /norestart"
                   InstallCondition="Bad_VCRedist"
@@ -256,7 +256,7 @@
         <ExitCode Value="1638" Behavior="success"/>
       </ExePackage>
       <ExePackage Id="vcredist"
-                  SourceFile="C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Redist\MSVC\v142\vcredist_x64.exe"
+                  SourceFile="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Redist\MSVC\v142\vcredist_x64.exe"
                   Name="vcredist_x64.exe"
                   InstallCommand="/install /quiet /norestart"
                   InstallCondition="NOT Bad_VCRedist"

external/CMakeLists.txt

@@ -3,6 +3,7 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMPILER_FLAGS_THIRD_PARTY}")
 
 add_subdirectory(qslog)
 add_subdirectory(qhttp)
+add_subdirectory(discord)
 
 if(APPLE)
   add_subdirectory(plistparser)

external/discord/CMakeLists.txt

@@ -0,0 +1,13 @@
+include_directories(.)
+
+file(GLOB DISCORD_SRC
+     "*.h"
+     "*.cpp"
+)
+
+add_library(discord STATIC
+  ${DISCORD_SRC}
+)
+# add_library(discord discord_game_sdk.dll.lib)
+target_link_libraries(discord D:/Projects/jellyfin-media-player/external/discord/discord_game_sdk.dll.lib)
+set_target_properties(discord PROPERTIES LINKER_LANGUAGE C)

external/discord/achievement_manager.cpp

@@ -0,0 +1,99 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "achievement_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class AchievementEvents final {
+public:
+    static void DISCORD_CALLBACK OnUserAchievementUpdate(void* callbackData,
+                                                         DiscordUserAchievement* userAchievement)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->AchievementManager();
+        module.OnUserAchievementUpdate(*reinterpret_cast<UserAchievement const*>(userAchievement));
+    }
+};
+
+IDiscordAchievementEvents AchievementManager::events_{
+  &AchievementEvents::OnUserAchievementUpdate,
+};
+
+void AchievementManager::SetUserAchievement(Snowflake achievementId,
+                                            std::uint8_t percentComplete,
+                                            std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->set_user_achievement(
+      internal_, achievementId, percentComplete, cb.release(), wrapper);
+}
+
+void AchievementManager::FetchUserAchievements(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->fetch_user_achievements(internal_, cb.release(), wrapper);
+}
+
+void AchievementManager::CountUserAchievements(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->count_user_achievements(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result AchievementManager::GetUserAchievement(Snowflake userAchievementId,
+                                              UserAchievement* userAchievement)
+{
+    if (!userAchievement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_user_achievement(
+      internal_, userAchievementId, reinterpret_cast<DiscordUserAchievement*>(userAchievement));
+    return static_cast<Result>(result);
+}
+
+Result AchievementManager::GetUserAchievementAt(std::int32_t index,
+                                                UserAchievement* userAchievement)
+{
+    if (!userAchievement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_user_achievement_at(
+      internal_, index, reinterpret_cast<DiscordUserAchievement*>(userAchievement));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord

external/discord/achievement_manager.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class AchievementManager final {
+public:
+    ~AchievementManager() = default;
+
+    void SetUserAchievement(Snowflake achievementId,
+                            std::uint8_t percentComplete,
+                            std::function<void(Result)> callback);
+    void FetchUserAchievements(std::function<void(Result)> callback);
+    void CountUserAchievements(std::int32_t* count);
+    Result GetUserAchievement(Snowflake userAchievementId, UserAchievement* userAchievement);
+    Result GetUserAchievementAt(std::int32_t index, UserAchievement* userAchievement);
+
+    Event<UserAchievement const&> OnUserAchievementUpdate;
+
+private:
+    friend class Core;
+
+    AchievementManager() = default;
+    AchievementManager(AchievementManager const& rhs) = delete;
+    AchievementManager& operator=(AchievementManager const& rhs) = delete;
+    AchievementManager(AchievementManager&& rhs) = delete;
+    AchievementManager& operator=(AchievementManager&& rhs) = delete;
+
+    IDiscordAchievementManager* internal_;
+    static IDiscordAchievementEvents events_;
+};
+
+} // namespace discord

external/discord/activity_manager.cpp

@@ -0,0 +1,177 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "activity_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class ActivityEvents final {
+public:
+    static void DISCORD_CALLBACK OnActivityJoin(void* callbackData, char const* secret)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityJoin(static_cast<const char*>(secret));
+    }
+
+    static void DISCORD_CALLBACK OnActivitySpectate(void* callbackData, char const* secret)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivitySpectate(static_cast<const char*>(secret));
+    }
+
+    static void DISCORD_CALLBACK OnActivityJoinRequest(void* callbackData, DiscordUser* user)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityJoinRequest(*reinterpret_cast<User const*>(user));
+    }
+
+    static void DISCORD_CALLBACK OnActivityInvite(void* callbackData,
+                                                  EDiscordActivityActionType type,
+                                                  DiscordUser* user,
+                                                  DiscordActivity* activity)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityInvite(static_cast<ActivityActionType>(type),
+                                *reinterpret_cast<User const*>(user),
+                                *reinterpret_cast<Activity const*>(activity));
+    }
+};
+
+IDiscordActivityEvents ActivityManager::events_{
+  &ActivityEvents::OnActivityJoin,
+  &ActivityEvents::OnActivitySpectate,
+  &ActivityEvents::OnActivityJoinRequest,
+  &ActivityEvents::OnActivityInvite,
+};
+
+Result ActivityManager::RegisterCommand(char const* command)
+{
+    auto result = internal_->register_command(internal_, const_cast<char*>(command));
+    return static_cast<Result>(result);
+}
+
+Result ActivityManager::RegisterSteam(std::uint32_t steamId)
+{
+    auto result = internal_->register_steam(internal_, steamId);
+    return static_cast<Result>(result);
+}
+
+void ActivityManager::UpdateActivity(Activity const& activity, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->update_activity(internal_,
+                               reinterpret_cast<DiscordActivity*>(const_cast<Activity*>(&activity)),
+                               cb.release(),
+                               wrapper);
+}
+
+void ActivityManager::ClearActivity(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->clear_activity(internal_, cb.release(), wrapper);
+}
+
+void ActivityManager::SendRequestReply(UserId userId,
+                                       ActivityJoinRequestReply reply,
+                                       std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->send_request_reply(internal_,
+                                  userId,
+                                  static_cast<EDiscordActivityJoinRequestReply>(reply),
+                                  cb.release(),
+                                  wrapper);
+}
+
+void ActivityManager::SendInvite(UserId userId,
+                                 ActivityActionType type,
+                                 char const* content,
+                                 std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->send_invite(internal_,
+                           userId,
+                           static_cast<EDiscordActivityActionType>(type),
+                           const_cast<char*>(content),
+                           cb.release(),
+                           wrapper);
+}
+
+void ActivityManager::AcceptInvite(UserId userId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->accept_invite(internal_, userId, cb.release(), wrapper);
+}
+
+} // namespace discord