AI Companion

IMeetingService
  └─► GetMeetingAICompanionController()
        ├─► GetMeetingSmartSummaryHelper()              // DEPRECATED
        ├─► GetMeetingAICompanionSmartSummaryHelper()   // Smart Summary
        └─► GetMeetingAICompanionQueryHelper()          // AI Query/Q&A

IMeetingAICompanionController* aiCtrl = meetingService->GetMeetingAICompanionController();
if (!aiCtrl) return;

IMeetingAICompanionSmartSummaryHelper* summaryHelper = 
    aiCtrl->GetMeetingAICompanionSmartSummaryHelper();
if (!summaryHelper) return;

class SmartSummaryEventHandler : public IMeetingAICompanionSmartSummaryHelperEvent {
public:
    void onSmartSummaryStateNotSupported() override {
        // Meeting doesn't support smart summary
        // Account may not have the feature enabled
    }
    
    void onSmartSummaryStateSupportedButDisabled(
        IMeetingEnableSmartSummaryHandler* handler) override 
    {
        // Feature supported but needs to be enabled
        if (handler) {
            if (handler->IsForRequest()) {
                // This is a request from another user
                // Host should decide whether to enable
            } else {
                // Current user can enable directly
                handler->EnableSmartSummary();
            }
        }
    }
    
    void onSmartSummaryStateEnabledButNotStarted(
        IMeetingStartSmartSummaryHandler* handler) override 
    {
        // Feature enabled, ready to start
        if (handler) {
            if (handler->IsForRequest()) {
                // Request from another user to start
            } else {
                // Can start directly
                handler->StartSmartSummary();
            }
        }
    }
    
    void onSmartSummaryStateStarted(
        IMeetingStopSmartSummaryHandler* handler) override 
    {
        // Smart summary is now active
        // handler is nullptr if current user can't stop it
        if (handler) {
            // Can stop if needed
            // handler->StopSmartSummary();
        }
    }
    
    void onFailedToStartSmartSummary(bool bTimeout) override {
        if (bTimeout) {
            // Request timed out
        } else {
            // Host/cohost declined the request
        }
    }
    
    void onSmartSummaryEnableRequestReceived(
        IMeetingApproveEnableSmartSummaryHandler* handler) override 
    {
        // Another user requested to enable smart summary
        // Host/cohost receives this callback
        if (handler) {
            unsigned int requesterId = handler->GetSenderUserID();
            // Approve or handle the request
            handler->ContinueApprove();
        }
    }
    
    void onSmartSummaryStartRequestReceived(
        IMeetingApproveStartSmartSummaryHandler* handler) override 
    {
        // Another user requested to start smart summary
        if (handler) {
            unsigned int requesterId = handler->GetSenderUserID();
            handler->Approve();  // or handler->Decline();
        }
    }
    
    void onSmartSummaryEnableActionCallback(
        IMeetingEnableSmartSummaryActionHandler* handler) override 
    {
        // Confirmation dialog for enabling smart summary
        if (handler) {
            const zchar_t* title = handler->GetTipTitle();
            const zchar_t* tip = handler->GetTipString();
            // Show UI with tip, then:
            handler->Confirm();  // or handler->Cancel();
        }
    }
};

// Register the handler
SmartSummaryEventHandler summaryHandler;
summaryHelper->SetEvent(&summaryHandler);

IMeetingAICompanionController* aiCtrl = meetingService->GetMeetingAICompanionController();
if (!aiCtrl) return;

IMeetingAICompanionQueryHelper* queryHelper = 
    aiCtrl->GetMeetingAICompanionQueryHelper();
if (!queryHelper) return;

class AIQueryEventHandler : public IMeetingAICompanionQueryHelperEvent {
public:
    void onQueryStateNotSupported() override {
        // Meeting doesn't support AI query
    }
    
