kit_define_meeting.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_METTING_H_
#define NEM_SDK_INTERFACE_DEFINE_METTING_H_
 
#include <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "kit_define_public.h"
#include "kit_define_settings.h"
 
NNEM_SDK_INTERFACE_BEGIN_DECLS
 
enum NEMeetingStatus {
 
    MEETING_STATUS_FAILED =  -1,
 
    MEETING_STATUS_IDLE = 0,
 
    MEETING_STATUS_WAITING = 1,
 
    MEETING_STATUS_CONNECTING = 2,
 
    MEETING_STATUS_INMEETING = 3,
 
    MEETING_STATUS_IN_WAITING_ROOM = 5,
    MEETING_STATUS_DISCONNECTING = 6,
 
    MEETING_STATUS_IN_SCREEN_SHARING = 7,
 
    MEETING_STATUS_UNKNOWN = 100,
};
 
enum MeetingDisconnectCode {
    MEETING_DISCONNECTING_BY_SELF = 0,
 
    MEETING_DISCONNECTING_REMOVED_BY_HOST = 1,
 
    MEETING_DISCONNECTING_CLOSED_BY_HOST = 2,
 
    MEETING_DISCONNECTING_LOGIN_ON_OTHER_DEVICE = 3,
 
    MEETING_DISCONNECTING_CLOSED_BY_SELF_AS_HOST = 4,
 
    MEETING_DISCONNECTING_AUTH_INFO_EXPIRED = 5,
 
    MEETING_DISCONNECTING_BY_SERVER = 6,
 
    MEETING_DISCONNECTING_BY_MEETINGNOTEXIST = 7,
 
    MEETING_DISCONNECTING_BY_SYNCDATAERROR = 8,
 
    MEETING_DISCONNECTING_BY_RTCINITERROR = 9,
 
    MEETING_DISCONNECTING_BY_JOINCHANNELERROR = 10,
 
    MEETING_DISCONNECTING_BY_TIMEOUT = 11,
 
    MEETING_DISCONNECTING_BY_END_OF_LIFE = 12,
 
    MEETING_WAITING_VERIFY_PASSWORD = 20
};
 
enum NEMeetingItemStatus {
    MEETING_INVALID,
 
    MEETING_INIT,
 
    MEETING_STARTED,
 
    MEETING_ENDED,
 
    MEETING_CANCEL,
 
    MEETING_RECYCLED
};
 
enum NEShowMeetingIdOption {
    kDisplayShortIdOnly, 
    kDisplayLongIdOnly,  
    kDisplayAll          
};
 
enum NEMeetingWindowMode {
    WHITEBOARD_MODE,
 
    NORMAL_MODE
};
 
 
enum NEMenuVisibility {
    VISIBLE_ALWAYS = 0,
 
    VISIBLE_EXCLUDE_HOST = 1,
 
    VISIBLE_TO_HOST_ONLY = 2,
 
    /*
     * @brief SIP/H323不可见
     */
    VISIBLE_EXCLUDE_ROOM_SYSTEM_DEVICE = 3,
 
    /*
     * @brief 仅对会议创建者可见
     */
    VISIBLE_TO_OWNER_ONLY = 4,
 
    /*
     * @brief 仅对会议主持人可见，联席主持人不可见
     */
    VISIBLE_TO_HOST_EXCLUDE_CO_HOST = 5
};
 
enum NEMeetingRoleType {
    host,
 
    coHost,
 
    member,
 
    guest,
};
 
enum NERecordStrategyType { kHostJoin, kMemberJoin };
 
typedef struct tagNECloudRecordConfig {
    bool enable;
 
    NERecordStrategyType recordStrategy{NERecordStrategyType::kHostJoin};
 
} NECloudRecordConfig;
 
typedef struct tagNEInMeetingUserInfo {
    std::string userId;
 
    std::string userName;
 
    std::string tag;
 
    NEMeetingRoleType role;
 
} NEInMeetingUserInfo;
 
enum NEEncryptionMode {
    kNEEncryptionTypeGMCryptoSM4ECB,
};
 
typedef struct _tagNEEncryptionConfig {
    NEEncryptionMode encryptionMode{NEEncryptionMode::kNEEncryptionTypeGMCryptoSM4ECB};
 
    std::string encryptKey;
} NEEncryptionConfig;
 
struct NEWatermarkConfig {
    std::string name;
    std::string phone;
    std::string email;
    std::string jobNumber;
};
 
enum NEControlType { kControlTypeAudio, kControlTypeVideo };
 
enum NEAttendeeOffType {
    kAttendeeOffNone,
 
    kAttendeeOffAllowSelfOn,
 
    kAttendeeOffNotAllowSelfOn
};
 
typedef struct tagNEMeetingControl {
    NEAttendeeOffType attendeeOff{kAttendeeOffNone};
 
    std::string type;
 
} NEMeetingControl;
 
typedef struct tagNEMeetingInfo {
    int64_t meetingId;
 
    std::string meetingNum;
 
    std::string shortMeetingNum;
 
    std::string subject;
 
    std::string password;
 
    bool isHost;
 
    bool isLocked;
 
    bool isInWaitingRoom;
 
    int64_t scheduleStartTime;
 
    int64_t scheduleEndTime;
 
    int64_t startTime;
 
    int64_t duration;
 
    std::string sipId;
 
    std::string hostUserId;
 
    std::list<NEInMeetingUserInfo> userList;
 
    std::string extraData;
 
    std::string timezoneId;
} NEMeetingInfo;
 
