kit_define_meeting_sdk.h

浏览该文件的文档.

// Copyright (c) 2022 NetEase, Inc. All rights reserved.
// Use of this source code is governed by a MIT license that can be
// found in the LICENSE file.
 
#ifndef NEM_SDK_INTERFACE_DEFINE_SDK_INIT_CONFIG_H__
#define NEM_SDK_INTERFACE_DEFINE_SDK_INIT_CONFIG_H__
 
#include <map>
#include <string>
#include "kit_define_meeting.h"
#include "kit_define_public.h"
 
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 NEExtraObject : public NEObject {
public:
    enum NEExtraObjectType {
        kNEExtraObjectString,
        kNEExtraObjectInt,
        kNEExtraObjectBool,
        kNEExtraObjectDouble,
    };
    NEExtraObject() {}
    NEExtraObject(const std::string& value) {
        type_ = kNEExtraObjectString;
        string_value_ = value;
    }
    NEExtraObject(int64_t value) {
        type_ = kNEExtraObjectInt;
        int_value_ = value;
    }
    NEExtraObject(bool value) {
        type_ = kNEExtraObjectBool;
        bool_value_ = value;
    }
    NEExtraObject(double value) {
        type_ = kNEExtraObjectDouble;
        double_value_ = value;
    }
 
    NEExtraObjectType getType() const { return type_; }
 
    std::string getStringValue() const {
        if (type_ == kNEExtraObjectString) {
            return string_value_;
        }
        return "";
    }
 
    void setStringValue(const std::string& value) {
        type_ = kNEExtraObjectString;
        string_value_ = value;
    }
 
    int64_t getIntValue() const {
        if (type_ == kNEExtraObjectInt) {
            return int_value_;
        }
        return 0;
    }
 
    void setIntValue(int64_t value) {
        type_ = kNEExtraObjectInt;
        int_value_ = value;
    }
 
    bool getBoolValue() const {
        if (type_ == kNEExtraObjectBool) {
            return bool_value_;
        }
        return false;
    }
 
    void setBoolValue(bool value) {
        type_ = kNEExtraObjectBool;
        bool_value_ = value;
    }
 
    double getDoubleValue() const {
        if (type_ == kNEExtraObjectDouble) {
            return double_value_;
        }
        return 0.0;
    }
 
    void setDoubleValue(double value) {
        type_ = kNEExtraObjectDouble;
        double_value_ = value;
    }
 
private:
    NEExtraObjectType type_ = kNEExtraObjectString;
    std::string string_value_;
    int64_t int_value_ = 0;
    bool bool_value_ = false;
    double double_value_ = 0.0;
};
 
class NEM_SDK_INTERFACE_EXPORT NEMeetingKitConfig : public NEObject {
public:
    NEMeetingKitConfig() = default;
 
public:
    NEMAppInfo* getAppInfo() const { return &appInfo; }
 
    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; }
    std::string getAppKey() const { return appKey; }
 
    void setAppKey(const std::string& value) { appKey = value; }
 
    std::string getAppName() const { return appName; }
 
    void setAppName(const std::string& value) { appName = value; }
 
    bool getUseAssetServerConfig() const { return useAssetServerConfig; }
 
    void setUseAssetServerConfig(bool value) { useAssetServerConfig = value; }
 
    std::map<std::string, NEExtraObject> getExtras() const { return extras; }
 
    void setExtras(const std::map<std::string, NEExtraObject>& value) { extras = value; }
 
    void setLanguage(NEMeetingLanguage uiLanguage) { language = uiLanguage; }
 
    NEMeetingLanguage getLanguage() const { return language; }
 
    static std::string getLanguageString(NEMeetingLanguage lang) {
        switch (lang) {
            case NEMeetingLanguage::kNEAutomatic:
                return "*";
            case NEMeetingLanguage::kNEChinese:
                return "zh";
            case NEMeetingLanguage::kNEEnglish:
                return "en";
            case NEMeetingLanguage::kNEJapanese:
                return "ja";
            default:
                return "*";
        }
    }
 
    void setServerUrl(const std::string& url) { serverUrl = url; }
 
    std::string getServerUrl() const { return serverUrl; }
 
    void setCorpCode(const std::string& code) { corpCode = code; }
 
    std::string getCorpCode() const { return corpCode; }
 
    void setCorpEmail(const std::string& email) { corpEmail = email; }
 
    std::string getCorpEmail() const { return corpEmail; }
 
