RoomDefines.h

Go to the documentation of this file.

//
//  RoomDefines.h
//  zegoliveroom
//
//  Created by Strong on 2017/7/20.
//
 
#ifndef RoomDefines_h
#define RoomDefines_h
 
#include "./AVDefines.h"
#include <cstddef>
 
#ifndef ZEGO_API
    #ifdef WIN32
        #ifdef ZEGO_EXPORTS
            #define ZEGO_API __declspec(dllexport)
        #else
            #define ZEGO_API __declspec(dllimport)
        #endif
    #else
        #define ZEGO_API __attribute__((visibility("default")))
    #endif
#endif
 
namespace ZEGO
{
    namespace COMMON
    {
        enum ZEGONetType
        {
            ZEGO_NT_NONE = 0,       
            ZEGO_NT_LINE = 1,       
            ZEGO_NT_WIFI = 2,       
            ZEGO_NT_2G = 3,         
            ZEGO_NT_3G = 4,         
            ZEGO_NT_4G = 5,         
            ZEGO_NT_5G = 6,         
            ZEGO_NT_UNKNOWN = 32    
        };
        
        enum ZegoStreamUpdateType
        {
            StreamAdded     = 2001,     
            StreamDeleted   = 2002,     
        };
 
        enum ZegoStreamDeleteReason
        {
            ZEGO_DELETE_NOT_SUPPORT = -1,             
            ZEGO_DELETE_NORMAL = 0,                   
            ZEGO_DELETE_HEARTBEAT_TIMEOUT = 1,        
            ZEGO_DELETE_REPEAT_LOGIN = 2,             
            ZEGO_DELETE_KICKOUT = 3,                  
            ZEGO_DELETE_OFFLINE = 4,                  
            ZEGO_DELETE_SERVER = 100,                 
            ZEGO_DELETE_UNKOWN = 1000,                
        };
 
        struct ZegoStreamInfo
        {
            ZegoStreamInfo()
            {
                szUserId[0] = '\0';
                szUserName[0] = '\0';
                szStreamId[0] = '\0';
                szExtraInfo[0] = '\0';
                nStreamNId = 0;
                streamDeleteReason = ZEGO_DELETE_NOT_SUPPORT;
            }
 
            char szUserId[ZEGO_MAX_USERID_LEN];
            char szUserName[ZEGO_MAX_USERNAME_LEN];
            char szStreamId[ZEGO_MAX_COMMON_LEN];
            char szExtraInfo[ZEGO_MAX_EXTRA_INFO_LEN];
            int nStreamNId;
 
            //流删除原因,当前流删除原因 (只在sdk 回调onStreamUpdated 且type类型为流删除时有效) 
            ZegoStreamDeleteReason streamDeleteReason;
        };
 
        enum ZegoPublishFlag
        {
            ZEGO_JOIN_PUBLISH = 0,        
            ZEGO_MIX_STREAM = 1 << 1,   
            ZEGO_SINGLE_ANCHOR = 1 << 2,   
        };
        
        struct ZegoPublishingStreamInfo
        {
            ZegoPublishingStreamInfo()
            {
                uiRtmpURLCount = 0;
                uiHlsURLCount = 0;
                uiFlvURLCount = 0;
                for (int i = 0; i < ZEGO_MAX_URL_COUNT; i++)
                {
                    arrRtmpURLs[i] = NULL;
                    arrFlvURLs[i] = NULL;
                    arrHlsURLs[i] = NULL;
                }
            }
            const char* arrRtmpURLs[ZEGO_MAX_URL_COUNT];   
            unsigned int uiRtmpURLCount;                   
            const char* arrFlvURLs[ZEGO_MAX_URL_COUNT];
            unsigned int uiFlvURLCount;
            
            const char* arrHlsURLs[ZEGO_MAX_URL_COUNT];
            unsigned int uiHlsURLCount;
        };
 
        enum ZegoRoomRole
        {
            UnknownRole = 0,
            Anchor = 1,     
            Audience = 2,   
            Assistant = 32, 
        };
 
        enum ZegoUserUpdateType
        {
            UPDATE_TOTAL = 1,   
            UPDATE_INCREASE,    
        };
 
        enum ZegoUserUpdateFlag
        {
            USER_ADDED = 1,     
            USER_DELETED,       
        };
 
        struct ZegoUserInfo
        {
            ZegoUserInfo()
            {
                szUserId[0] = '\0';
                szUserName[0] = '\0';
                udapteFlag = USER_ADDED;
                role = UnknownRole;
            }
 
            char szUserId[ZEGO_MAX_USERID_LEN];
            char szUserName[ZEGO_MAX_USERNAME_LEN];
            ZegoUserUpdateFlag udapteFlag;
            ZegoRoomRole role;
        };
 
        struct ZegoRoomInfo
        {
            ZegoRoomInfo()
            {
                //标志房间时间断内唯一性的id
                uRoomSessionId = 0; 
            }
 
            unsigned long long uRoomSessionId;
        };
    }
 
    namespace ROOM 
    {
        struct ZegoUser 
        {
            ZegoUser()
            {
                szUserId[0] = '\0';
                szUserName[0] = '\0';
            }
 
            char szUserId[ZEGO_MAX_USERID_LEN];
            char szUserName[ZEGO_MAX_USERNAME_LEN];
        };
 