typedef struct tagNEMeetingRoleConfiguration {
    NEMeetingRoleType roleType = member;
 
    int32_t maxCount = -1;
 
    std::list<std::string> userList;
} NEMeetingRoleConfiguration;
 
typedef struct tagNEMeetingScene {
    std::string code;
 
    std::list<NEMeetingRoleConfiguration> roleTypes;
} NEMeetingScene;
 
typedef struct tagNEMeetingChatroomConfig {
    tagNEMeetingChatroomConfig& operator=(const tagNEMeetingChatroomConfig& config) {
        enableFileMessage = config.enableFileMessage;
        enableImageMessage = config.enableImageMessage;
        return *this;
    }
 
    bool enableFileMessage = true;
    bool enableImageMessage = true;
} NEMeetingChatroomConfig;
 
#define NEM_MORE_MENU_USER_INDEX 100
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kFirstinjectedMenuId = 100;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kMicMenuId = 0;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kCameraMenuId = 1;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kScreenShareMenuId = 2;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kParticipantsMenuId = 3;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kMangeParticipantsMenuId = 4;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kInviteMenuId = 20;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kChatMenuId = 21;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kViewMenuId = 22;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kWhiteboardMenuId = 23;
 
[[deprecated("This menu ID is deprecated, use the new NEMenuIDs instead")]]
const int kSecurityMenuId = 24;
 
enum NEMeetingMenuIDs {
 
    kMeetingMicMenuId =0,
    kMeetingCameraMenuId = 1,
    kMeetingScreenshareMenuId= 2,
    kMeetingParticipantsMenuId = 3,
    kMeetingManageParticipantsMenuId= 4,
    kMeetingSwitchShowTypeMenuId = 6,
 
    kMeetingInviteMenuId = 20,
    kMeetingChatMenuId = 21,
    kMeetingWhiteboardMenuId = 22,
    kMeetingCloudRecordMenuId = 23,
    kMeetingSecurityMenuId = 24,
    kMeetingDisconnectAudioMenuId = 25,
    kMeetingNotifyCenterMenuId = 26,
    kMeetingSettingsMenuId = 27,
    kMeetingFeedbackMenuId = 28,
    kMeetingBeautyMenuId = 54,
    kMeetingLiveMenuId = 55,
    kMeetingVirtualBackgroundMenuId = 58,
    kMeetingInterpretationMenuId = 59,
    kMeetingCaptionsMenuId = 60,
    kMeetingTranscriptionMenuId = 61,
    kMeetingSipCallMenuId = 62,
    kMeetingFirstInjectedMenuId = 100,
};
 
enum  NEActionMenuIDs {
 
    kActionMenuStartId = 100000,
 
    kActionMenuEndId = 110000,
 
    kAudioActionMenuId = 100000,
 
    kVideoActionMenuId = 100001,
 
    kFocusVideoActionMenuId = 100002,
 
    kLockVideoActionMenuId = 100003,
 
    kChangeHostActionMenuId = 100004,
 
    kReclaimHostActionMenuId = 100005,
 
    kRemoveMemberActionMenuId = 100006,
 
    kRejectHandsUpActionMenuId = 100007,
 
    kWhiteboardInteractionActionMenuId = 100008,
 
    kScreenShareActionMenuId = 100009,
 
    kWhiteboardShareActionMenuId = 100010,
 
    kUpdateNickActionMenuId = 100011,
 
    kAudioAndVideoActionMenuId = 100012,
 
    kCoHostActionMenuId = 100013,
 
    kPutinWaitingRoomActionMenuId = 100014,
 
    kChatPrivateActionMenuId = 100015
};
 
enum NEMeetingMenuType { kNEMeetingMenuTypeDefault, kNEMeetingMenuTypeSingleState, kNEMeetingMenuTypeCheckable };
 
typedef struct tagNEMeetingMenuItem {
    tagNEMeetingMenuItem() = default;
 
    virtual ~tagNEMeetingMenuItem() = default;
 
    tagNEMeetingMenuItem(NEMeetingMenuType t, int i, NEMenuVisibility v)
        : type(t)
        , itemId(i)
        , visibility(v) {}
 
    NEMeetingMenuType type = kNEMeetingMenuTypeDefault;
    int itemId = kFirstinjectedMenuId;
 
    NEMenuVisibility visibility = NEMenuVisibility::VISIBLE_ALWAYS;
 
    //    bool operator==(const NEMeetingMenuItem& item) const { return item.itemId == itemId; }
    //
    //    bool operator<(const NEMeetingMenuItem& item) const { return itemId < item.itemId; }
} NEMeetingMenuItem;
 
using NEMeetingMenuItemPtr = std::shared_ptr<NEMeetingMenuItem>;
 
typedef struct TagNEMenuItemInfo {
    std::string icon;
    std::string text;
} NEMenuItemInfo;
 
