rdiscord_sdk 1.1.0

data/third-party/include/lobby_manager.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class LobbyManager final {
+public:
+    ~LobbyManager() = default;
+
+    Result GetLobbyCreateTransaction(LobbyTransaction* transaction);
+    Result GetLobbyUpdateTransaction(LobbyId lobbyId, LobbyTransaction* transaction);
+    Result GetMemberUpdateTransaction(LobbyId lobbyId,
+                                      UserId userId,
+                                      LobbyMemberTransaction* transaction);
+    void CreateLobby(LobbyTransaction const& transaction,
+                     std::function<void(Result, Lobby const&)> callback);
+    void UpdateLobby(LobbyId lobbyId,
+                     LobbyTransaction const& transaction,
+                     std::function<void(Result)> callback);
+    void DeleteLobby(LobbyId lobbyId, std::function<void(Result)> callback);
+    void ConnectLobby(LobbyId lobbyId,
+                      LobbySecret secret,
+                      std::function<void(Result, Lobby const&)> callback);
+    void ConnectLobbyWithActivitySecret(LobbySecret activitySecret,
+                                        std::function<void(Result, Lobby const&)> callback);
+    void DisconnectLobby(LobbyId lobbyId, std::function<void(Result)> callback);
+    Result GetLobby(LobbyId lobbyId, Lobby* lobby);
+    Result GetLobbyActivitySecret(LobbyId lobbyId, char secret[128]);
+    Result GetLobbyMetadataValue(LobbyId lobbyId, MetadataKey key, char value[4096]);
+    Result GetLobbyMetadataKey(LobbyId lobbyId, std::int32_t index, char key[256]);
+    Result LobbyMetadataCount(LobbyId lobbyId, std::int32_t* count);
+    Result MemberCount(LobbyId lobbyId, std::int32_t* count);
+    Result GetMemberUserId(LobbyId lobbyId, std::int32_t index, UserId* userId);
+    Result GetMemberUser(LobbyId lobbyId, UserId userId, User* user);
+    Result GetMemberMetadataValue(LobbyId lobbyId,
+                                  UserId userId,
+                                  MetadataKey key,
+                                  char value[4096]);
+    Result GetMemberMetadataKey(LobbyId lobbyId, UserId userId, std::int32_t index, char key[256]);
+    Result MemberMetadataCount(LobbyId lobbyId, UserId userId, std::int32_t* count);
+    void UpdateMember(LobbyId lobbyId,
+                      UserId userId,
+                      LobbyMemberTransaction const& transaction,
+                      std::function<void(Result)> callback);
+    void SendLobbyMessage(LobbyId lobbyId,
+                          std::uint8_t* data,
+                          std::uint32_t dataLength,
+                          std::function<void(Result)> callback);
+    Result GetSearchQuery(LobbySearchQuery* query);
+    void Search(LobbySearchQuery const& query, std::function<void(Result)> callback);
+    void LobbyCount(std::int32_t* count);
+    Result GetLobbyId(std::int32_t index, LobbyId* lobbyId);
+    void ConnectVoice(LobbyId lobbyId, std::function<void(Result)> callback);
+    void DisconnectVoice(LobbyId lobbyId, std::function<void(Result)> callback);
+    Result ConnectNetwork(LobbyId lobbyId);
+    Result DisconnectNetwork(LobbyId lobbyId);
+    Result FlushNetwork();
+    Result OpenNetworkChannel(LobbyId lobbyId, std::uint8_t channelId, bool reliable);
+    Result SendNetworkMessage(LobbyId lobbyId,
+                              UserId userId,
+                              std::uint8_t channelId,
+                              std::uint8_t* data,
+                              std::uint32_t dataLength);
+
+    Event<std::int64_t> OnLobbyUpdate;
+    Event<std::int64_t, std::uint32_t> OnLobbyDelete;
+    Event<std::int64_t, std::int64_t> OnMemberConnect;
+    Event<std::int64_t, std::int64_t> OnMemberUpdate;
+    Event<std::int64_t, std::int64_t> OnMemberDisconnect;
+    Event<std::int64_t, std::int64_t, std::uint8_t*, std::uint32_t> OnLobbyMessage;
+    Event<std::int64_t, std::int64_t, bool> OnSpeaking;
+    Event<std::int64_t, std::int64_t, std::uint8_t, std::uint8_t*, std::uint32_t> OnNetworkMessage;
+
+private:
+    friend class Core;
+
+    LobbyManager() = default;
+    LobbyManager(LobbyManager const& rhs) = delete;
+    LobbyManager& operator=(LobbyManager const& rhs) = delete;
+    LobbyManager(LobbyManager&& rhs) = delete;
+    LobbyManager& operator=(LobbyManager&& rhs) = delete;
+
+    IDiscordLobbyManager* internal_;
+    static IDiscordLobbyEvents events_;
+};
+
+} // namespace discord

