Chat

IMeetingService
    └── GetMeetingChatController() → IMeetingChatController
                                         ├── SetEvent(IMeetingChatCtrlEvent*)
                                         ├── GetChatMessageBuilder() → IChatMsgInfoBuilder
                                         ├── SendChatMsgTo(IChatMsgInfo*)
                                         └── GetChatStatus()

#include <meeting_service_interface.h>
#include <meeting_service_components/meeting_chat_interface.h>

// MeetingChatEventListener.h
#pragma once
#include <meeting_service_components/meeting_chat_interface.h>

class MeetingChatEventListener : public ZOOMSDK::IMeetingChatCtrlEvent {
public:
    MeetingChatEventListener() = default;
    virtual ~MeetingChatEventListener() = default;

    // Called when a new chat message arrives
    virtual void onChatMsgNotification(
        ZOOMSDK::IChatMsgInfo* chatMsg,
        const zchar_t* content
    ) override;

    // Called when chat privileges change
    virtual void onChatStatusChangedNotification(
        ZOOMSDK::ChatStatus* status
    ) override;

    // Called when a message is deleted
    virtual void onChatMsgDeleteNotification(
        const zchar_t* msgID,
        ZOOMSDK::SDKChatMessageDeleteType deleteBy
    ) override;

    // Called when a message is edited
    virtual void onChatMessageEditNotification(
        ZOOMSDK::IChatMsgInfo* chatMsg
    ) override;

    // Called when meeting chat sharing status changes
    virtual void onShareMeetingChatStatusChanged(bool isStart) override;

    // File transfer callbacks
    virtual void onFileSendStart(ZOOMSDK::ISDKFileSender* sender) override;
    virtual void onFileReceived(ZOOMSDK::ISDKFileReceiver* receiver) override;
    virtual void onFileTransferProgress(ZOOMSDK::SDKFileTransferInfo* info) override;
};

// MeetingChatEventListener.cpp
#include "MeetingChatEventListener.h"
#include <iostream>

using namespace ZOOMSDK;

void MeetingChatEventListener::onChatMsgNotification(
    IChatMsgInfo* chatMsg,
    const zchar_t* content
) {
    if (chatMsg && content) {
        // Get sender information
        unsigned int senderId = chatMsg->GetSenderUserId();
        const zchar_t* senderName = chatMsg->GetSenderDisplayName();
        
        // Get message details
        const zchar_t* msgContent = chatMsg->GetContent();
        SDKChatMessageType msgType = chatMsg->GetChatMessageType();
        
        std::wcout << L"[Chat] " << senderName << L": " << msgContent << std::endl;
        
        // Check message type
        switch (msgType) {
            case SDKChatMessageType_To_All:
                std::cout << "  (sent to everyone)" << std::endl;
                break;
            case SDKChatMessageType_To_Individual:
                std::cout << "  (private message)" << std::endl;
                break;
            case SDKChatMessageType_To_WaitingRoomUsers:
                std::cout << "  (to waiting room)" << std::endl;
                break;
        }
        
        // Check if this is a threaded reply
        const zchar_t* threadId = chatMsg->GetThreadID();
        if (threadId && wcslen(threadId) > 0) {
            std::wcout << L"  Thread ID: " << threadId << std::endl;
        }
    }
}

void MeetingChatEventListener::onChatStatusChangedNotification(ChatStatus* status) {
    if (status) {
        std::cout << "Chat status changed" << std::endl;
        // Check what chat privileges are available
    }
}

void MeetingChatEventListener::onChatMsgDeleteNotification(
    const zchar_t* msgID,
    SDKChatMessageDeleteType deleteBy
) {
    std::wcout << L"Message deleted: " << msgID << std::endl;
    switch (deleteBy) {
        case SDKChatMessageDeleteType_By_Self:
            std::cout << "  (deleted by sender)" << std::endl;
            break;
        case SDKChatMessageDeleteType_By_Host:
            std::cout << "  (deleted by host)" << std::endl;
            break;
        case SDKChatMessageDeleteType_By_DLP:
            std::cout << "  (deleted by DLP policy)" << std::endl;
            break;
    }
}

void MeetingChatEventListener::onChatMessageEditNotification(IChatMsgInfo* chatMsg) {
    if (chatMsg) {
        std::wcout << L"Message edited: " << chatMsg->GetContent() << std::endl;
    }
}

void MeetingChatEventListener::onShareMeetingChatStatusChanged(bool isStart) {
    std::cout << "Share meeting chat: " << (isStart ? "started" : "stopped") << std::endl;
}

void MeetingChatEventListener::onFileSendStart(ISDKFileSender* sender) {
    std::cout << "File send started" << std::endl;
}

void MeetingChatEventListener::onFileReceived(ISDKFileReceiver* receiver) {
    std::cout << "File received" << std::endl;
}

void MeetingChatEventListener::onFileTransferProgress(SDKFileTransferInfo* info) {
    // Handle file transfer progress
}

// Global variables
IMeetingChatController* g_chatController = nullptr;
MeetingChatEventListener* g_chatListener = nullptr;

void initializeChat(IMeetingService* meetingService) {
    // Get the chat controller
    g_chatController = meetingService->GetMeetingChatController();
    if (!g_chatController) {
        std::cerr << "Failed to get chat controller" << std::endl;
        return;
    }
    
    // Create and set event listener
    g_chatListener = new MeetingChatEventListener();
    SDKError err = g_chatController->SetEvent(g_chatListener);
    if (err != SDKERR_SUCCESS) {
        std::cerr << "Failed to set chat event listener: " << err << std::endl;
        return;
    }
    
    std::cout << "Chat controller initialized" << std::endl;
}