typedef struct tagNESingleStateMenuItem : NEMeetingMenuItem {
    ~tagNESingleStateMenuItem() = default;
 
    tagNESingleStateMenuItem() = default;
 
    tagNESingleStateMenuItem(int itemId_, NEMenuVisibility visibility_, NEMenuItemInfo singleStateItem_)
        : NEMeetingMenuItem(kNEMeetingMenuTypeSingleState, itemId_, visibility_)
        , singleStateItem(std::move(singleStateItem_)) {}
 
    NEMenuItemInfo singleStateItem;
} NESingleStateMenuItem;
 
using NESingleStateMenuItemPtr = std::shared_ptr<NESingleStateMenuItem>;
 
typedef struct tagNECheckableMenuItem : NEMeetingMenuItem {
    ~tagNECheckableMenuItem() = default;
 
    tagNECheckableMenuItem() = default;
 
    tagNECheckableMenuItem(int itemId_, NEMenuVisibility visibility_, NEMenuItemInfo checkedStateItem_, NEMenuItemInfo uncheckedStateItem_)
        : NEMeetingMenuItem(kNEMeetingMenuTypeCheckable, itemId_, visibility_)
        , uncheckStateItem(std::move(checkedStateItem_))
        , checkedStateItem(std::move(uncheckedStateItem_)) {}
 
    NEMenuItemInfo checkedStateItem;
    NEMenuItemInfo uncheckStateItem;
    bool checked{false};
 
} NECheckableMenuItem;
 
using NECheckableMenuItemPtr = std::shared_ptr<NECheckableMenuItem>;
 
typedef struct tagNEMenuClickInfo {
    virtual ~tagNEMenuClickInfo() = default;
 
    tagNEMenuClickInfo() = default;
 
    int itemId;
} NEMenuClickInfo;
 
using NEMenuClickInfoPtr = std::shared_ptr<NEMenuClickInfo>;
 
typedef struct tagNEStatefulMenuClickInfo : NEMenuClickInfo {
    virtual ~tagNEStatefulMenuClickInfo() = default;
 
    tagNEStatefulMenuClickInfo() = default;
 
    tagNEStatefulMenuClickInfo(int state_, int itemId_, bool isChecked_)
        : state(state_)
        , isChecked(isChecked_) {}
 
    int state;
    bool isChecked = false;
} NEStatefulMenuClickInfo;
 
using NEStatefulMenuClickInfoPtr = std::shared_ptr<NEStatefulMenuClickInfo>;
 
