ToolSuiteProxyDef.h

Go to the documentation of this file.

#pragma once
#include "ToolSuiteProxyPlatform.h"
#include <vector>
#include <string>
#include "ToolSuiteVectorInterface.h"
#include <functional>
 
namespace ZMToolSuiteProxy
{
    struct ZMToolSuiteProxyAuthContext {
        const zchar_t* accessToken = nullptr;
        const zchar_t* domain = nullptr;
    };
 
    enum ZMToolSuiteProxyAuthResult {
        AUTH_RESULT_SUCCESS,
        AUTH_RESULT_REQUEST_ERROR,
        AUTH_RESULT_VERIFY_USER_FAILED,
        AUTH_RESULT_FAILED //Tips: add error scene desc.
    };
 
    enum ZMToolSuiteProxyErrors
    {
        kZMToolSuiteProxyErrorsUnknown,
        kZMToolSuiteProxyErrorsSuccess,
        kZMToolSuiteProxyErrorsNotImplemented,
        kZMToolSuiteProxyErrorsWrongUsage,
        kZMToolSuiteProxyErrorsInvalidArgument,
        kZMToolSuiteProxyErrorsInternalError,
        kZMToolSuiteProxyErrorsNoPermission,
        kZMToolSuiteProxyErrorsRateLimitReached,
        kZMToolSuiteProxyErrorsOperationTimeout,
        kZMToolSuiteProxyErrorsVersionIncompatible
    };
 
    struct BaseResult {
        ZMToolSuiteProxyErrors error_code = kZMToolSuiteProxyErrorsUnknown;
    };
 
    enum ZMToolSuiteIPCConnectStatus
    {
        IPC_STATUS_IDLE,
        IPC_STATUS_CONNECT_TIMEOUT,
        IPC_STATUS_CONNECTED,
        IPC_STATUS_DISCONNECTED
    };
 
    enum ZMToolSuiteAudioType {
        ZMToolSuiteAudioType_None,
        ZMToolSuiteAudioType_Voip,
        ZMToolSuiteAudioType_Telephony,
    };
 
    enum ZMToolSuiteUserRole {
        ZMToolSuiteUserRole_None,
        ZMToolSuiteUserRole_Host,
        ZMToolSuiteUserRole_CoHost,
        ZMToolSuiteUserRole_Attendee,
        ZMToolSuiteUserRole_Panelist,
        ZMToolSuiteUserRole_BreakoutRoomModerator,
    };
 
    struct ZMToolSuiteUser {
        bool bHost = false;
        bool bVideoOn = false;
        unsigned int iUserID = 0;
        const zchar_t* strUserName = nullptr;
        bool bMyself = false;
        bool bSpotlighted = false;
        bool bAttendee = false;
        bool bRaisedHand = false;
        bool bAudioMuted = false;
        bool bTalking = false;
        bool bInWaitingRoom = false;
        ZMToolSuiteAudioType audioType = ZMToolSuiteAudioType_None;
    };
 
    enum ZMToolSuiteUserAction {
        USER_ACTION_NO_ACTION,
        USER_ACTION_SYNC_ALL,
        USER_ACTION_ADD_USER,
        USER_ACTION_LEFT_USER,
        USER_ACTION_UPDATE_USER
    };
 
    struct ZMToolSuiteUserList : public BaseResult {
        ZMToolSuiteUserAction eUserAction = USER_ACTION_NO_ACTION;
        IToolSuiteVector<ZMToolSuiteUser>* vUserList = {};
    };
 
    enum ZMToolSuiteProxySharePlayError
    {
        ZMToolSuiteProxySharePlayError_No_Error,
        ZMToolSuiteProxySharePlayError_Not_Support,
        ZMToolSuiteProxySharePlayError_Resolution_High,
        ZMToolSuiteProxySharePlayError_Open_Fail,
        ZMToolSuiteProxySharePlayError_Play_Fail,
        ZMToolSuiteProxySharePlayError_Seek_Fail
    };
 
    enum ZMToolSuiteProxyShareContentType
    {
        ZMToolSuiteProxyShareContentType_None,
        ZMToolSuiteProxyShareContentType_AS,
        ZMToolSuiteProxyShareContentType_DS,
        ZMToolSuiteProxyShareContentType_AUDIO,
        ZMToolSuiteProxyShareContentType_FRAME,
        ZMToolSuiteProxyShareContentType_VIDEO_FILE,
        ZMToolSuiteProxyShareContentType_CAMERA
    };
 