void sendMessageToAll(const wchar_t* message) {
    if (!g_chatController) return;
    
    // Get the message builder
    IChatMsgInfoBuilder* builder = g_chatController->GetChatMessageBuilder();
    if (!builder) {
        std::cerr << "Failed to get message builder" << std::endl;
        return;
    }
    
    // Build the message
    builder->SetContent(message);
    builder->SetReceiver(0);  // 0 = everyone
    builder->SetMessageType(SDKChatMessageType_To_All);
    
    // Build and send
    IChatMsgInfo* msgInfo = builder->Build();
    if (msgInfo) {
        SDKError err = g_chatController->SendChatMsgTo(msgInfo);
        if (err == SDKERR_SUCCESS) {
            std::cout << "Message sent successfully" << std::endl;
        } else {
            std::cerr << "Failed to send message: " << err << std::endl;
        }
    }
}

void sendPrivateMessage(unsigned int userId, const wchar_t* message) {
    if (!g_chatController) return;
    
    IChatMsgInfoBuilder* builder = g_chatController->GetChatMessageBuilder();
    if (!builder) return;
    
    builder->SetContent(message);
    builder->SetReceiver(userId);  // Specific user ID
    builder->SetMessageType(SDKChatMessageType_To_Individual);
    
    IChatMsgInfo* msgInfo = builder->Build();
    if (msgInfo) {
        SDKError err = g_chatController->SendChatMsgTo(msgInfo);
        if (err == SDKERR_SUCCESS) {
            std::cout << "Private message sent" << std::endl;
        }
    }
}

void sendFormattedMessage() {
    if (!g_chatController) return;
    
    IChatMsgInfoBuilder* builder = g_chatController->GetChatMessageBuilder();
    if (!builder) return;
    
    // Set content: "Hello, this is BOLD and this is italic"
    const wchar_t* content = L"Hello, this is BOLD and this is italic";
    builder->SetContent(content);
    builder->SetReceiver(0);
    builder->SetMessageType(SDKChatMessageType_To_All);
    
    // Apply bold to "BOLD" (positions 14-17, 0-indexed)
    builder->SetBold(14, 18);
    
    // Apply italic to "italic" (positions 32-37)
    builder->SetItalic(32, 38);
    
    // Build and send
    IChatMsgInfo* msgInfo = builder->Build();
    if (msgInfo) {
        g_chatController->SendChatMsgTo(msgInfo);
    }
}

void sendMessageWithLink() {
    if (!g_chatController) return;
    
    IChatMsgInfoBuilder* builder = g_chatController->GetChatMessageBuilder();
    if (!builder) return;
    
    // Set content with link text
    const wchar_t* content = L"Check out this website for more info";
    builder->SetContent(content);
    builder->SetReceiver(0);
    builder->SetMessageType(SDKChatMessageType_To_All);
    
    // Create link attributes
    InsertLinkAttrs linkAttrs;
    linkAttrs.insertLinkUrl = L"https://zoom.us";
    
    // Apply link to "this website" (positions 10-21)
    builder->SetInsertLink(linkAttrs, 10, 22);
    
    IChatMsgInfo* msgInfo = builder->Build();
    if (msgInfo) {
        g_chatController->SendChatMsgTo(msgInfo);
    }
}

void sendThreadedReply(const wchar_t* threadId, const wchar_t* message) {
    if (!g_chatController) return;
    
    IChatMsgInfoBuilder* builder = g_chatController->GetChatMessageBuilder();
    if (!builder) return;
    
    builder->SetContent(message);
    builder->SetReceiver(0);
    builder->SetMessageType(SDKChatMessageType_To_All);
    builder->SetThreadId(threadId);  // Reply to existing thread
    
    IChatMsgInfo* msgInfo = builder->Build();
    if (msgInfo) {
        g_chatController->SendChatMsgTo(msgInfo);
    }
}

void onInMeeting(IMeetingService* meetingService) {
    // Initialize chat when in meeting
    initializeChat(meetingService);
    
    // Send a greeting
    sendMessageToAll(L"Hello everyone! Bot has joined the meeting.");
}

// Call from your meeting status callback
void MeetingServiceEventListener::onMeetingStatusChanged(
    MeetingStatus status,
    int iResult
) {
    if (status == MEETING_STATUS_INMEETING) {
        onInMeeting(g_meetingService);
    }
}

enum SDKChatMessageType {
    SDKChatMessageType_To_None,              // Invalid
    SDKChatMessageType_To_All,               // To everyone
    SDKChatMessageType_To_Individual,        // Private message
    SDKChatMessageType_To_Individual_Panelist,  // Webinar panelist
    SDKChatMessageType_To_WaitingRoomUsers   // To waiting room
};

SDKError err = g_chatController->SendChatMsgTo(msgInfo);
switch (err) {
    case SDKERR_SUCCESS:
        std::cout << "Message sent" << std::endl;
        break;
    case SDKERR_INVALID_PARAMETER:
        std::cerr << "Invalid message parameters" << std::endl;
        break;
    case SDKERR_NO_PERMISSION:
        std::cerr << "No permission to send chat" << std::endl;
        break;
    case SDKERR_WRONG_USAGE:
        std::cerr << "Chat not available (not in meeting?)" << std::endl;
        break;
    default:
        std::cerr << "Failed to send: " << err << std::endl;
}