class NEM_SDK_INTERFACE_EXPORT NEActionMenuItems {
public:
    static NECheckableMenuItemPtr audio() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr = std::make_shared<NECheckableMenuItem>(
            NEActionMenuIDs::kAudioActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY, checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NECheckableMenuItemPtr video() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr = std::make_shared<NECheckableMenuItem>(
            NEActionMenuIDs::kVideoActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY, checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NECheckableMenuItemPtr focusVideo() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr = std::make_shared<NECheckableMenuItem>(
            NEActionMenuIDs::kFocusVideoActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY, checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NECheckableMenuItemPtr lockVideo() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr = std::make_shared<NECheckableMenuItem>(
            NEActionMenuIDs::kLockVideoActionMenuId, NEMenuVisibility::VISIBLE_ALWAYS, checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NESingleStateMenuItemPtr changeHost() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kChangeHostActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_EXCLUDE_CO_HOST, singleStateItem);
        return mSingleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr reclaimHost() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kReclaimHostActionMenuId, NEMenuVisibility::VISIBLE_TO_OWNER_ONLY, singleStateItem);
        return mSingleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr removeMember() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kRemoveMemberActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY, singleStateItem);
        return mSingleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr rejectHandsUp() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kRejectHandsUpActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY, singleStateItem);
        return mSingleStateMenuItemPtr;
    }
    static NECheckableMenuItemPtr whiteboardInteraction() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr = std::make_shared<NECheckableMenuItem>(NEActionMenuIDs::kWhiteboardInteractionActionMenuId,
            NEMenuVisibility::VISIBLE_EXCLUDE_ROOM_SYSTEM_DEVICE, checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NESingleStateMenuItemPtr screenShare() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kScreenShareActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY, singleStateItem);
        return mSingleStateMenuItemPtr;
    };
    static NESingleStateMenuItemPtr whiteBoardShare() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kWhiteboardShareActionMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY, singleStateItem);
        return mSingleStateMenuItemPtr;
    };
    static NESingleStateMenuItemPtr updateNick() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kUpdateNickActionMenuId,
            NEMenuVisibility::VISIBLE_TO_HOST_ONLY, singleStateItem);
        return mSingleStateMenuItemPtr;
    };
    static NECheckableMenuItemPtr audioAndVideo() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr = std::make_shared<NECheckableMenuItem>(NEActionMenuIDs::kAudioAndVideoActionMenuId,
            NEMenuVisibility::VISIBLE_TO_HOST_ONLY,
            checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NECheckableMenuItemPtr coHost() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr = std::make_shared<NECheckableMenuItem>(NEActionMenuIDs::kCoHostActionMenuId,
            NEMenuVisibility::VISIBLE_TO_HOST_EXCLUDE_CO_HOST,
            checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NESingleStateMenuItemPtr putInWaitingRoom() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kPutinWaitingRoomActionMenuId,
            NEMenuVisibility::VISIBLE_TO_HOST_ONLY, singleStateItem);
        return mSingleStateMenuItemPtr;
    };
    static NESingleStateMenuItemPtr chatPrivate() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr mSingleStateMenuItemPtr;
        mSingleStateMenuItemPtr = std::make_shared<NESingleStateMenuItem>(
            NEActionMenuIDs::kChatPrivateActionMenuId,
            NEMenuVisibility::VISIBLE_EXCLUDE_ROOM_SYSTEM_DEVICE, singleStateItem);
        return mSingleStateMenuItemPtr;
    };
};
class NEM_SDK_INTERFACE_EXPORT NEMeetingMenuItems {
public:
    static NECheckableMenuItemPtr micMenu() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr mCheckableMenuItemPtr;
        mCheckableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingMicMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem, uncheckStateItem);
        return mCheckableMenuItemPtr;
    }
    static NECheckableMenuItemPtr cameraMenu() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr checkableMenuItemPtr;
        checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingCameraMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem, uncheckStateItem);
        return checkableMenuItemPtr;
    }
    static NECheckableMenuItemPtr switchShowTypeMenu() {
        NEMenuItemInfo checkedStateItem_;
        NEMenuItemInfo uncheckStateItem_;
        NECheckableMenuItemPtr m_checkableMenuItemPtr;
        m_checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingSwitchShowTypeMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem_, uncheckStateItem_);
        return m_checkableMenuItemPtr;
    }
    static NECheckableMenuItemPtr screenShareMenu() {
        NEMenuItemInfo checkedStateItem_;
        NEMenuItemInfo uncheckStateItem_;
        NECheckableMenuItemPtr m_checkableMenuItemPtr;
        m_checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingScreenshareMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem_, uncheckStateItem_);
        return m_checkableMenuItemPtr;
    }
    static NESingleStateMenuItemPtr participantsMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr m_singleStateMenuItemPtr;
        m_singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingParticipantsMenuId, NEMenuVisibility::VISIBLE_EXCLUDE_HOST,
                singleStateItem);
        return m_singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr managerParticipantsMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr m_singleStateMenuItemPtr;
        m_singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingManageParticipantsMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY,
                singleStateItem);
        return m_singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr inviteMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingInviteMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr chatMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr m_singleStateMenuItemPtr;
        m_singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingChatMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return m_singleStateMenuItemPtr;
    }
    static NECheckableMenuItemPtr whiteBoardShareMenu() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr checkableMenuItemPtr;
        checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingWhiteboardMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem, uncheckStateItem);
        return checkableMenuItemPtr;
    }
    static NECheckableMenuItemPtr cloudRecordMenu() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr checkableMenuItemPtr;
        checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingCloudRecordMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY,
                checkedStateItem, uncheckStateItem);
        return checkableMenuItemPtr;
    }
    static NESingleStateMenuItemPtr securityMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingSecurityMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NECheckableMenuItemPtr disconnectAudioMenu() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr checkableMenuItemPtr;
        checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingDisconnectAudioMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem, uncheckStateItem);
        return checkableMenuItemPtr;
    }
    static NESingleStateMenuItemPtr notifyCenterMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingNotifyCenterMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr settingMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingSettingsMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr feedbackMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingFeedbackMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr sipCallMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingSipCallMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NECheckableMenuItemPtr captionsMenu() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr checkableMenuItemPtr;
        checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingCaptionsMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem, uncheckStateItem);
        return checkableMenuItemPtr;
    }
    static NECheckableMenuItemPtr transcriptionMenu() {
        NEMenuItemInfo checkedStateItem;
        NEMenuItemInfo uncheckStateItem;
        NECheckableMenuItemPtr checkableMenuItemPtr;
        checkableMenuItemPtr =
            std::make_shared<NECheckableMenuItem>(NEMeetingMenuIDs::kMeetingTranscriptionMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                checkedStateItem, uncheckStateItem);
        return checkableMenuItemPtr;
    }
    static NESingleStateMenuItemPtr interpretationMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingInterpretationMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr beautyMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingBeautyMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr virtualBackgroundMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingVirtualBackgroundMenuId, NEMenuVisibility::VISIBLE_ALWAYS,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
    static NESingleStateMenuItemPtr liveMenu() {
        NEMenuItemInfo singleStateItem;
        NESingleStateMenuItemPtr singleStateMenuItemPtr;
        singleStateMenuItemPtr =
            std::make_shared<NESingleStateMenuItem>(NEMeetingMenuIDs::kMeetingLiveMenuId, NEMenuVisibility::VISIBLE_TO_HOST_ONLY,
                singleStateItem);
        return singleStateMenuItemPtr;
    }
};
 
 
class NEM_SDK_INTERFACE_EXPORT NEMeetingParams : public NEObject {
public:
    NEMeetingParams(const std::string& strDisplayName = "",
        const std::string& strMeetingNum = "",
        const std::string& subject = "",
        const std::string& strTag = "",
        const std::string& strPassword = "")
        : displayName(strDisplayName)
        , meetingNum(strMeetingNum)
        // , subject(subject)
        , tag(strTag)
        , password(strPassword) {}
 