    enum ZMToolSuiteProxyRecordStatus
    {
        ZMToolSuiteProxyRecordStatus_None,
        ZMToolSuiteProxyRecordStatus_Start,
        ZMToolSuiteProxyRecordStatus_Stop,
        ZMToolSuiteProxyRecordStatus_Pause,
        ZMToolSuiteProxyRecordStatus_Connecting
    };
 
    enum ZMToolSuiteMeetingStatus {
        MEETING_STATUS_IDLE,
        MEETING_STATUS_CONNECTING,
        MEETING_STATUS_WAITING_FOR_HOST,
        MEETING_STATUS_INMEETING,
        MEETING_STATUS_DISCONNECTING,
        MEETING_STATUS_RECONNECTING,
        MEETING_STATUS_FAILED,
        MEETING_STATUS_ENDED,
        MEETING_STATUS_LOCKED,
        MEETING_STATUS_UNLOCKED,
        MEETING_STATUS_IN_WAITING_ROOM,
        MEETING_STATUS_WEBINAR_PROMOTE,
        MEETING_STATUS_WEBINAR_DEPROMOTE,
 
        MEETING_STATUS_BEFORE_SUBCONF_CREATE,
        MEETING_STATUS_BEFORE_SUBCONF_DESTROY,
 
        MEETING_STATUS_SUBCONF_CREATED,
        MEETING_STATUS_SUBCONF_DESTROYED
    };
 
    enum ZMToolSuiteMeetingType
    {
        MEETING_TYPE_NONE,
        MEETING_TYPE_NORMAL,
        MEETING_TYPE_WEBINAR,
        MEETING_TYPE_WEBINARBO,
        MEETING_TYPE_BO,
        MEETING_TYPE_GREENROOM
    };
 
    enum ZMToolSuiteMeetingInstance
    {
        ZMToolSuiteMeetingInstance_None,
        ZMToolSuiteMeetingInstance_Default,
        ZMToolSuiteMeetingInstance_GreenRoom,
        ZMToolSuiteMeetingInstance_NewBO
    };
 
    struct ZMToolSuiteGetMeetingProperty : public BaseResult {
        const zchar_t* strMeetingTopic = nullptr;
        const zchar_t* strCurrentMeetingNum = nullptr;
        const zchar_t* strMeetingPassword = nullptr;
        const zchar_t* strMeetingJoinURL = nullptr;
        ZMToolSuiteMeetingType eMeetingType = MEETING_TYPE_NONE;
    };
 
    struct GetCmrStatsResult : public BaseResult {
        ZMToolSuiteProxyRecordStatus status = ZMToolSuiteProxyRecordStatus_None;
    };
 
    struct GetLocalRecordingStatsResult : public BaseResult {
        ZMToolSuiteProxyRecordStatus status = ZMToolSuiteProxyRecordStatus_None;
    };
 
    // Audio session statistic
    struct ZMToolSuiteProxyAudioStatisticInfo {
        int frequency_send = 0;   
        int frequency_recv = 0;   
        int latency_send = 0;     
        int latency_recv = 0;     
        int jitter_send = 0;      
        int jitter_recv = 0;      
        float packetloss_send = 0.f;    
        float packetmaxloss_send = 0.f; 
        float packetloss_recv = 0.f;    
        float packetmaxloss_recv = 0.f; 
        int bandwidth_send = 0;   
        int bandwidth_recv = 0;   
    };
 
    // Video/session statistic
    struct ZMToolSuiteProxyVideoStatisticInfo {
        int latency_send = 0;     
        int latency_recv = 0;     
        int jitter_send = 0;      
        int jitter_recv = 0;      
        float packetloss_send_max = 0.f;  
        float packetloss_recv_max = 0.f;  
        float packetloss_send_avg = 0.f;  
        float packetloss_recv_avg = 0.f;  
        int resolution_send = 0;   
        int resolution_recv = 0;   
        int fps_send = 0;        
        int fps_recv = 0;        
        int bandwidth_send = 0;  
        int bandwidth_recv = 0;  
    };
 
    struct QueryAudioStatisticInfoResult : public BaseResult {
        ZMToolSuiteProxyAudioStatisticInfo info;
    };
 
    struct QueryVideoStatisticInfoResult : public BaseResult {
        ZMToolSuiteProxyVideoStatisticInfo info;
    };
 
