c++ - 如何将 cpp dll 加载到 kotlin 本机

Question

我现在正在学习 cpp 和 Kotlin，并且我有 cpp sdk。我需要从 kotlin 调用它，我应该为此做什么？我试图将它编译为dll并加载它，但不明白加载后如何使用库......

库的 Cpp 主标题：

#pragma once

#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
#include <map>

#include <functional>

#include <locale>
#include <codecvt>

#include "Entity.hpp"

#include "Pools.hpp"

#ifdef _WIN32
#define API extern "C" __declspec(dllexport) 
#else
#define API extern "C"
#endif

namespace sdk
{
    using removeEventHandler_t = std::function<void(IPlayer*, const args_t&)>;
    
    struct time_t
    {
        union
        {
            struct
            {
                uint8_t hour;
                uint8_t minute;
                uint8_t second;
            } a;
            uint32_t i;
        };
    };

    class IPlugin
    {
    public:
        static constexpr int sdkver = 0;

        virtual uint32_t GetVersion() { return sdkver; }
        virtual void Unload() { }
    };
    
    class IEntityHandler;
    class IPlayerHandler;
    class IVehicleHandler;
    class IColshapeHandler;
    class ICheckpointHandler;
    /*class IMarkerHandler;
    class IPickupHandler;*/
    class IBlipHandler;
    class IStreamerHandler;
    class ITickHandler;

    class IEventHandler
    {
    public:
        virtual IEntityHandler *GetEntityHandler() { return nullptr; }
        virtual IPlayerHandler *GetPlayerHandler() { return nullptr; }
        virtual IVehicleHandler *GetVehicleHandler() { return nullptr; }
        virtual IColshapeHandler *GetColshapeHandler() { return nullptr; }
        virtual ICheckpointHandler *GetCheckpointHandler() { return nullptr; }
        /*virtual IMarkerHandler *GetMarkerHandler() { return nullptr; }
        virtual IPickupHandler *GetPickupHandler() { return nullptr; }*/
        virtual IBlipHandler *GetBlipHandler() { return nullptr; }
        virtual IStreamerHandler *GetStreamerHandler() { return nullptr; }
        virtual ITickHandler *GetTickHandler() { return nullptr; }
    };

    class IEntityHandler
    {
    public:
        virtual void OnEntityCreated(IEntity *entity) { }
        virtual void OnEntityDestroyed(IEntity *entity) { }
        virtual void OnEntityModelChange(IEntity *entity, hash_t oldModel) { }
    };

    enum class exit_t : uint8_t
    {
        disconnect,
        timeout,
        kicked
    };

    class IPlayerHandler
    {
    public:
        virtual void OnPlayerJoin(IPlayer *player) { }
        virtual void OnPlayerReady(IPlayer *player) { }
        virtual void OnPlayerQuit(IPlayer *player, exit_t exitType, const char *reason) { }

        virtual void OnPlayerCommand(IPlayer *player, const std::u16string& command) { }
        virtual void OnPlayerChat(IPlayer *player, const std::u16string& text) { }

        virtual void OnPlayerDeath(IPlayer *player, hash_t reason, IPlayer *killer) { }
        virtual void OnPlayerSpawn(IPlayer *player) { }
        virtual void OnPlayerDamage(IPlayer *player, float healthLoss, float armorLoss) { }
        virtual void OnPlayerWeaponChange(IPlayer *player, hash_t oldWeapon, hash_t newWeapon) { }

        virtual void OnPlayerRemoteEvent(IPlayer *player, uint64_t eventNameHash, const args_t& args) { } // xxhash64

        virtual void OnPlayerStartEnterVehicle(IPlayer *player, IVehicle *vehicle, uint8_t seatId) { }
        virtual void OnPlayerEnterVehicle(IPlayer *player, IVehicle *vehicle, uint8_t seatId) { }
        virtual void OnPlayerStartExitVehicle(IPlayer *player, IVehicle *vehicle) { }
        virtual void OnPlayerExitVehicle(IPlayer *player, IVehicle *vehicle) { }
    };

    class IVehicleHandler
    {
    public:
        virtual void OnVehicleDeath(IVehicle *vehicle, hash_t hash, IPlayer *killer) { }
        virtual void OnVehicleSirenToggle(IVehicle *vehicle, bool toggle) { }
        virtual void OnVehicleHornToggle(IVehicle *vehicle, bool toggle) { }
        virtual void OnTrailerAttached(IVehicle *vehicle, IVehicle *trailer) { }
        virtual void OnVehicleDamage(IVehicle *vehicle, float bodyHealthLoss, float engineHealthLoss) { }
    };