    NEMeetingParams(std::string&& strDisplayName, std::string&& strMeetingNum, std::string&& subject, std::string&& strTag, std::string&& strPassword)
        : displayName(std::move(strDisplayName))
        , meetingNum(std::move(strMeetingNum))
        // , subject(std::move(subject))
        , tag(std::move(strTag))
        , password(std::move(strPassword)) {}
 
public:
    std::string displayName;
 
    std::string avatar;
 
    std::string meetingNum;
 
    // std::string subject;
 
    std::string tag;
 
    // NEMeetingRoleType roleType;
 
    std::string password;
 
    //    NEEncryptionConfig encryptionConfig;
 
    NEWatermarkConfig watermarkConfig;
};
 
class NEM_SDK_INTERFACE_EXPORT NEMeetingOptions : public NEObject {
public:
    NEMeetingOptions(bool bNoVideo = true,
        bool bNoAudio = true,
        bool bNoChat = false,
        bool bNoInvite = false,
        bool bNoScreenShare = true,
        bool bNoView = true,
        bool bNoWhiteboard = false,
        bool bNoRename = false,
        bool bNoSip = true,
        bool bNoMuteAllVideo = true,
        bool bNoMuteAllAudio = false,
        bool bAudioAINSEnabled = true,
        bool bShowMemberTag = false,
        bool bShowMeetingRemainingTip = false,
        bool bDetectMutedMic = true,
        bool bUnpubAudioOnMute = true,
        NEMeetingWindowMode bEmViewMode = NORMAL_MODE,
        NEMeetingChatroomConfig bChatroomConfigIn = NEMeetingChatroomConfig(),
        bool bNoCaptions = false,
        bool bAutoEnableCaptionsOnJoin = false,
        bool bNoTranscription = false)
        : noVideo(bNoVideo)
        , noAudio(bNoAudio)
        , showMeetingTime(false)
        , showNameInVideo(true)
        , enableSpeakerSpotlight(false)
        , noMinimize(true)
        , noSwitchCamera(false)
        , noSwitchAudioMode(false)
        , noLive(false)
        , showScreenShareUserVideo(true)
        , enableAudioShare(false)
        , showWhiteboardShareUserVideo(false)
        , enableTransparentWhiteboard(false)
        , showFloatingMicrophone(true)
        , noChat(bNoChat)
        , noInvite(bNoInvite)
        , noScreenShare(bNoScreenShare)
        , noView(bNoView)
        , noWhiteboard(bNoWhiteboard)
        , noRename(bNoRename)
        , noSip(bNoSip)
        , noMuteAllVideo(bNoMuteAllVideo)
        , noMuteAllAudio(bNoMuteAllAudio)
        , audioAINSEnabled(bAudioAINSEnabled)
        , showMemberTag(bShowMemberTag)
        , showMeetingRemainingTip(bShowMeetingRemainingTip)
        , detectMutedMic(bDetectMutedMic)
        , unpubAudioOnMute(bUnpubAudioOnMute)
        , defaultWindowMode(bEmViewMode)
        , meetingIdDisplayOption(kDisplayAll)
        , chatroomConfig(bChatroomConfigIn)
        , noCaptions(bNoCaptions)
        , autoEnableCaptionsOnJoin(bAutoEnableCaptionsOnJoin)
        , noTranscription(bNoTranscription) {}
 
public:
    bool noVideo;
 
    bool noAudio;
 
    bool showMeetingTime;
    bool showNameInVideo;
 
    bool enableSpeakerSpotlight;
 
    bool noMinimize;
 
    bool noSwitchCamera;
 
    bool noSwitchAudioMode;
 
    bool noLive;
 
    bool showScreenShareUserVideo;
 
    bool enableAudioShare;
 
    bool showWhiteboardShareUserVideo;
 
    bool enableTransparentWhiteboard;
 
    bool showFloatingMicrophone;
 
    bool noChat;
 
    bool noInvite;
 
    bool noScreenShare;
 
    bool noView;
 
    bool noWhiteboard;
 
    bool noRename;
 
    bool noSip;
 
    bool noMuteAllVideo;
 
    bool noMuteAllAudio;
 
    bool audioAINSEnabled;
 
    bool showMemberTag;
 
    bool showMeetingRemainingTip;
 
    bool detectMutedMic;
 
    bool unpubAudioOnMute;
 
    NEMeetingWindowMode defaultWindowMode;
 
    NEShowMeetingIdOption meetingIdDisplayOption;
 
    std::vector<NEMeetingMenuItemPtr> fullToolbarMenuItems;
 
    std::vector<NEMeetingMenuItemPtr> fullMoreMenuItems;
 
    std::vector<NEMeetingMenuItemPtr> memberActionMenuItems;
 
    int joinTimeout = 45 * 1000;
 
    NEMeetingChatroomConfig chatroomConfig;
 
    int audioProfile;
 
    bool showCloudRecordMenuItem = true;
 
    bool showCloudRecordingUI = true;
 
    bool enableAudioDeviceSwitch = true;
 
    bool noReadPhoneState = false;
 
    bool noNotifyCenter = false;
 
    bool noWebApps = false;
 
    bool noCaptions = false;
 
    bool autoEnableCaptionsOnJoin = false;
 
    bool noTranscription = false;
    int pluginNotifyDuration = 5000;
    bool showNotYetJoinedMembers = false;
    NEChatMessageNotificationType chatMessageNotificationType;
    bool enableDirectMemberMediaControlByHost = false;
    bool showParticipationTime;
    bool enableLeaveTheMeetingRequiresConfirmation;
};
 