        enum ZegoTransparentMessageType 
        {
            TransparentMessageNormal = 0, //发和收不保证严格顺序
            TransparentMessageSequence = 1, //TransparentMessageSequence,sdk 会严格保证接收顺序。 x用户 在房间A中sendA, sendB   那么 在房间A中收到用户x 的OnRecvRoomTransparentMessage 回调一定是 recvA, recvB
        };
        
        enum ZegoTransparentMessageMode 
        {
            RoomTransparentClient = 0, //数据只会推给对端 接收端触发 OnRecvRoomTransparentMessage
            RoomTransparentServer = 1, //数据只会推给客户服务，不会触发OnRecvRoomTransparentMessage. 需要后台配置服务调度地址
            RoomTransparentClientAndServer = 2, //数据推给客户服务，和推给sdk, 需要后台配置服务调度地址
        };
        
        struct ZegoSendTransparentMessage
        {
            ZegoSendTransparentMessage() {
                sendType = TransparentMessageNormal;
                sendMode = RoomTransparentClient;
                recvUserList = NULL;
                recvUserListCount = 0;
                content = NULL;
                contentLenth = 0;
                timeOut = 10;
            }
            ZegoTransparentMessageType sendType;
            ZegoTransparentMessageMode sendMode;
 
            ZegoUser *recvUserList;
            unsigned int recvUserListCount;
 
            unsigned char *content;
            unsigned int contentLenth;
 
            int timeOut; //单位s
        };
        
        struct ZegoRecvTransparentMessage {
            ZegoRecvTransparentMessage() {
                content = NULL;
                contentLenth = 0;
            }
 
            ZegoUser sendUser;
            unsigned char *content;
            unsigned int contentLenth;
        };
 
        enum ZegoRoomStreamListType
        {
            RoomStreamPlay = 0,
            RoomStreamAll = 1
        };
 
        struct ZegoRoomStreamList
        {
            COMMON::ZegoStreamInfo *publishStreamList;
            unsigned int publishStreamListCount;
 
            COMMON::ZegoStreamInfo *playStreamList;
            unsigned int playStreamListCount;
 
            ZegoRoomStreamList()
            { 
                publishStreamList = nullptr;
                publishStreamListCount = 0;
 
                playStreamList = nullptr;
                playStreamListCount = 0;
            }
        };
    }
 }
 
#ifndef ZegoRoomDefines_h
 
namespace ZEGO
{
    namespace ROOM
    {
        enum ZegoMessageType
        {
            Text = 1,           
            Picture,            
            File,               
            OtherType = 100,    
        };
 
        enum ZegoMessagePriority
        {
            Default = 2,        
            High = 3,           
        };
 
        enum ZegoMessageCategory
        {
            Chat = 1,           
            System,             
            Like,               
            Gift,               
            OtherCategory = 100,
        };
        
        enum ZegoRelayType
        {
            RelayTypeNone = 1,
            RelayTypeDati = 2,
        };
 
        struct ZegoRoomMessage
        {
            ZegoRoomMessage()
            {
                szUserId[0] = '\0';
                szUserName[0] = '\0';
                szContent[0] = '\0';
                role = COMMON::Audience;
                type = Text;
                priority = Default;
                category = Chat;
                sendTime = 0;
                messageId = 0;
            }
 
            char szUserId[ZEGO_MAX_USERID_LEN];
            char szUserName[ZEGO_MAX_USERNAME_LEN];
            COMMON::ZegoRoomRole role;
            char szContent[ZEGO_MAX_ROOMMESSAGE_LEN];
            unsigned long long messageId;
            ZegoMessageType type;
            ZegoMessagePriority priority;
            ZegoMessageCategory category;
            unsigned long long sendTime;
        };
        
        struct ZegoBigRoomMessage
        {
            ZegoBigRoomMessage()
            {
                szUserId[0] = '\0';
                szUserName[0] = '\0';
                szContent[0] = '\0';
                szMessageId[0] = '\0';
                role = COMMON::Audience;
                type = Text;
                category = Chat;
                sendTime = 0;
            }
            
            char szUserId[ZEGO_MAX_USERID_LEN];
            char szUserName[ZEGO_MAX_USERNAME_LEN];
            COMMON::ZegoRoomRole role;
            char szContent[ZEGO_MAX_ROOMMESSAGE_LEN];
            char szMessageId[ZEGO_MAX_IDENTITY_LEN];
            ZegoMessageType type;
            ZegoMessageCategory category;
            unsigned long long sendTime;
        };
 
        struct ZegoRoomExtraInfo
        {
            ZegoRoomExtraInfo()
            {
                szKey[0] = '\0';
                szValue[0] = '\0';
                szUserID[0] = '\0';
                szUserName[0] = '\0';
                updateTime = 0;
            }
            char szKey[ZEGO_MAX_ROOM_EXTRA_INFO_KEY_LEN];
            char szValue[ZEGO_MAX_ROOM_EXTRA_INFO_VALUE_LEN];
            char szUserID[ZEGO_MAX_USERID_LEN];
            char szUserName[ZEGO_MAX_USERNAME_LEN];
            unsigned long long updateTime;
        };
    
        enum ZegoConnectState
        {
            Disconnected = 1,
            WaitingConnect,
            Connecting,
            Connected,
        };
    }
}
 
#endif  /* ZegoRoomDefines_h */
#endif /* RoomDefines_h */