sdk_init_config.h

浏览该文件的文档.

 
#ifndef NEM_SDK_INTERFACE_DEFINE_SDK_INIT_CONFIG_H__
#define NEM_SDK_INTERFACE_DEFINE_SDK_INIT_CONFIG_H__
 
#include "public_define.h"
#include <string>
 
NNEM_SDK_INTERFACE_BEGIN_DECLS
 
class NEM_SDK_INTERFACE_EXPORT NEMAppInfo : public NEObject
{
public:
    NEMAppInfo() {
    }
 
    std::string SDKPath() const {
        return sdk_path_;
    }
 
    void SDKPath(const std::string& path) {
        sdk_path_ = path;
    }
 
    std::string OrganizationName() const {
        return organization_name_;
    }
 
    void OrganizationName(const std::string& organization_name) {
        organization_name_ = organization_name;
    }
 
    std::string ApplicationName() const {
        return application_name_;
    }
 
    void ApplicationName(const std::string& application_name) {
        application_name_ = application_name;
    }
 
    std::string ProductName() const {
        return product_name_;
    }
 
    void ProductName(const std::string& product_name) {
        product_name_ = product_name;
    }
private:
    std::string sdk_path_;          
    std::string organization_name_; 
    std::string application_name_;  
    std::string product_name_;      
};
 
enum NELogLevel {
    NEVERBOSE,
    NEDEBUG,
    NEINFO,
    NEWARNING,
    NEERROR,
};
 
class NEM_SDK_INTERFACE_EXPORT NELoggerConfig : public NEObject {
public:
    NELoggerConfig() {}
 
    std::string LoggerPath() const { return path_; }
 
    void LoggerPath(const std::string& path) { path_ = path; }
 
    NELogLevel LoggerLevel() const { return level_; }
 
    void LoggerLevel(NELogLevel level) { level_ = level; }
 
private:
    std::string path_;          
    NELogLevel level_ = NEINFO; 
};
 
class NEM_SDK_INTERFACE_EXPORT NEMeetingSDKConfig : public NEObject
{
public:
    NEMeetingSDKConfig() = default;
 
    NEMeetingSDKConfig(const std::string& strDomain)
        : domain(strDomain) {
    }
 
    NEMeetingSDKConfig(std::string&& strDomain)
        : domain(std::move(strDomain)) {
    }
 
public:
    NEMAppInfo* getAppInfo() const {
        return &appInfo;
    }
 
    std::string getAppKey() const {
        return appKey;
    }
 
    void setAppKey(const std::string& value) {
        appKey = value;
    }
 
    std::string getDomain() const {
        return domain;
    }
 
    void setDomain(const std::string& value) {
        domain = value;
    }
 
    bool getEnableDebugLog() const {
        return enableDebugLog;
    }
 
    void setEnableDebugLog(bool value) {
        enableDebugLog = value;
    }
 
    int getLogSize() const {
        return logSize;
    }
 
    void setLogSize(int value) {
        logSize = value;
    }
 
    bool getUseAssetServerConfig() const { 
        return useAssetServerConfig;
    }
 
    void setUseAssetServerConfig(bool bUse) {
        useAssetServerConfig = bUse;
    }
 
    int getKeepAliveInterval() const {
        return keepAliveInterval;
    }
 
    void setKeepAliveInterval(int interval) {
        keepAliveInterval = interval;
    }
 
    NELoggerConfig* getLoggerConfig() const { return &loggerConfig; }
 
    bool getRunAdmin() const { return runAdmin; }
 
    void setRunAdmin(bool admin) { runAdmin = admin; }
 
private:
    mutable NEMAppInfo appInfo;         
    std::string appKey;                 
    std::string domain;                 
    bool enableDebugLog = true;         
    int logSize = 10;                   
    bool useAssetServerConfig = false;  
    int keepAliveInterval = 10;         
    bool runAdmin = true;               
    mutable NELoggerConfig loggerConfig; 
};
 
NNEM_SDK_INTERFACE_END_DECLS
 
#endif // NEM_SDK_INTERFACE_DEFINE_SDK_INIT_CONFIG_H__