class NEStartMeetingParams : public NEMeetingParams {
public:
    // NEMeetingScene scene;
 
    std::string extraData;
 
    std::string subject;
 
    std::list<NEMeetingControl> controls;
 
    std::map<std::string, NEMeetingRoleType> roleBinds;
};
 
class NEStartMeetingOptions : public NEMeetingOptions {
public:
    NECloudRecordConfig cloudRecordConfig;
 
    bool enableWaitingRoom = false;
 
    bool enableGuestJoin = false;
};
 
class NEJoinMeetingParams : public NEMeetingParams {};
 
class NEJoinMeetingOptions : public NEMeetingOptions {
public:
    bool enableMyAudioDeviceOnJoinRtc{true};
};
 
typedef struct tagNEMeetingItemSetting {
    bool cloudRecordOn{false};
 
    std::list<NEMeetingControl> controls;
    NEMeetingControl currentAudioControl{kAttendeeOffNone, "audio"};
    NEMeetingControl currentVideoControl{kAttendeeOffNone, "video"};
 
} NEMeetingItemSetting;
 
typedef struct tagNEMeetingItemLiveSetting {
    bool enable = false;
    std::string title;
    std::string password;
    bool allowAnonymousEnterChatRoom = true;      
    bool useMeetingChatRoomAsLiveChatRoom = true; 
    std::string webSite;                          
} NEMeetingItemLiveSetting;
 
enum NEMeetingType {
    NEMeetingTypeRandom = 1,
    NEMeetingTypePersonal,
    NEMeetingTypeReservation,
};
 
enum NEMeetingLiveAuthLevel {
    NEMeetingLiveAuthLevelNormal,
    NEMeetingLiveAuthLevelToken,
    NEMeetingLiveAuthLevelAppToken
};
 
enum NEMeetingItemLiveStatus {
    NEMeetingItemLiveStatusInvalid,
    NEMeetingItemLiveStatusInit,
    NEMeetingItemLiveStatusStarted,
    NEMeetingItemLiveStatusEnded
};
 
typedef struct tagNEMeetingItemLive {
    bool enable;
    NEMeetingLiveAuthLevel liveWebAccessControlLevel{NEMeetingLiveAuthLevelNormal};
    std::string hlsPullUrl;
    std::string httpPullUrl;
    std::string rtmpPullUrl;
    std::string liveUrl;
    std::string pushUrl;
    std::string chatRoomId;
    std::list<std::string> liveAVRoomUids;
    bool liveChatRoomEnable;
    std::string meetingNum;
    NEMeetingItemLiveStatus state{NEMeetingItemLiveStatusInvalid};
    std::string taskId;
    std::string title;
    bool liveChatRoomIndependent;
} NEMeetingItemLive;
 
enum NEMeetingFrequencyUnitType {
    NEMeetingFrequencyUnitTypeUndefine,
    NEMeetingFrequencyUnitTypeDay,
    NEMeetingFrequencyUnitTypeWeekday,
    NEMeetingFrequencyUnitTypeDayOfMonth,
    NEMeetingFrequencyUnitTypeWeekdayOfMonth
};
 
enum NEMeetingRecurringRuleType {
    NEMeetingRecurringRuleTypeUndefine,
    NEMeetingRecurringRuleTypeNo,
    NEMeetingRecurringRuleTypeDay,
    NEMeetingRecurringRuleTypeWeekday,
    NEMeetingRecurringRuleTypeWeek,
    NEMeetingRecurringRuleTypeTwoWeeks,
    NEMeetingRecurringRuleTypeDayOfMonth,
    NEMeetingRecurringRuleTypeCustom
};
 
enum NEMeetingRecurringEndRule {
    NEMeetingRecurringEndRuleTypeUndefine,
    NEMeetingRecurringEndRuleTypeDate,
    NEMeetingRecurringEndRuleTypeTimes
};
 
typedef struct tagNEMeetingCustomizedFrequency {
    int32_t stepSize{0};
    NEMeetingFrequencyUnitType stepUnit{NEMeetingFrequencyUnitTypeDay};
    std::list<int32_t> daysOfWeek;
    std::list<int32_t> daysOfMonth;
} NEMeetingCustomizedFrequency;
 
typedef struct tagNEMeetingRecurringRuleEndRule {
    std::string date;
    int times{0};
    NEMeetingRecurringEndRule type{NEMeetingRecurringEndRuleTypeDate};
} NEMeetingRecurringRuleEndRule;
 
typedef struct tagNEMeetingRecurringRule {
    NEMeetingRecurringRuleType type{NEMeetingRecurringRuleTypeNo};
    NEMeetingCustomizedFrequency customizedFrequency;
    NEMeetingRecurringRuleEndRule endRule;
} NEMeetingRecurringRule;
 
typedef struct tagNEScheduledMember {
    std::string userUuid;
    std::string role;
} NEScheduledMember;
 
typedef struct tagNEMeetingInterpreter {
    std::string userId;
    std::string firstLang;
    std::string secondLang;
    bool isValid;
} NEMeetingInterpreter;
 
class NEMeetingInterpretationSettings {
public:
    NEMeetingInterpretationSettings() = default;
 