data/third-party/include/network_manager.cpp

@@ -0,0 +1,103 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "network_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class NetworkEvents final {
+public:
+    static void OnMessage(void* callbackData,
+                          DiscordNetworkPeerId peerId,
+                          DiscordNetworkChannelId channelId,
+                          uint8_t* data,
+                          uint32_t dataLength)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->NetworkManager();
+        module.OnMessage(peerId, channelId, data, dataLength);
+    }
+
+    static void OnRouteUpdate(void* callbackData, char const* routeData)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->NetworkManager();
+        module.OnRouteUpdate(static_cast<const char*>(routeData));
+    }
+};
+
+IDiscordNetworkEvents NetworkManager::events_{
+  &NetworkEvents::OnMessage,
+  &NetworkEvents::OnRouteUpdate,
+};
+
+void NetworkManager::GetPeerId(NetworkPeerId* peerId)
+{
+    if (!peerId) {
+        return;
+    }
+
+    internal_->get_peer_id(internal_, reinterpret_cast<uint64_t*>(peerId));
+}
+
+Result NetworkManager::Flush()
+{
+    auto result = internal_->flush(internal_);
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::OpenPeer(NetworkPeerId peerId, char const* routeData)
+{
+    auto result = internal_->open_peer(internal_, peerId, const_cast<char*>(routeData));
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::UpdatePeer(NetworkPeerId peerId, char const* routeData)
+{
+    auto result = internal_->update_peer(internal_, peerId, const_cast<char*>(routeData));
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::ClosePeer(NetworkPeerId peerId)
+{
+    auto result = internal_->close_peer(internal_, peerId);
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::OpenChannel(NetworkPeerId peerId, NetworkChannelId channelId, bool reliable)
+{
+    auto result = internal_->open_channel(internal_, peerId, channelId, (reliable ? 1 : 0));
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::CloseChannel(NetworkPeerId peerId, NetworkChannelId channelId)
+{
+    auto result = internal_->close_channel(internal_, peerId, channelId);
+    return static_cast<Result>(result);
+}
+
+Result NetworkManager::SendMessage(NetworkPeerId peerId,
+                                   NetworkChannelId channelId,
+                                   std::uint8_t* data,
+                                   std::uint32_t dataLength)
+{
+    auto result = internal_->send_message(
+      internal_, peerId, channelId, reinterpret_cast<uint8_t*>(data), dataLength);
+    return static_cast<Result>(result);
+}
+
+} // namespace discord

data/third-party/include/network_manager.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class NetworkManager final {
+public:
+    ~NetworkManager() = default;
+
+    /**
+     * Get the local peer ID for this process.
+     */
+    void GetPeerId(NetworkPeerId* peerId);
+    /**
+     * Send pending network messages.
+     */
+    Result Flush();
+    /**
+     * Open a connection to a remote peer.
+     */
+    Result OpenPeer(NetworkPeerId peerId, char const* routeData);
+    /**
+     * Update the route data for a connected peer.
+     */
+    Result UpdatePeer(NetworkPeerId peerId, char const* routeData);
+    /**
+     * Close the connection to a remote peer.
+     */
+    Result ClosePeer(NetworkPeerId peerId);
+    /**
+     * Open a message channel to a connected peer.
+     */
+    Result OpenChannel(NetworkPeerId peerId, NetworkChannelId channelId, bool reliable);
+    /**
+     * Close a message channel to a connected peer.
+     */
+    Result CloseChannel(NetworkPeerId peerId, NetworkChannelId channelId);
+    /**
+     * Send a message to a connected peer over an opened message channel.
+     */
+    Result SendMessage(NetworkPeerId peerId,
+                       NetworkChannelId channelId,
+                       std::uint8_t* data,
+                       std::uint32_t dataLength);
+
+    Event<NetworkPeerId, NetworkChannelId, std::uint8_t*, std::uint32_t> OnMessage;
+    Event<char const*> OnRouteUpdate;
+
+private:
+    friend class Core;
+
+    NetworkManager() = default;
+    NetworkManager(NetworkManager const& rhs) = delete;
+    NetworkManager& operator=(NetworkManager const& rhs) = delete;
+    NetworkManager(NetworkManager&& rhs) = delete;
+    NetworkManager& operator=(NetworkManager&& rhs) = delete;
+
+    IDiscordNetworkManager* internal_;
+    static IDiscordNetworkEvents events_;
+};
+
+} // namespace discord

data/third-party/include/overlay_manager.cpp

@@ -0,0 +1,112 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "overlay_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class OverlayEvents final {
+public:
+    static void OnToggle(void* callbackData, bool locked)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->OverlayManager();
+        module.OnToggle((locked != 0));
+    }
+};
+
+IDiscordOverlayEvents OverlayManager::events_{
+  &OverlayEvents::OnToggle,
+};
+
+void OverlayManager::IsEnabled(bool* enabled)
+{
+    if (!enabled) {
+        return;
+    }
+
+    internal_->is_enabled(internal_, reinterpret_cast<bool*>(enabled));
+}
+
+void OverlayManager::IsLocked(bool* locked)
+{
+    if (!locked) {
+        return;
+    }
+
+    internal_->is_locked(internal_, reinterpret_cast<bool*>(locked));
+}
+
+void OverlayManager::SetLocked(bool locked, 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_locked(internal_, (locked ? 1 : 0), cb.release(), wrapper);
+}
+
+void OverlayManager::OpenActivityInvite(ActivityActionType type,
+                                        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_->open_activity_invite(
+      internal_, static_cast<EDiscordActivityActionType>(type), cb.release(), wrapper);
+}
+
+void OverlayManager::OpenGuildInvite(char const* code, 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_->open_guild_invite(internal_, const_cast<char*>(code), cb.release(), wrapper);
+}
+
+void OverlayManager::OpenVoiceSettings(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_->open_voice_settings(internal_, cb.release(), wrapper);
+}
+
+} // namespace discord