    // Network type for overall statistic
    enum ZMToolSuiteProxyNetworkType {
        ZMToolSuiteProxyNetworkType_Wired = 0,   
        ZMToolSuiteProxyNetworkType_Wifi = 1,    
        ZMToolSuiteProxyNetworkType_PPP = 2,     
        ZMToolSuiteProxyNetworkType_3G = 3,      
        ZMToolSuiteProxyNetworkType_Others = 4,  
        ZMToolSuiteProxyNetworkType_Unknown = -1 
    };
 
    // Connection type for overall statistic
    enum ZMToolSuiteProxyConnectionType {
        ZMToolSuiteProxyConnectionType_Cloud = 0,   
        ZMToolSuiteProxyConnectionType_Direct = 1,  
        ZMToolSuiteProxyConnectionType_Unknown = -1 
    };
 
    // Overall statistic
    struct ZMToolSuiteProxyOverallStatisticInfo {
        ZMToolSuiteProxyNetworkType net_work_type = ZMToolSuiteProxyNetworkType_Unknown;   
        ZMToolSuiteProxyConnectionType connection_type = ZMToolSuiteProxyConnectionType_Unknown; 
        const zchar_t* proxy_addr = nullptr;   
        const zchar_t* bandwidth = nullptr;    
        const zchar_t* data_center = nullptr;  
        const zchar_t* version = nullptr;      
        unsigned int overall_cpu_usage = 0;    
        unsigned int overall_memory = 0;       
    };

    struct ZMToolSuiteProxyShareStatisticInfo {
        int latency_send = 0;     
        int latency_recv = 0;     
        int jitter_send = 0;      
        int jitter_recv = 0;      
        float packetloss_send_max = 0.f;  
        float packetloss_recv_max = 0.f;  
        float packetloss_send_avg = 0.f;  
        float packetloss_recv_avg = 0.f;  
        int resolution_send = 0;   
        int resolution_recv = 0;   
        int fps_send = 0;        
        int fps_recv = 0;        
        int bandwidth_send = 0;  
        int bandwidth_recv = 0;  
    };
 
    struct QueryOverallStatisticInfoResult : public BaseResult {
        ZMToolSuiteProxyOverallStatisticInfo info;
    };
 
    struct QueryShareStatisticInfoResult : public BaseResult {
        ZMToolSuiteProxyShareStatisticInfo info;
    };
 
    struct GetUnreadChatCountResult : public BaseResult {
        unsigned int uCount = 0;
    };
 
    struct IsUseOriginalSoundResult : public BaseResult {
        bool isUse = false;
    };
 
    struct IsShowOriginalSoundOptionResult : public BaseResult {
        bool isShow = false;
    };
 
    struct GetUserRoleByUserIDResult : public BaseResult {
        ZMToolSuiteUserRole role = ZMToolSuiteUserRole_None;
    };
 
    enum IPCAnnotationClearType
    {
        IPCAnnotationClearType_All,
        IPCAnnotationClearType_Self,
        IPCAnnotationClearType_Other,
    };
 
    enum ZMToolSuiteChatMessageType
    {
        CHAT_MESSAGE_TYPE_IDLE,
        CHAT_MESSAGE_TYPE_TO_ALL,
        CHAT_MESSAGE_TYPE_TO_ALL_PANELIST,
        CHAT_MESSAGE_TYPE_TO_INDIVIDUAL_PANELIST,
        CHAT_MESSAGE_TYPE_TO_INDIVIDUAL,
        CHAT_MESSAGE_TYPE_TO_WAITINGROOMUSERS,
    };
 
    struct ZMToolSuiteChatInfo
    {
        const zchar_t* strContent = nullptr;
        unsigned int iUserID = 0;
        ZMToolSuiteChatMessageType eChatType = CHAT_MESSAGE_TYPE_IDLE;
    };
 
    struct StartMeetingParam {
        long long meetingNumber = 0;
        bool isNoVideo = true;
        bool isNoAudio = true;
    };
 
    struct JoinMeetingParam {
        const zchar_t* displayName = nullptr;
        long long meetingNumber = 0;
        const zchar_t* password = nullptr;
    };
 
    enum IPCEmojiReactionType
    {
        IPCEmojiReactionType_Unknow,
        IPCEmojiReactionType_Clap,
        IPCEmojiReactionType_Thumbsup,
        IPCEmojiReactionType_Heart,
        IPCEmojiReactionType_Joy,
        IPCEmojiReactionType_Openmouth,
        IPCEmojiReactionType_Tada,
        IPCEmojiReactionType_ClapSound,
        IPCEmojiReactionType_Count,
    };
 