    explicit NEMeetingInterpretationSettings(std::list<NEMeetingInterpreter> interpreters)
        : interpreterList(std::move(interpreters)) {}
 
    bool addInterpreter(const std::string& userId, const std::string& firstLang, const std::string& secondLang) {
        if (userId.empty() || firstLang.empty() || secondLang.empty()) {
            return false;
        }
        NEMeetingInterpreter interpreter;
        interpreter.userId = userId;
        interpreter.firstLang = firstLang;
        interpreter.secondLang = secondLang;
        interpreter.isValid = true;
        interpreterList.push_back(interpreter);
        return true;
    }
 
    bool addInterpreters(const std::list<NEMeetingInterpreter>& interpreters) {
        for (const auto& interpreter : interpreters) {
            if (interpreter.userId.empty() || interpreter.firstLang.empty() || interpreter.secondLang.empty()) {
                return false;
            }
            interpreterList.push_back(interpreter);
        }
        return true;
    }
 
    bool removeInterpreter(const std::string& userId) {
        for (auto it = interpreterList.begin(); it != interpreterList.end(); ++it) {
            if (it->userId == userId) {
                interpreterList.erase(it);
                return true;
            }
        }
        return false;
    }
 
    void clearInterpreterList() { interpreterList.clear(); }
 
    const std::list<NEMeetingInterpreter>& getInterpreterList() const { return interpreterList; }
 
    bool isEmpty() const { return interpreterList.empty(); }
 
    std::list<NEMeetingInterpreter> interpreterList;
};
 
typedef struct tagNEMeetingItem {
    int64_t meetingId{0};
    std::string meetingNum;
    std::string shortMeetingNum;
    std::string subject;
    std::string roomUuid;
    std::string ownerUserUuid;
    std::string ownerNickname;
    time_t startTime{0};
    time_t endTime{0};
    std::string password;
    NEMeetingItemSetting settings;
    NEMeetingItemStatus status{MEETING_INVALID};
    NEMeetingType meetingType{NEMeetingTypeRandom};
    bool noSip{false};
    bool waitingRoomEnabled{false};
    bool enableJoinBeforeHost{false};
    bool enableGuestJoin{false};
    std::string inviteUrl;
    NEMeetingItemLive live;
    std::string extraData;
    std::map<std::string, NEMeetingRoleType> roleBinds;
    NEMeetingRecurringRule recurringRule;
    std::list<NEScheduledMember> scheduledMemberList;
    std::string timezoneId;
    NEMeetingInterpretationSettings interpretationSettings;
    NECloudRecordConfig cloudRecordConfig;
    std::string sipCid;
} NEMeetingItem;
 
typedef struct tagNERemoteHistoryMeeting {
    int64_t anchorId{0};
    int64_t meetingId{0};
    std::string meetingNum;
    std::string subject;
    NEMeetingType type{NEMeetingTypeRandom};
    time_t roomEntryTime{0};
    time_t roomStartTime{0};
    std::string ownerAvatar;
    std::string ownerUserUuid;
    std::string ownerNickname;
    int64_t favoriteId{0};
    time_t roomEndTime{0};
    std::string timeZoneId;
} NERemoteHistoryMeeting;
 
enum NEChatroomExportAccess {
    NEChatroomExportAccessUnknown,
    NEChatroomExportAccessAvailable,
    NEChatroomExportAccessNoPermission,
    NEChatroomExportAccessOutOfDate,
};
 
typedef struct tagNEMeetingWebAppIconItem {
    std::string defaultIcon;
    std::string notifyIcon;
} NEMeetingWebAppIconItem;
 
enum NEMeetingWebAppItemType {
    NEMeetingWebAppItemTypeOfficial,
    NEMeetingWebAppItemTypeCorporate,
};
 
typedef struct tagNEChatroomInfo {
    int64_t chatroomId;
    NEChatroomExportAccess exportAccess;
} NEChatroomInfo;
 
typedef struct tagNEMeetingWebAppItem {
    std::string pluginId;
    std::string name;
    NEMeetingWebAppIconItem icon;
    std::string description;
    NEMeetingWebAppItemType type{NEMeetingWebAppItemTypeOfficial};
    std::string homeUrl;
    std::string sessionId;
} NEMeetingWebAppItem;
 
typedef struct tagNERemoteHistoryMeetingDetail {
    NEChatroomInfo chatroomInfo;
    std::list<NEMeetingWebAppItem> pluginInfoList;
} NERemoteHistoryMeetingDetail;
 
enum NELoginType {
    kLoginTypeUnknown,
    kLoginTypeNEPassword,
    kLoginTypeNEAccount,
    kLoginTypeSSOToken, 
};
 
typedef struct tagAccountInfo {
    NELoginType loginType;
 
    std::string username;
 
    std::string appKey;
 
    std::string accountId;
 
    std::string accountToken;
 
    std::string personalMeetingId;
 
    std::string shortMeetingNum;
 
    std::string accountName;
} AccountInfo;
 
typedef struct tagNEHistoryMeetingItem {
    long meetingId;
 
    std::string meetingNum;
 
    std::string shortMeetingNum;
 
    std::string subject;
    std::string password;
 
    std::string nickname;
 
    std::string sipId;
} NEHistoryMeetingItem;
 