data/third-party/include/overlay_manager.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class OverlayManager final {
+public:
+    ~OverlayManager() = default;
+
+    void IsEnabled(bool* enabled);
+    void IsLocked(bool* locked);
+    void SetLocked(bool locked, std::function<void(Result)> callback);
+    void OpenActivityInvite(ActivityActionType type, std::function<void(Result)> callback);
+    void OpenGuildInvite(char const* code, std::function<void(Result)> callback);
+    void OpenVoiceSettings(std::function<void(Result)> callback);
+
+    Event<bool> OnToggle;
+
+private:
+    friend class Core;
+
+    OverlayManager() = default;
+    OverlayManager(OverlayManager const& rhs) = delete;
+    OverlayManager& operator=(OverlayManager const& rhs) = delete;
+    OverlayManager(OverlayManager&& rhs) = delete;
+    OverlayManager& operator=(OverlayManager&& rhs) = delete;
+
+    IDiscordOverlayManager* internal_;
+    static IDiscordOverlayEvents events_;
+};
+
+} // namespace discord

data/third-party/include/relationship_manager.cpp

@@ -0,0 +1,90 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "relationship_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class RelationshipEvents final {
+public:
+    static void OnRefresh(void* callbackData)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->RelationshipManager();
+        module.OnRefresh();
+    }
+
+    static void OnRelationshipUpdate(void* callbackData, DiscordRelationship* relationship)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->RelationshipManager();
+        module.OnRelationshipUpdate(*reinterpret_cast<Relationship const*>(relationship));
+    }
+};
+
+IDiscordRelationshipEvents RelationshipManager::events_{
+  &RelationshipEvents::OnRefresh,
+  &RelationshipEvents::OnRelationshipUpdate,
+};
+
+void RelationshipManager::Filter(std::function<bool(Relationship const&)> filter)
+{
+    static auto wrapper = [](void* callbackData, DiscordRelationship* relationship) -> bool {
+        auto cb(reinterpret_cast<std::function<bool(Relationship const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return {};
+        }
+        return (*cb)(*reinterpret_cast<Relationship const*>(relationship));
+    };
+    std::unique_ptr<std::function<bool(Relationship const&)>> cb{};
+    cb.reset(new std::function<bool(Relationship const&)>(std::move(filter)));
+    internal_->filter(internal_, cb.get(), wrapper);
+}
+
+Result RelationshipManager::Count(std::int32_t* count)
+{
+    if (!count) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->count(internal_, reinterpret_cast<int32_t*>(count));
+    return static_cast<Result>(result);
+}
+
+Result RelationshipManager::Get(UserId userId, Relationship* relationship)
+{
+    if (!relationship) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get(internal_, userId, reinterpret_cast<DiscordRelationship*>(relationship));
+    return static_cast<Result>(result);
+}
+
+Result RelationshipManager::GetAt(std::uint32_t index, Relationship* relationship)
+{
+    if (!relationship) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->get_at(internal_, index, reinterpret_cast<DiscordRelationship*>(relationship));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord

data/third-party/include/relationship_manager.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class RelationshipManager final {
+public:
+    ~RelationshipManager() = default;
+
+    void Filter(std::function<bool(Relationship const&)> filter);
+    Result Count(std::int32_t* count);
+    Result Get(UserId userId, Relationship* relationship);
+    Result GetAt(std::uint32_t index, Relationship* relationship);
+
+    Event<> OnRefresh;
+    Event<Relationship const&> OnRelationshipUpdate;
+
+private:
+    friend class Core;
+
+    RelationshipManager() = default;
+    RelationshipManager(RelationshipManager const& rhs) = delete;
+    RelationshipManager& operator=(RelationshipManager const& rhs) = delete;
+    RelationshipManager(RelationshipManager&& rhs) = delete;
+    RelationshipManager& operator=(RelationshipManager&& rhs) = delete;
+
+    IDiscordRelationshipManager* internal_;
+    static IDiscordRelationshipEvents events_;
+};
+
+} // namespace discord

data/third-party/include/storage_manager.cpp

@@ -0,0 +1,158 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "storage_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+Result StorageManager::Read(char const* name,
+                            std::uint8_t* data,
+                            std::uint32_t dataLength,
+                            std::uint32_t* read)
+{
+    if (!read) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->read(internal_,
+                                  const_cast<char*>(name),
+                                  reinterpret_cast<uint8_t*>(data),
+                                  dataLength,
+                                  reinterpret_cast<uint32_t*>(read));
+    return static_cast<Result>(result);
+}
+
+void StorageManager::ReadAsync(char const* name,
+                               std::function<void(Result, std::uint8_t*, std::uint32_t)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, uint8_t* data, uint32_t dataLength) -> void {
+        std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb(
+          reinterpret_cast<std::function<void(Result, std::uint8_t*, std::uint32_t)>*>(
+            callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), data, dataLength);
+    };
+    std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb{};
+    cb.reset(new std::function<void(Result, std::uint8_t*, std::uint32_t)>(std::move(callback)));
+    internal_->read_async(internal_, const_cast<char*>(name), cb.release(), wrapper);
+}
+
+void StorageManager::ReadAsyncPartial(
+  char const* name,
+  std::uint64_t offset,
+  std::uint64_t length,
+  std::function<void(Result, std::uint8_t*, std::uint32_t)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, uint8_t* data, uint32_t dataLength) -> void {
+        std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb(
+          reinterpret_cast<std::function<void(Result, std::uint8_t*, std::uint32_t)>*>(
+            callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), data, dataLength);
+    };
+    std::unique_ptr<std::function<void(Result, std::uint8_t*, std::uint32_t)>> cb{};
+    cb.reset(new std::function<void(Result, std::uint8_t*, std::uint32_t)>(std::move(callback)));
+    internal_->read_async_partial(
+      internal_, const_cast<char*>(name), offset, length, cb.release(), wrapper);
+}
+
+Result StorageManager::Write(char const* name, std::uint8_t* data, std::uint32_t dataLength)
+{
+    auto result = internal_->write(
+      internal_, const_cast<char*>(name), reinterpret_cast<uint8_t*>(data), dataLength);
+    return static_cast<Result>(result);
+}
+
+void StorageManager::WriteAsync(char const* name,
+                                std::uint8_t* data,
+                                std::uint32_t dataLength,
+                                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_->write_async(internal_,
+                           const_cast<char*>(name),
+                           reinterpret_cast<uint8_t*>(data),
+                           dataLength,
+                           cb.release(),
+                           wrapper);
+}
+
+Result StorageManager::Delete(char const* name)
+{
+    auto result = internal_->delete_(internal_, const_cast<char*>(name));
+    return static_cast<Result>(result);
+}
+
+Result StorageManager::Exists(char const* name, bool* exists)
+{
+    if (!exists) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->exists(internal_, const_cast<char*>(name), reinterpret_cast<bool*>(exists));
+    return static_cast<Result>(result);
+}
+
+void StorageManager::Count(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->count(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result StorageManager::Stat(char const* name, FileStat* stat)
+{
+    if (!stat) {
+        return Result::InternalError;
+    }
+
+    auto result =
+      internal_->stat(internal_, const_cast<char*>(name), reinterpret_cast<DiscordFileStat*>(stat));
+    return static_cast<Result>(result);
+}
+
+Result StorageManager::StatAt(std::int32_t index, FileStat* stat)
+{
+    if (!stat) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->stat_at(internal_, index, reinterpret_cast<DiscordFileStat*>(stat));
+    return static_cast<Result>(result);
+}
+
+Result StorageManager::GetPath(char path[4096])
+{
+    if (!path) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_path(internal_, reinterpret_cast<DiscordPath*>(path));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord