room_kit_interface.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 ROOM_KIT_INTERFACE_H
#define ROOM_KIT_INTERFACE_H
 
#include <memory>
#include <unordered_map>
 
#include "auth_service_interface.h"
#include "base_type_defines.h"
#include "message_service_interface.h"
#include "nos_service_interface.h"
#include "room_kit_listener.h"
#include "room_service_interface.h"
#include "extension_service_interface.h"
 
namespace neroom {
enum NELogLevel {
    NEVERBOSE,
    NEDEBUG,
    NEINFO,
    NEWARNING,
    NEERROR,
};
 
typedef struct tagNERoomKitServerConfig {
    std::string roomServer; 
    std::string lbsServer; 
} NERoomKitServerConfig;
 
typedef struct tagNEIMServerConfig {
    int handShakeType{0}; 
    int negoKeyNeca{1};                      
    int commNeca{1};                         
    std::string lbs;                         
    std::list<std::string> lbsBackupAddress; 
    std::string nosLbs;                      
    std::string link;     
    std::string linkIpv6; 
    std::string nosUploader; 
    std::string nosUploaderHost; 
    std::string negoKeyNecaKeyParta; 
    std::string negoKeyNecaKeyPartb{"10001"};       
    int negoKeyNecaKeyVersion = 0;                  
    std::string nosDownloader;                      
    std::vector<std::string> nosAccelerateHostList; 
    std::string nosAccelerate;                      
    std::string probeIpv4Url;                       
    std::string probeIpv6Url;                       
    std::list<std::string> httpDnsServerInterface;  
    bool httpsEnabled = true;
} NEIMServerConfig;
 
typedef struct tagNERtcServerConfig {
    std::string lbsServer;                
    std::string channelServer;            
    std::string statisticsServer;         
    std::string roomServer;               
    std::string compatServer;             
    std::string nosLbsServer;             
    std::string nosUploadSever;           
    std::string nosTokenServer;           
    std::string cloudProxyServer;         
    std::string websocketProxyServer;     
    std::string quicProxyServer;          
    std::string mediaProxyServer;         
    std::string statisticsDispatchServer; 
    std::string statisticsBackupServer;   
    bool useIPv6 = false;                 
} NERtcServerConfig;
 
typedef struct tagNEWhiteboardServerConfig {
    std::string webServer;          
    std::string roomServer;         
    std::string sdkLogNosServer;    
    std::string dataReportServer;   
    std::string directNosServer;    
    std::string mediaUploadServer;  
    std::string docTransServer;     
    std::string fontDownloadServer; 
} NEWhiteboardServerConfig;
 
typedef struct tagNEServerConfig {
    NERoomKitServerConfig roomKitServerConfig;       
    NEIMServerConfig imServerConfig;                 
    NERtcServerConfig rtcServerConfig;               
    NEWhiteboardServerConfig whiteboardServerConfig; 
} NEServerConfig;
 
typedef struct tagNEWhiteBoardAppConfig {
    bool nosAntiLeech = false;                              
    int nosAntiLeechExpire = 7200;                          
    std::string canvasBgColor = "rgba(255, 255, 255, 255)"; 
} NEWhiteBoardAppConfig;
 
typedef struct tagNERoomKitOptions {
    std::string appKey;                                  
    std::string logPath;                                 
    NELogLevel logLevel = NEINFO;                        
    bool reuseIM = false;                                
    bool useAssetServerConfig = false;                   
    bool useInternalVideoRender = false;                 
    bool supportColorSpace = false;
    NEServerConfig serverConfig;                         
    std::string serverUrl;                               
    std::unordered_map<std::string, std::string> extras; 
    NEWhiteBoardAppConfig whiteBoardAppConfig;           
} NERoomKitOptions;
 
typedef struct tagNEDomainItem {
    std::string domain = "";                                 
} NEDomainItem;
 
typedef struct tagNEDomainInfo {
    long ttl = 0;                                           
    long updateTime = 0;                                    
    int racingLimit = 0;                                    
    long switchTimeout = 0;                                 
    std::list<NEDomainItem> domainList;                 
} NEDomainInfo;
 
typedef struct tagNEDomainInfoResult {
    int code = 0;                                           
    std::string msg = "";                                    
    NEDomainInfo data;                                  
} NEDomainInfoResult;
 
class INERoomKit {
public:
    INERoomKit() = default;
 
    virtual ~INERoomKit() = default;
 
    virtual void initialize(const NERoomKitOptions& options, const NECallback<>& callback = NECallback<>()) = 0;
 
    virtual void release() = 0;
 
    virtual bool isInitialized() const = 0;
 
    virtual NESDKVersions getSdkVersions() const = 0;
 
    virtual int switchLanguage(NERoomLanguage language) = 0;
 
    virtual INEAuthService* getAuthService() = 0;
 
    virtual INERoomService* getRoomService() = 0;
 
    virtual INEMessageChannelService* getMessageChannelService() = 0;
 
    virtual INENosService* getNosService() = 0;
 
    virtual INEExtensionService* getExtensionService() = 0;
 
    virtual void uploadLog(const NECallback<std::string>& callback) = 0;
 
    virtual std::string getCurrentLogPath() = 0;
 
    virtual void addGlobalEventListener(INEGlobalEventListener* listener) = 0;
 
    virtual void removeGlobalEventListener(INEGlobalEventListener* listener) = 0;
 
    virtual void invokeMethod(const std::string& method, const std::string& parameters, const NECallback<>& callback) = 0;
 
    virtual std::string getDeviceId()  = 0;
 
    virtual NENetworkType getNetworkType() = 0;
 
    virtual int switchDomain(const std::string& domain) = 0;
 
    virtual NEDomainInfoResult getAvailableDomain(const std::string& appKey) = 0;
 
    virtual void writeLog(const std::string& moduleName, int level, const std::string& content) = 0;
};
 
#ifdef __cplusplus
extern "C" {
#endif
NEROOMKIT_INTERFACE_EXPORT INERoomKit* createNERoomKit();
 
NEROOMKIT_INTERFACE_EXPORT void destroyNERoomKit();
 
#ifdef __cplusplus
}
#endif
 
}  // namespace neroom
 
#endif  // ROOM_KIT_INTERFACE_H