    class IColshapeHandler
    {
    public:
        virtual void OnPlayerEnterColshape(IPlayer *player, IColshape *colshape) { }
        virtual void OnPlayerExitColshape(IPlayer *player, IColshape *colshape) { }
    };

    class ICheckpointHandler
    {
    public:
        virtual void OnPlayerEnterCheckpoint(IPlayer *player, ICheckpoint *checkpoint) { }
        virtual void OnPlayerExitCheckpoint(IPlayer *player, ICheckpoint *checkpoint) { }
    };

    /*class IMarkerHandler
    {
    public:
    };
    class IPickupHandler
    {
    public:
    };*/

    class IBlipHandler
    {
    public:
        virtual void OnPlayerCreateWaypoint(sdk::IPlayer *player, const vector3& position) { }
        virtual void OnPlayerReachWaypoint(sdk::IPlayer *player) { }
    };

    class IStreamerHandler
    {
    public:
        virtual void OnPlayerStreamIn(IPlayer *player, IPlayer *forplayer) { }
        virtual void OnPlayerStreamOut(IPlayer *player, IPlayer *forplayer) { }
    };

    class ITickHandler
    {
    public:
        virtual void Tick() { }
    };

    class IWorld
    {
    public:
        virtual time_t GetTime() = 0;
        virtual void SetTime(time_t time) = 0;
        virtual const std::string& GetWeather() = 0;
        virtual void SetWeather(const std::string& weather) = 0;
        virtual void SetWeatherTransition(const std::string& weather, float time = 0.5f) = 0;

        virtual void RequestIpl(const std::string& ipl) = 0;
        virtual void RemoveIpl(const std::string& ipl) = 0;

        virtual bool AreTrafficLightsLocked() = 0;
        virtual void LockTrafficLights(bool toggle) = 0;

        virtual int GetTrafficLightsState() = 0;
        virtual void SetTrafficLightsState(int state) = 0;
    };

    class IConfig
    {
    public:
        virtual int GetInt(const std::string& key, int def = 0) = 0;
        virtual std::string GetString(const std::string& key, const std::string& def = "") = 0;
    };

    class IMultiplayer
    {
    public:
        virtual void AddEventHandler(IEventHandler *handler) = 0;

        virtual void AddRemoteEventHandler(const std::string& eventName, removeEventHandler_t handler) = 0;

        virtual IPlayerPool& GetPlayerPool() = 0;
        virtual IVehiclePool& GetVehiclePool() = 0;
        virtual IColshapePool& GetColshapePool() = 0;
        virtual ICheckpointPool& GetCheckpointPool() = 0;
        virtual IMarkerPool& GetMarkerPool() = 0;
        virtual IBlipPool& GetBlipPool() = 0;
        virtual IPickupPool& GetPickupPool() = 0;
        virtual IObjectPool& GetObjectPool() = 0;
        virtual ITextLabelPool& GetLabelPool() = 0;
        virtual IWorld& GetWorld() = 0;
        virtual IConfig& GetConfig() = 0;
    };


    using initializeFunc_t = IPlugin*(
#ifdef _WIN32
    __cdecl
#endif
        *) (IMultiplayer *multiplayer);
}

我应该怎么做才能将 API 加载到 kotlin 本机中？kotlin 代码中有哪些定义？

这是一个如何与 cpp 一起使用的示例

#include <iostream>

#include "../sdk.hpp"

namespace gm
{
    class EventHandler
        : public sdk::IEventHandler,
        public sdk::IPlayerHandler,
        public sdk::ITickHandler
    {
    public:
        virtual sdk::ITickHandler *GetTickHandler() { return this; }
        virtual sdk::IPlayerHandler *GetPlayerHandler() { return this; }

        virtual void OnPlayerJoin(sdk::IPlayer *player) { std::cout << "Player: " << player->GetId() << std::endl; }

        virtual void Tick() { std::cout << "tick!!!!" << std::endl; }
    };
}

API sdk::IPlugin *InitializePlugin(sdk::IMultiplayer *mp)
{
    mp->AddEventHandler(new gm::EventHandler);
    return new sdk::IPlugin;
}

标签： c++kotlin-native