    enum IPCEmojiReactionSkinTone
    {
        IPCEmojiReactionSkinTone_Unknow,
        IPCEmojiReactionSkinTone_Default,
        IPCEmojiReactionSkinTone_Light,
        IPCEmojiReactionSkinTone_MediumLight,
        IPCEmojiReactionSkinTone_Medium,
        IPCEmojiReactionSkinTone_MediumDark,
        IPCEmojiReactionSkinTone_Dark,
    };
 
    enum IPCFeedbackReactionType
    {
        IPCFeedbackReactionType_None,
        IPCFeedbackReactionType_Hand,
        IPCFeedbackReactionType_Yes,
        IPCFeedbackReactionType_No,
        IPCFeedbackReactionType_Fast,
        IPCFeedbackReactionType_Slow,
        IPCFeedbackReactionType_Bad,
        IPCFeedbackReactionType_Good,
        IPCFeedbackReactionType_Clap,
        IPCFeedbackReactionType_Coffee,
        IPCFeedbackReactionType_Clock,
        IPCFeedbackReactionType_Emoji,
        IPCFeedbackReactionType_Clear,
    };
 
    struct SendEmojiReactionParam {
        IPCEmojiReactionType type = IPCEmojiReactionType_Unknow;
        IPCEmojiReactionSkinTone skinTone = IPCEmojiReactionSkinTone_Unknow;
    };
 
    enum IPCReactionCategory
    {
        IPCReactionCategory_Unknown = 0,
        IPCReactionCategory_Normal  = 1,
        IPCReactionCategory_Custom  = 2,
    };
 
    struct WebinarEmojiContent {
        std::string         emojiKey;
        unsigned int        count            = 0;
        IPCReactionCategory reactionCategory = IPCReactionCategory_Unknown;
    };
 
    struct ZMToolSuiteDeviceInfo : public BaseResult
    {
        const zchar_t* device_id = nullptr;
        const zchar_t* device_name = nullptr;
        bool isSelected = false;
    };
 
    enum ZMToolSuiteAudioShareMode
    {
        AUDIO_SHARE_IDLE,
        AUDIO_SHARE_MONO,
        AUDIO_SHARE_STEREO
    };
 
    struct ZMToolSuiteGetAudioShareModeResult : public BaseResult
    {
        ZMToolSuiteAudioShareMode eShareMode = AUDIO_SHARE_IDLE;
    };
 
 
    enum IPCMeetingComponentType
    {
        //Meeting window.
        IPCMeetingComponentType_MainWindow,
        //Audio.
        IPCMeetingComponentType_Audio,
        //Chat.
        IPCMeetingComponentType_Chat,
        //Participants.
        IPCMeetingComponentType_Participants,
        //Main toolbar at the bottom of meeting window.
        IPCMeetingComponentType_MainToolBar,
        //Main toolbar for sharing on the primary view.
        IPCMeetingComponentType_MainShareToolBar,
        //Setting components.
        IPCMeetingComponentType_Setting,
        //Window for sharing options.
        IPCMeetingComponentType_ShareOptionWindow,
        //Thumbnail video layout.
        IPCMeetingComponentType_ThumbnailVideo,
        //Window for invite other into meeting.
        IPCMeetingComponentType_InviteWindow,
        //Window for sharing select.
        IPCMeetingComponentType_ShareSelectWindow,
    };
 
    enum IPCMeetingViewType
    {
        IPCMeetingViewType_ActiveSpeaker,
        IPCMeetingViewType_Wall,
        IPCMeetingViewType_MultiSpeaker,
        IPCMeetingViewType_Other,
    };
 
    struct GetMeetingViewTypeResult : public BaseResult
    {
        IPCMeetingViewType type = IPCMeetingViewType_ActiveSpeaker;
    };
 
    struct ToggleFullScreenParam {
        bool enterFullScreen = false;
        bool firstMonitor = true;
        bool dualMonitor = false;
    };
 
    struct SwitchMeetingComponentParam {
        IPCMeetingComponentType type = IPCMeetingComponentType_MainWindow;
        bool show = true;
    };
 