typedef enum class tagNEMeetingLanguage {
    kNEAutomatic, 
    kNEChinese,   
    kNEEnglish,   
    kNEJapanese,  
} NEMeetingLanguage;
 
typedef struct tagNELocalHistoryMeeting {
    std::string meetingNum;
    int64_t meetingId;
    std::string shortMeetingNum;
    std::string subject;
    std::string password;
    std::string nickname;
    std::string sipId;
} NELocalHistoryMeeting;
 
// 邀请状态枚举
enum NEMeetingInviteStatus {
    UNKNOWN,        // 未知状态
    WAITING_CALL,   // 等待接听
    CALLING,        // 呼叫中
    REJECTED,       // 已拒接
    NO_ANSWER,      // 未接听
    ERROR,          // 呼叫异常
    REMOVED,        // 已移除
    CANCELED,       // 已取消
    WAITING_JOINED  // 待入会
};
 
// 邀请信息结构体
struct NEMeetingInviteInfo {
    std::string meetingNum;     // 会议号
    std::string inviterName;    // 邀请者昵称
    std::string inviterAvatar;  // 邀请者头像
    std::string subject;        // 会议主题
    bool preMeetingInvitation;  // 会前邀请，当在预约会议被添加时触发，则为true；会中主动邀请，则为false
};
 
// 呼叫类型
enum NERoomSipDeviceInviteProtocolType {
    kProtocolTypeIP = 1,  // IP呼叫协议
    kProtocolTypeH323     // H323呼叫协议
};
 
typedef struct tagNERoomSystemDevice {
    NERoomSipDeviceInviteProtocolType protocol;  // 呼叫协议类型
    std::string deviceAddress;                   // 设备地址
    std::string name;                            // 昵称
} NERoomSystemDevice;
 
typedef struct tagNERoomSIPCallInfo {
    std::string userUuid;  // 用户的uuid
    std::string userName;   // 用户名
    std::string isRepeatedCall;                   // 是否重复呼叫，true：是；false：否
} NERoomSIPCallInfo;
 
typedef struct tagNEMeetingRecordFileInfo {
    std::string type;  // 文件的类型，即文件扩展名。aac：实时音频录制文件、mp4：实时视频录制文件、flv：互动直播视频录制文件
    bool mix{false};       // 是否为混合录制文件，true：混合录制文件，false：单人录制文件。
    std::string filename;  // 文件名
    std::string md5;       // 文件md5
    int64_t size{0};       // 文件大小，单位为字节
    std::string url;       // 文件下载地址
    int64_t vid{0};        // 点播文件id
    int pieceIndex{0};     // 录制文件分片索引
    std::string userUuid;  // 单录时，用户的uuId，这里为NERoom里的uuid
    std::string nickname;  // 单录时，用户会议中的昵称
} NEMeetingRecordFileInfo;
 
typedef struct tagNEMeetingRecord {
    std::string recordId;                           // 录制id
    long recordStartTime{0};                        // 录制开始时间，毫秒时间戳
    long recordEndTime{0};                          // 录制结束时间，毫秒时间戳
    std::vector<NEMeetingRecordFileInfo> infoList;  // 单次录制生成的所有录制文件对应信息
} NEMeetingRecord;
 
typedef struct tagNEMeetingTranscriptionInterval {
    int64_t start;  // 转写开始时间戳，单位为ms
    int64_t stop;   // 转写开始时间戳，单位为ms
} NEMeetingTranscriptionInterval;
 
typedef struct tagNEMeetingTranscriptionInfo {
    int state;                                               
    std::vector<NEMeetingTranscriptionInterval> timeRanges;  
    std::vector<std::string>
        originalNosFileKeys;  
    std::vector<std::string> txtNosFileKeys;   
    std::vector<std::string> wordNosFileKeys;  
    std::vector<std::string> pdfNosFileKeys;   
} NEMeetingTranscriptionInfo;
 
typedef struct tagNEMeetingTranscriptionMessage {
    std::string fromUserUuid;  
    std::string fromNickname;  
    std::string content;       
    int64_t timestamp;         
} NEMeetingTranscriptionMessage;
 
enum class NEMeetingChatMessageType {
    kText,   
    kFile,   
    kImage,  
    kCustom  
};
 
typedef struct tagNEMeetingChatMessage {
    std::string messageUuid;                  
    NEMeetingChatMessageType messageType;     
    std::string fromUserUuid;                 
    std::string fromNick;                     
    std::string fromAvatar;                   
    std::vector<std::string> toUserUuidList;  
    int64_t timeLong{0};                      
} NEMeetingChatMessage;
 
typedef enum tagNEChatroomMessageSearchOrder {
    kChatroomMessageSearchOrderDesc,  
    kChatroomMessageSearchOrderAsc    
} NEChatroomMessageSearchOrder;
 
typedef struct tagNEChatroomHistoryMessageSearchOption {
    int64_t startTime;  
    int limit;                                                                                             
    NEChatroomMessageSearchOrder order{tagNEChatroomMessageSearchOrder::kChatroomMessageSearchOrderDesc};  
} NEChatroomHistoryMessageSearchOption;
 
NNEM_SDK_INTERFACE_END_DECLS
 
#endif  // NEM_SDK_INTERFACE_DEFINE_METTING_H_