    void onQueryStateSupportedButDisabled(
        IMeetingEnableQueryHandler* pHandler) override 
    {
        // Query supported but disabled
        if (pHandler && !pHandler->IsForRequest()) {
            pHandler->EnableQuery

bool canChange = false;
SDKError err = queryHelper->CanChangeQuerySetting(canChange);
if (err == SDKERR_SUCCESS && canChange) {
    // Set who can ask questions
    queryHelper->ChangeQuerySettings(
        MeetingAICompanionQuerySettingOptions_WhenParticipantsJoin);
    
    // Get current setting
    MeetingAICompanionQuerySettingOptions currentSetting = 
        queryHelper->GetSelectedQuerySetting();
}

bool isAvailable = false;
queryHelper->IsAICompanionQueryLegalNoticeAvailable(isAvailable);
if (isAvailable) {
    const zchar_t* prompt = queryHelper->GetAICompanionQueryLegalNoticesPrompt();
    const zchar_t* explained = queryHelper->GetAICompanionQueryLegalNoticesExplained();
    // Display legal notice to user
}

IMeetingAICompanionController* aiCtrl = meetingService->GetMeetingAICompanionController();

// Check support
if (aiCtrl->IsTurnoffAllAICompanionsSupported()) {
    // Can turn off all AI features
    if (aiCtrl->CanTurnOffAllAICompanions()) {
        bool deleteAssets = false;  // Keep or delete meeting assets
        aiCtrl->TurnOffAllAICompanions(deleteAssets);
    }
}

if (aiCtrl->IsTurnOnAllAICompanionsSupported()) {
    // Can turn on all AI features
    if (aiCtrl->CanTurnOnAllAICompanions()) {
        aiCtrl->TurnOnAllAICompanions();
    }
}

// For non-host users
if (aiCtrl->CanRequestTurnoffAllAICompanions()) {
    aiCtrl->RequestTurnoffAllAICompanions();
}

if (aiCtrl->CanRequestTurnOnAllAICompanions()) {
    aiCtrl->RequestTurnOnAllAICompanions();
}

class AICompanionCtrlEventHandler : public IMeetingAICompanionCtrlEvent {
public:
    void onAICompanionFeatureTurnOffByParticipant(
        IAICompanionFeatureTurnOnAgainHandler* handler) override 
    {
        // Participant turned off AI feature before host joined
        if (handler) {
            IList<AICompanionFeature>* features = handler->GetFeatureList();
            IList<AICompanionFeature>* deletedAssets = 
                handler->GetAssetsDeletedFeatureList();
            
            // Host can turn features back on
            handler->TurnOnAgain();
            // Or agree to keep them off
            // handler->AgreeTurnOff();
        }
    }
    
    void onAICompanionFeatureSwitchRequested(
        IAICompanionFeatureSwitchHandler* handler) override 
    {
        // User requested to toggle AI features
        if (handler) {
            unsigned int requesterId = handler->GetRequestUserID();
            bool isTurningOn = handler->IsTurnOn();
            
            bool deleteAssets = false;
            handler->Agree(deleteAssets);
            // or handler->Decline();
        }
    }
    
    void onAICompanionFeatureSwitchRequestResponse(
        bool bTimeout, bool bAgree, bool bTurnOn) override 
    {
        // Response to our request
        if (!bTimeout && bAgree) {
            // Request approved
        }
    }
    
    void onAICompanionFeatureCanNotBeTurnedOff(
        IList<AICompanionFeature>* features) override 
    {
        // These features cannot be turned off
        if (features) {
            for (int i = 0; i < features->GetCount(); i++) {
                AICompanionFeature feature = features->GetItem(i);
                // Handle each feature
            }
        }
    }
    
    void onHostUnsupportedStopNotesRequest() override {
        // Host's client doesn't support stopping Notes
    }
};

// Register controller event handler
AICompanionCtrlEventHandler ctrlHandler;
aiCtrl->SetEvent(&ctrlHandler);

class SmartSummaryManager {
private:
    IMeetingAICompanionController* m_aiCtrl = nullptr;
    IMeetingAICompanionSmartSummaryHelper* m_summaryHelper = nullptr;
    
    class SummaryHandler : public IMeetingAICompanionSmartSummaryHelperEvent {
    public:
        SmartSummaryManager* m_manager = nullptr;
        
        void onSmartSummaryStateNotSupported() override {
            m_manager->OnFeatureNotSupported();
        }
        
        void onSmartSummaryStateSupportedButDisabled(
            IMeetingEnableSmartSummaryHandler* handler) override {
            if (handler && !handler->IsForRequest()) {
                handler->EnableSmartSummary();
            }
        }
        
        void onSmartSummaryStateEnabledButNotStarted(
            IMeetingStartSmartSummaryHandler* handler) override {
            if (handler && !handler->IsForRequest()) {
                handler->StartSmartSummary();
            }
        }
        
        void onSmartSummaryStateStarted(
            IMeetingStopSmartSummaryHandler* handler) override {
            m_manager->OnSummaryStarted(handler);
        }
        
        void onFailedToStartSmartSummary(bool bTimeout) override {
            m_manager->OnStartFailed(bTimeout);
        }
        
        void onSmartSummaryEnableRequestReceived(
            IMeetingApproveEnableSmartSummaryHandler* handler) override {
            if (handler) handler->ContinueApprove();
        }
        
        void onSmartSummaryStartRequestReceived(
            IMeetingApproveStartSmartSummaryHandler* handler) override {
            if (handler) handler->Approve();
        }
        
        void onSmartSummaryEnableActionCallback(
            IMeetingEnableSmartSummaryActionHandler* handler) override {
            if (handler) handler->Confirm();
        }
    };
    
    SummaryHandler m_handler;
    IMeetingStopSmartSummaryHandler* m_stopHandler = nullptr;
    
public:
    bool Initialize(IMeetingService* meetingService) {
        m_aiCtrl = meetingService->GetMeetingAICompanionController();
        if (!m_aiCtrl) return false;
        
        m_summaryHelper = m_aiCtrl->GetMeetingAICompanionSmartSummaryHelper();
        if (!m_summaryHelper) return false;
        
        m_handler.m_manager = this;
        m_summaryHelper->SetEvent(&m_handler);
        return true;
    }
    
    void OnFeatureNotSupported() {
        // Update UI - feature not available
    }
    
    void OnSummaryStarted(IMeetingStopSmartSummaryHandler* handler) {
        m_stopHandler = handler;
        // Update UI - summary is recording
    }
    
    void OnStartFailed(bool timeout) {
        // Show error message
    }
    
    void StopSummary() {
        if (m_stopHandler) {
            m_stopHandler->StopSmartSummary();
            m_stopHandler = nullptr;
        }
    }
};