    enum ZMToolSuiteProxySpotlightResult
    {
        ZMToolSuiteProxySpotResult_Success,
        ZMToolSuiteProxySpotResult_Fail_NotEnoughUsers,  
        ZMToolSuiteProxySpotResult_Fail_ToMuchSpotlightedUsers, 
        ZMToolSuiteProxySpotResult_Fail_UserCannotBeSpotlighted, 
        ZMToolSuiteProxySpotResult_Fail_UserWithoutVideo, 
        ZMToolSuiteProxySpotResult_Fail_NoPrivilegeToSpotlight,  
        ZMToolSuiteProxySpotResult_Fail_UserNotSpotlighted, 
        ZMToolSuiteProxySpotResult_Unknown = 100,
    };
 
    struct ZMToolSuiteProxyCanSpotlightResult:public BaseResult
    {
        ZMToolSuiteProxySpotlightResult result = ZMToolSuiteProxySpotResult_Success;
    };
 
    struct ZMToolSuiteProxyCanUnSpotlightResult :public BaseResult
    {
        ZMToolSuiteProxySpotlightResult result = ZMToolSuiteProxySpotResult_Success;
    };
 
    enum IPC_PROXY_TYPE {
        IPC_PROXY_TYPE_UNKNOWN,
        IPC_PROXY_TYPE_ZCUTS,
    };
 
    enum ZMToolSuiteShareStatus
    {
        ZMToolSuiteShareStatus_Started,
        ZMToolSuiteShareStatus_Ended
    };
 
    enum ZMToolSuitMonitorType
    {
        ZMToolSuitMonitorType_First,
        ZMToolSuitMonitorType_Dual,
    };
 
    struct GetSharingStatusResult : public BaseResult
    {
        ZMToolSuiteShareStatus status = ZMToolSuiteShareStatus_Ended;
    };
 
    enum ZMToolSuiteSetVBType {
        ZMToolSuiteSetVBType_None,
        ZMToolSuiteSetVBType_Blur,
        ZMToolSuiteSetVBType_Image,
        ZMToolSuiteSetVBType_Video,
    };
 
    struct ZMToolSuiteSetVBParam {
        ZMToolSuiteSetVBType type = ZMToolSuiteSetVBType_None;
        const zchar_t* path = nullptr;
    };
 
    enum ZMToolSuiteChatPrivilegeType {
        ZMToolSuiteChatPrivilegeType_To_Everyone,           
        ZMToolSuiteChatPrivilegeType_To_All_Panelist,       
        ZMToolSuiteChatPrivilegeType_To_Host,               
        ZMToolSuiteChatPrivilegeType_Disable_Attendee_Chat, 
        ZMToolSuiteChatPrivilegeType_Host_Public,           
    };
 
    enum ZMToolSuitePanelistChatPrivilege {
        ZMToolSuitePanelistChatPrivilege_PanelistOnly,   
        ZMToolSuitePanelistChatPrivilege_All,            
    };
 
    struct BoolValueResult : public BaseResult {
        bool bValue = false;
    };
 
    struct IntValueResult : public BaseResult {
        int iValue = 0;
    };
 
    struct GetPanelistChatPrivilegeResult : public BaseResult {
        ZMToolSuitePanelistChatPrivilege eType = ZMToolSuitePanelistChatPrivilege_All;
    };
 
    struct ZMToolSuiteShareOptions {
        bool bShareSound = false;
        bool bOptimizeVideo = false;
    };
 
    enum ZMToolSuiteSettingWindowTabType {
        ZMToolSuiteSettingWindowTabType_General = 0,
        ZMToolSuiteSettingWindowTabType_Video = 1,
        ZMToolSuiteSettingWindowTabType_Audio = 2,
        ZMToolSuiteSettingWindowTabType_ShareScreen = 3,
        ZMToolSuiteSettingWindowTabType_Phone = 4,
        ZMToolSuiteSettingWindowTabType_TeamChat = 5,
        // 6 reserved for Huddles (wire compatibility)
        ZMToolSuiteSettingWindowTabType_ZoomApps = 7,
        ZMToolSuiteSettingWindowTabType_Background = 8,
        ZMToolSuiteSettingWindowTabType_Recording = 9,
        ZMToolSuiteSettingWindowTabType_Profile = 10,
        ZMToolSuiteSettingWindowTabType_Statistics = 11,
        ZMToolSuiteSettingWindowTabType_Shortcuts = 12,
        ZMToolSuiteSettingWindowTabType_Accessibility = 13,
    };
}//namespace ZMToolSuiteProxy