VAMPConnection.h

//
//  VAMPConnection.h
//  VAMPCocos2dx
//
//  Copyright © 2024年 Supership. All rights reserved.
//
 
#ifndef VAMPConnection_h
#define VAMPConnection_h
 
#include <memory>
#include <string>
#include <functional>
 
#define VAMP_COCOS2DX_PLUGIN_VERSION "5.1.1"
 
#define VAMP_UNKNOWN_COUNTRY_CODE "99"
 
// namespace vamp {}
#ifdef __cplusplus
#define NS_VAMP_BEGIN               namespace vamp {
#define NS_VAMP_END                 }
#define USING_NS_VAMP               using namespace vamp
#else
#define NS_VAMP_BEGIN
#define NS_VAMP_END
#define USING_NS_VAMP
#endif
 
NS_VAMP_BEGIN
 
    class VAMPListener;
 
    class Location;
 
    class Ad;
 
    struct Request;
 
    using GetLocationCallback = std::function<void(const Location &location)>;
    using UserConsentCallback = std::function<void(bool isRequired)>;
 
    namespace error {
        enum class Error {
            NotSupportedOsVersion = 0,
            Unknown,
            ServerError,
            NoAdnetwork,
            NeedConnection,
            MediationTimeout,
            UserCancel,
            NoAdStock,
            AdnetworkError,
            SettingError,
            NotLoaded,
            InvalidParameter,
            FrequencyCapped,
            RequestTimeout
        };
    }
 
    class VAMPCocosSDK {
    public:
        VAMPCocosSDK(const std::string &placementId);
 
        virtual ~VAMPCocosSDK();
 
        static void setTestMode(bool isTestEnabled);
 
        static bool isTestMode();
 
        static void setDebugMode(bool isDebugEnabled);
 
        static bool isDebugMode();
 
        static void setHyperIDMode(bool useHyperID);
 
        static bool useHyperID();
 
        static const std::string sdkVersion();
 
        static bool isSupportedOSVersion();
 
        static void getLocation(const GetLocationCallback callback);
 
        static void setRewardKey(const std::string &key);
 
        void preload(const Request &request);
 
        void load(const Request &request);
 
        bool isReady();
 
        void show();
 
        void setVAMPListener(VAMPListener *listener);
 
        class Impl;
 
    private:
        std::unique_ptr<Impl> impl_;
    }; // class VAMPCocosSDK
 
    class VAMPListener {
    public:
        virtual ~VAMPListener() {}
 
    public:
        virtual void onVampReceive(const Ad &ad) {};
 
        virtual void onVampOpen(const Ad &ad) {};
 
        virtual void onVampComplete(const Ad &ad) {};
 
        virtual void onVampClose(const Ad &ad, const bool adClicked) {};
 
        virtual void onVampFailedToLoad(const Ad &ad, const error::Error err) {};
 
        virtual void onVampFailedToShow(const Ad &ad, const error::Error err) {};
 
        virtual void onVampExpired(const std::string &placementId) {};
 
        virtual void onVampLoadStart(const Ad &ad) {};
 
        virtual void onVampLoadResult(const Ad &ad, const bool success,
                                      const std::string &msg) {};
    }; // class VAMPListener
 
    struct Location {
        std::string countryCode;
        std::string region;
    }; // struct Location
 
    struct Ad {
        std::string placementId;
        std::string adnwName;
        std::string seqId;
    }; // struct Ad
 
    struct Request {
        static const int REQUEST_TIMEOUT_DEFAULT_SEC = 60;
 
        int requestTimeout = REQUEST_TIMEOUT_DEFAULT_SEC;
    }; // struct Request
 
    namespace privacy {
        enum class ConsentStatus {
            Unknown = 0,
            Accepted,
            Denied
        }; // enum ConsentStatus
 
        enum class UnderAgeOfConsent {
            Unknown = 0,
            True,
            False
        }; // enum UnderAgeOfConsent
 
        class PrivacySettings {
        public:
            static void setUserConsent(ConsentStatus consentStatus);
 
            static void setChildDirected(bool childDirected);
 
            static void setUnderAgeOfConsent(UnderAgeOfConsent underAgeOfConsent);
 
            static void isEUAccess(const UserConsentCallback callback);
        }; // class PrivacySettings
    } // namespace privacy
 
NS_VAMP_END
 
#endif /* VAMPConnection_h */