Transcription

┌─────────────────────────────────────────────────────────────────┐
│                    TRANSCRIPTION FLOW                           │
├─────────────────────────────────────────────────────────────────┤
│  1. Enable transcription → startLiveTranscription()             │
│  2. Receive captions → onLiveTranscriptionMsgInfoReceived()     │
│  3. Display/process text                                        │
└─────────────────────────────────────────────────────────────────┘

#pragma once
#include <windows.h>
#include <string>
#include <vector>
#include <functional>
#include "zoom_video_sdk_interface.h"

USING_ZOOM_VIDEO_SDK_NAMESPACE

struct TranscriptionMessage {
    std::wstring speakerName;
    std::wstring text;
    bool isFinal;
    unsigned long long timestamp;
};

class TranscriptionManager {
public:
    TranscriptionManager(IZoomVideoSDK* sdk);
    
    // Control
    bool StartTranscription();
    bool StopTranscription();
    bool IsTranscribing() const { return m_isTranscribing; }
    
    // Language settings
    bool SetSpokenLanguage(ILiveTranscriptionLanguage* language);
    bool SetTranslationLanguage(ILiveTranscriptionLanguage* language);
    std::vector<ILiveTranscriptionLanguage*> GetAvailableLanguages();
    
    // Callbacks from delegate
    void OnStatusChanged(ZoomVideoSDKLiveTranscriptionStatus status);
    void OnMessageReceived(ILiveTranscriptionMessageInfo* info);
    void OnOriginalLanguageReceived(ILiveTranscriptionMessageInfo* info);
    void OnError(ILiveTranscriptionLanguage* spoken, 
                 ILiveTranscriptionLanguage* transcript);
    
    // Set message handler
    using MessageCallback = std::function<void(const TranscriptionMessage&)>;
    void SetMessageHandler(MessageCallback callback) { m_callback = callback; }
    
private:
    IZoomVideoSDK* m_sdk;
    IZoomVideoSDKLiveTranscriptionHelper* m_helper;
    bool m_isTranscribing;
    MessageCallback m_callback;
};

#include "TranscriptionManager.h"
#include <iostream>

TranscriptionManager::TranscriptionManager(IZoomVideoSDK* sdk)
    : m_sdk(sdk)
    , m_helper(nullptr)
    , m_isTranscribing(false) {
}

bool TranscriptionManager::StartTranscription() {
    m_helper = m_sdk->getLiveTranscriptionHelper();
    if (

class MyDelegate : public IZoomVideoSDKDelegate {
private:
    TranscriptionManager* m_transcription;
    
public:
    MyDelegate(IZoomVideoSDK* sdk) {
        m_transcription = new TranscriptionManager(sdk);
        
        // Set message handler
        m_transcription->SetMessageHandler([](const TranscriptionMessage& msg) {
            // Process transcription (e.g., save to file, analyze)
            if (msg.isFinal) {
                SaveTranscript(msg.speakerName, msg.text);
            }
        });
    }
    
    void onSessionJoin() override {
        // Start transcription
        m_transcription->StartTranscription();
    }
    
    void onLiveTranscriptionStatus(ZoomVideoSDKLiveTranscriptionStatus status) override {
        m_transcription->OnStatusChanged(status);
    }
    
    void onLiveTranscriptionMsgInfoReceived(ILiveTranscriptionMessageInfo* info) override {
        m_transcription->OnMessageReceived(info);
    }
    
    void onOriginalLanguageMsgReceived(ILiveTranscriptionMessageInfo* info) override {
        m_transcription->OnOriginalLanguageReceived(info);
    }
    
    void onLiveTranscriptionMsgError(ILiveTranscriptionLanguage* spoken,
                                      ILiveTranscriptionLanguage* transcript) override {
        m_transcription->OnError(spoken, transcript);
    }
    
    // ... other callbacks
};

auto languages = transcriptionManager->GetAvailableLanguages();
for (auto lang : languages) {
    std::wcout << lang->getLTTLanguageID() << L": " 
               << lang->getLTTLanguageName() << std::endl;
}

if (helper->canStartLiveTranscription()) {
    helper->startLiveTranscription();
}

void onSessionJoin() override {
    sdk->getAudioHelper()->startAudio();  // Connect audio first
    transcription->StartTranscription();
}

auto languages = manager->GetAvailableLanguages();
for (auto lang : languages) {
    if (wcscmp(lang->getLTTLanguageID(), L"en") == 0) {
        manager->SetSpokenLanguage(lang);
        break;
    }
}