private:
    mutable NEMAppInfo appInfo;          
    int keepAliveInterval = 10;          
    mutable NELoggerConfig loggerConfig; 
    bool runAdmin = false; 
    std::string appKey;
    std::string appName;
    bool useAssetServerConfig = false;
    std::string broadcastAppGroup;
    std::map<std::string, NEExtraObject> extras;
    NEMeetingLanguage language;
    std::string serverUrl;
    std::string corpCode;
    std::string corpEmail;
};
 
class NEMeetingIdpInfo {
public:
    // 设置 id
    void setId(int64_t newId) { id = newId; }
 
    // 获取 id
    int64_t getId() const { return id; }
 
    // 设置 type
    void setType(int newType) { type = newType; }
 
    // 获取 type
    int getType() const { return type; }
 
    // 设置 name
    void setName(const std::string& newName) { name = newName; }
 
    // 获取 name
    std::string getName() const { return name; }
 
private:
    int64_t id;
    int type;
    std::string name;
};
class NEMeetingCorpInfo {
public:
    enum NEMeetingCorpSSOLevel {
        kNone,
 
        kOptional,
 
        kForce,
    };
    void setAppKey(const std::string& newAppKey) { appKey = newAppKey; }
 
    std::string getAppKey() const { return appKey; }
 
    void setCorpName(const std::string& newCorpName) { corpName = newCorpName; }
 
    std::string getCorpName() const { return corpName; }
 
    void setCorpCode(const std::string& newCorpCode) { corpCode = newCorpCode; }
 
    std::string getCorpCode() const { return corpCode; }
 
    void setSSOLevel(int newSSOLevel) { ssoLevel = newSSOLevel; }
 
    int getSSOLevel() const { return ssoLevel; }
 
    void setIdpList(const std::vector<NEMeetingIdpInfo>& newIdpList) { idpList = newIdpList; }
 
    std::vector<NEMeetingIdpInfo> getIdpList() const { return idpList; }
 
    void addIdp(const NEMeetingIdpInfo& idp) { idpList.push_back(idp); }
 
    void clearIdpList() { idpList.clear(); }
 
private:
    std::string appKey;
    std::string corpName;
    std::string corpCode;
    int ssoLevel = kNone;
    std::vector<NEMeetingIdpInfo> idpList;
};
 
typedef enum {
    kNEMeetingAppNoticeTipTypeUnknown,
    kNEMeetingAppNoticeTipTypeText,
    kNEMeetingAppNoticeTipTypeUrl,
} NEMeetingAppNoticeTipType;
 
// 应用消息提示结构
struct NEMeetingAppNoticeTip {
    std::string content;             // 应用消息提示内容
    std::string title;               // 应用消息内容
    std::string okBtnLabel;          // 确认按钮文案
    std::string url;                 // 跳转链接
    NEMeetingAppNoticeTipType type;  // 应用消息提示类型
    long time;                       // 截止时间
    bool enable;                     // 是否可用
};
 
// 公告提示结构
struct NEMeetingAppNoticeTips {
    std::vector<NEMeetingAppNoticeTip> tipsList;  // 应用消息提示列表
    long curTime;                                 // 当前时间
};
 
NNEM_SDK_INTERFACE_END_DECLS
 
#endif  // NEM_SDK_INTERFACE_DEFINE_SDK_INIT_CONFIG_H__