zoom-meeting-sdk-windows

Par anthropics · knowledge-work-plugins

Zoom Meeting SDK pour Windows - SDK C++ natif permettant d'intégrer des réunions Zoom dans des applications de bureau Windows. Prend en charge une architecture d'interface utilisateur personnalisée avec données vidéo/audio brutes, des bots headless et une intégration poussée des fonctionnalités de réunion. Inclut des patterns d'architecture SDK et la gestion de la boucle de messages Windows.

npx skills add https://github.com/anthropics/knowledge-work-plugins --skill zoom-meeting-sdk-windows

Zoom Meeting SDK (Windows)

Intégrez les capacités de réunion Zoom dans les applications de bureau Windows pour les intégrations C++ natives et les bots sans interface.

Nouveau sur Zoom SDK ? Commencez ici !

Le moyen le plus rapide de maîtriser le SDK :

  1. Pattern architectural du SDK - Apprenez le pattern universel qui fonctionne pour TOUS les 35+ features
  2. Pattern d'authentification - Obtenez un bot fonctionnel rejoignant les réunions
  3. Boucle de messages Windows - Corrigez la #1 raison pour laquelle les callbacks ne se déclenchent pas

Vous construisez une interface personnalisée ?

Vous avez des problèmes ?

Prérequis

  • Application Zoom avec identifiants Meeting SDK (Client ID & Secret)
  • Visual Studio 2019/2022 ou ultérieur
  • Windows 10 ou ultérieur
  • Environnement de développement C++
  • vcpkg pour la gestion des dépendances

Besoin d'aide avec l'authentification ? Consultez la skill zoom-oauth pour la génération de token JWT.

Préférences et apprentissages du projet

IMPORTANT : Ce sont des préférences hard-won tirées de l'expérience réelle des projets. Suivez ces consignes lors de la création de nouveaux projets.

N'utilisez PAS CMake — Utilisez le .vcxproj Visual Studio natif

Créez toujours un projet Visual Studio natif .sln + .vcxproj, pas un projet CMake. Raisons :

  • Plus standard et familier pour les développeurs Windows C++
  • Les développeurs peuvent double-cliquer le .sln pour l'ouvrir dans Visual Studio immédiatement
  • Les paramètres du projet (répertoires d'inclusion, répertoires de lib, définitions du préprocesseur) sont plus faciles à voir et éditer dans l'interface VS Property Pages
  • Aucune étape de configuration ou tooling CMake supplémentaire requise
  • Plus convivial et facile à comprendre et maintenir pour les développeurs

config.json doit être visible dans Solution Explorer

Le fichier config.json (contenant sdk_jwt, meeting_number, passcode) doit être :

  1. Inclus dans le .vcxproj comme élément <None> avec <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  2. Placé dans un filtre "Config" dans le fichier .vcxproj.filters pour apparaître sous un dossier "Config" dans Solution Explorer
  3. Facilement éditable par les développeurs directement depuis Solution Explorer — ils ne devraient jamais avoir besoin de le chercher dans l'Explorateur de fichiers

Exemple d'entrée .vcxproj :

<ItemGroup>
  <None Include="config.json">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </None>
</ItemGroup>

Exemple d'entrée .vcxproj.filters :

<ItemGroup>
  <Filter Include="Config">
    <UniqueIdentifier>{GUID-HERE}</UniqueIdentifier>
  </Filter>
</ItemGroup>
<ItemGroup>
  <None Include="config.json">
    <Filter>Config</Filter>
  </None>
</ItemGroup>

Aperçu

Le SDK Windows est un SDK C++ natif conçu pour :

  • Applications de bureau - Applications Windows natives avec contrôle UI complet
  • Bots sans interface - Rejoindre les réunions sans interface
  • Accès aux médias bruts - Capturer/envoyer les streams audio/vidéo
  • Enregistrement local - Enregistrer les réunions localement ou dans le cloud

Insight architectural clé

Le SDK suit un pattern universel en 3 étapes pour chaque feature :

  1. Obtenir le contrôleur (singleton) : meetingService->Get[Feature]Controller()
  2. Implémenter l'observateur d'événements : class MyListener : public I[Feature]Event { ... }
  3. Enregistrer et utiliser : controller->SetEvent(listener) puis appeler les méthodes

Cela fonctionne pour TOUS les features : audio, vidéo, chat, enregistrement, participants, partage d'écran, salles de sous-commission, webinaires, Q&A, sondages, tableau blanc, et 20+ plus !

En savoir plus : Guide du pattern architectural du SDK

Démarrage rapide

1. Télécharger Windows SDK

Téléchargez depuis Zoom Marketplace :

  • Extrayez zoom-meeting-sdk-windows_x86_64-{version}.zip

2. Configurer la structure du projet

your-project/
  YourApp/
    SDK/
      x64/
        bin/          # Fichiers DLL et dépendances
        h/            # Fichiers d'en-tête
        lib/          # sdk.lib
      x86/
        bin/
        h/
        lib/
    YourApp.cpp
    YourApp.vcxproj
    config.json

Copiez les fichiers du SDK :

xcopy /E /I sdk-package\x64 your-project\YourApp\SDK\x64\
xcopy /E /I sdk-package\x86 your-project\YourApp\SDK\x86\

3. Installer les dépendances (vcpkg)

# Installer vcpkg
git clone https://github.com/Microsoft/vcpkg.git C:\vcpkg
cd C:\vcpkg
.\bootstrap-vcpkg.bat
.\vcpkg integrate install

# Installer les dépendances
.\vcpkg install jsoncpp:x64-windows
.\vcpkg install curl:x64-windows

4. Configurer le projet Visual Studio

Project Properties → C/C++ → General → Additional Include Directories:

$(SolutionDir)SDK\$(PlatformTarget)\h
C:\vcpkg\packages\jsoncpp_x64-windows\include
C:\vcpkg\packages\curl_x64-windows\include

Project Properties → Linker → General → Additional Library Directories:

$(SolutionDir)SDK\$(PlatformTarget)\lib

Project Properties → Linker → Input → Additional Dependencies:

sdk.lib

Post-Build Event (Copier les DLLs à la sortie) :

xcopy /Y /D "$(SolutionDir)SDK\$(PlatformTarget)\bin\*.*" "$(OutDir)"

5. Configurer les identifiants

Créez config.json :

{
  "sdk_jwt": "YOUR_JWT_TOKEN",
  "meeting_number": "1234567890",
  "passcode": "password123",
  "zak": ""
}

6. Compiler et exécuter

  • Ouvrez la solution dans Visual Studio
  • Sélectionnez la configuration x64 ou x86
  • Appuyez sur F5 pour compiler et exécuter

Flux de travail principal

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│  InitSDK    │───►│  AuthSDK    │───►│ JoinMeeting │───►│ Raw Data    │
│             │    │  (JWT)      │    │             │    │ Subscribe   │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
                         │                   │
                         ▼                   ▼
                   OnAuthComplete      onInMeeting
                     callback           callback

⚠️ CRITIQUE : Ajoutez la boucle de messages Windows ou les callbacks ne se déclencheront pas !

while (!done) {
    MSG msg;
    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

Voir : Guide de la boucle de messages Windows

Exemples de code

💡 Pro Tip : Ce sont des exemples minimalistes. Pour du code complet et testé voir :

Important : Ordre d'inclusion

CRITIQUE : Incluez les en-têtes dans cet ordre exact ou vous obtiendrez des erreurs de build :

#include <windows.h>      // DOIT être en premier
#include <cstdint>         // DOIT être en second (les en-têtes du SDK utilisent uint32_t)
// ... autres en-têtes standard ...
#include <zoom_sdk.h>
#include <meeting_service_components/meeting_audio_interface.h>  // AVANT participants!
#include <meeting_service_components/meeting_participants_ctrl_interface.h>

Voir : Guide des erreurs de build pour tous les correctifs de dépendances.

1. Initialiser le SDK

#include <windows.h>
#include <cstdint>
#include <zoom_sdk.h>

using namespace ZOOM_SDK_NAMESPACE;

bool InitMeetingSDK() {
    InitParam initParam;
    initParam.strWebDomain = L"https://zoom.us";
    initParam.strSupportUrl = L"https://zoom.us";
    initParam.emLanguageID = LANGUAGE_English;
    initParam.enableLogByDefault = true;
    initParam.enableGenerateDump = true;

    SDKError err = InitSDK(initParam);
    if (err != SDKERR_SUCCESS) {
        std::wcout << L"InitSDK failed: " << err << std::endl;
        return false;
    }
    return true;
}

2. S'authentifier avec JWT

#include <windows.h>
#include <cstdint>
#include <auth_service_interface.h>
#include "AuthServiceEventListener.h"

IAuthService* authService = nullptr;

void OnAuthenticationComplete() {
    std::cout << "Authentication successful!" << std::endl;
    JoinMeeting();  // Proceed to join meeting
}

bool AuthenticateSDK(const std::wstring& jwtToken) {
    CreateAuthService(&authService);
    if (!authService) return false;

    // Set event listener BEFORE calling SDKAuth
    authService->SetEvent(new AuthServiceEventListener(&OnAuthenticationComplete));

    // Authenticate with JWT
    AuthContext authContext;
    authContext.jwt_token = jwtToken.c_str();

    SDKError err = authService->SDKAuth(authContext);
    if (err != SDKERR_SUCCESS) {
        std::wcout << L"SDKAuth failed: " << err << std::endl;
        return false;
    }

    // CRITIQUE : Ajoutez la boucle de messages ou le callback ne se déclenchera pas !
    // Voir exemple complet : examples/authentication-pattern.md

    return true;
}

AuthServiceEventListener.h:

#include <windows.h>
#include <cstdint>
#include <auth_service_interface.h>
#include <iostream>

using namespace ZOOM_SDK_NAMESPACE;

class AuthServiceEventListener : public IAuthServiceEvent {
public:
    AuthServiceEventListener(void (*onComplete)()) 
        : onAuthComplete(onComplete) {}

    void onAuthenticationReturn(AuthResult ret) override {
        if (ret == AUTHRET_SUCCESS && onAuthComplete) {
            onAuthComplete();
        } else {
            std::cout << "Auth failed: " << ret << std::endl;
        }
    }

    // Must implement ALL pure virtual methods (6 total)
    void onLoginReturnWithReason(LOGINSTATUS ret, IAccountInfo* info, LoginFailReason reason) override {}
    void onLogout() override {}
    void onZoomIdentityExpired() override {}
    void onZoomAuthIdentityExpired() override {}
#if defined(WIN32)
    void onNotificationServiceStatus(SDKNotificationServiceStatus status, SDKNotificationServiceError error) override {}
#endif

private:
    void (*onAuthComplete)();
};

Voir code complet fonctionnel : Guide du pattern d'authentification

3. Rejoindre la réunion

#include <meeting_service_interface.h>
#include "MeetingServiceEventListener.h"

IMeetingService* meetingService = nullptr;

void OnMeetingJoined() {
    std::cout << "Joining meeting..." << std::endl;
}

void OnInMeeting() {
    std::cout << "In meeting now!" << std::endl;
    // Start raw data capture here
}

void OnMeetingEnds() {
    std::cout << "Meeting ended" << std::endl;
}

bool JoinMeeting(UINT64 meetingNumber, const std::wstring& password) {
    CreateMeetingService(&meetingService);
    if (!meetingService) return false;

    // Set event listener
    meetingService->SetEvent(
        new MeetingServiceEventListener(&OnMeetingJoined, &OnMeetingEnds, &OnInMeeting)
    );

    // Prepare join parameters
    JoinParam joinParam;
    joinParam.userType = SDK_UT_WITHOUT_LOGIN;

    JoinParam4WithoutLogin& params = joinParam.param.withoutloginuserJoin;
    params.meetingNumber = meetingNumber;
    params.userName = L"Bot User";
    params.psw = password.c_str();
    params.isVideoOff = false;
    params.isAudioOff = false;

    SDKError err = meetingService->Join(joinParam);
    if (err != SDKERR_SUCCESS) {
        std::wcout << L"Join failed: " << err << std::endl;
        return false;
    }
    return true;
}

MeetingServiceEventListener.h:

#include <windows.h>
#include <cstdint>
#include <meeting_service_interface.h>
#include <iostream>

using namespace ZOOM_SDK_NAMESPACE;

class MeetingServiceEventListener : public IMeetingServiceEvent {
public:
    MeetingServiceEventListener(
        void (*onJoined)(),
        void (*onEnded)(), 
        void (*onInMeeting)()
    ) : onMeetingJoined(onJoined), 
        onMeetingEnded(onEnded),
        onInMeetingCallback(onInMeeting) {}

    void onMeetingStatusChanged(MeetingStatus status, int iResult) override {
        if (status == MEETING_STATUS_CONNECTING) {
            if (onMeetingJoined) onMeetingJoined();
        }
        else if (status == MEETING_STATUS_INMEETING) {
            if (onInMeetingCallback) onInMeetingCallback();
        }
        else if (status == MEETING_STATUS_ENDED) {
            if (onMeetingEnded) onMeetingEnded();
        }
    }

    // Must implement ALL pure virtual methods (9 total)
    void onMeetingStatisticsWarningNotification(StatisticsWarningType type) override {}
    void onMeetingParameterNotification(const MeetingParameter* param) override {}
    void onSuspendParticipantsActivities() override {}
    void onAICompanionActiveChangeNotice(bool isActive) override {}
    void onMeetingTopicChanged(const zchar_t* sTopic) override {}
    void onMeetingFullToWatchLiveStream(const zchar_t* sLiveStreamUrl) override {}
    void onUserNetworkStatusChanged(MeetingComponentType type, ConnectionQuality level, unsigned int userId, bool uplink) override {}
#if defined(WIN32)
    void onAppSignalPanelUpdated(IMeetingAppSignalHandler* pHandler) override {}
#endif

private:
    void (*onMeetingJoined)();
    void (*onMeetingEnded)();
    void (*onInMeetingCallback)();
};

Voir toutes les méthodes requises : Guide des méthodes d'interface

4. S'abonner à la vidéo brute

#include <windows.h>
#include <cstdint>
#include <rawdata/zoom_rawdata_api.h>
#include <rawdata/rawdata_renderer_interface.h>
#include <zoom_sdk_raw_data_def.h>  // REQUIRED for YUVRawDataI420
#include "ZoomSDKRendererDelegate.h"

IZoomSDKRenderer* videoHelper = nullptr;
ZoomSDKRendererDelegate* videoSource = new ZoomSDKRendererDelegate();

bool StartVideoCapture(uint32_t userId) {
    // STEP 1: Start raw recording FIRST (required!)
    IMeetingRecordingController* recordCtrl = 
        meetingService->GetMeetingRecordingController();

    SDKError canStart = recordCtrl->CanStartRawRecording();
    if (canStart != SDKERR_SUCCESS) {
        std::cout << "Cannot start recording: " << canStart << std::endl;
        return false;
    }

    recordCtrl->StartRawRecording();

    // Wait for recording to initialize
    std::this_thread::sleep_for(std::chrono::milliseconds(500));

    // STEP 2: Create renderer
    SDKError err = createRenderer(&videoHelper, videoSource);
    if (err != SDKERR_SUCCESS || !videoHelper) {
        std::cout << "createRenderer failed: " << err << std::endl;
        return false;
    }

    // STEP 3: Set resolution and subscribe
    videoHelper->setRawDataResolution(ZoomSDKResolution_720P);
    err = videoHelper->subscribe(userId, RAW_DATA_TYPE_VIDEO);
    if (err != SDKERR_SUCCESS) {
        std::cout << "Subscribe failed: " << err << std::endl;
        return false;
    }

    std::cout << "Video capture started! Frames arrive in onRawDataFrameReceived()" << std::endl;
    return true;
}

ZoomSDKRendererDelegate.h:

#include <windows.h>
#include <cstdint>
#include <rawdata/rawdata_renderer_interface.h>
#include <zoom_sdk_raw_data_def.h>
#include <fstream>
#include <iostream>

using namespace ZOOM_SDK_NAMESPACE;

class ZoomSDKRendererDelegate : public IZoomSDKRendererDelegate {
public:
    void onRawDataFrameReceived(YUVRawDataI420* data) override {
        if (!data) return;

        // YUV420 (I420) format: Y plane + U plane + V plane
        int width = data->GetStreamWidth();
        int height = data->GetStreamHeight();

        // Calculate buffer sizes
        // Y = full resolution, U/V = quarter resolution each
        size_t ySize = width * height;
        size_t uvSize = ySize / 4;  // (width/2) * (height/2)

        // Total size: width * height * 1.5 bytes

        // Save to file (playback: ffplay -f rawvideo -pixel_format yuv420p -video_size 1280x720 output.yuv)
        std::ofstream outputFile("output.yuv", std::ios::binary | std::ios::app);
        outputFile.write(data->GetYBuffer(), ySize);    // Brightness
        outputFile.write(data->GetUBuffer(), uvSize);   // Blue-difference
        outputFile.write(data->GetVBuffer(), uvSize);   // Red-difference
        outputFile.close();
    }

    void onRawDataStatusChanged(RawDataStatus status) override {
        std::cout << "Raw data status: " << status << std::endl;
    }

    void onRendererBeDestroyed() override {
        std::cout << "Renderer destroyed" << std::endl;
    }
};

Guide complet de capture vidéo : Guide de capture vidéo brute

5. S'abonner à l'audio brut

#include <rawdata/rawdata_audio_helper_interface.h>

class ZoomSDKAudioRawDataDelegate : public IZoomSDKAudioRawDataDelegate {
public:
    void onMixedAudioRawDataReceived(AudioRawData* data) override {
        // Process PCM audio (mixed from all participants)
        std::ofstream pcmFile("audio.pcm", std::ios::binary | std::ios::app);
        pcmFile.write((char*)data->GetBuffer(), data->GetBufferLen());
        pcmFile.close();
    }

    void onOneWayAudioRawDataReceived(AudioRawData* data, uint32_t node_id) override {
        // Process audio from specific participant
    }
};

// Subscribe to audio
IZoomSDKAudioRawDataHelper* audioHelper = GetAudioRawdataHelper();
audioHelper->subscribe(new ZoomSDKAudioRawDataDelegate());

6. Boucle de messages principal (CRITIQUE !)

⚠️ SANS CECI, LES CALLBACKS NE SE DÉCLENCHERONT PAS !

#include <windows.h>
#include <thread>
#include <chrono>

int main() {
    // Initialize COM
    CoInitialize(NULL);

    // Load config and initialize
    LoadConfig();
    InitMeetingSDK();
    AuthenticateSDK(sdk_jwt);

    // CRITIQUE : Boucle de messages Windows pour les callbacks du SDK
    // Le SDK utilise la pompe de messages Windows pour distribuer les callbacks
    // Sans ceci, les callbacks sont en attente mais NE SE DÉCLENCHENT JAMAIS !
    MSG msg;
    while (!g_exit) {
        // Process all pending Windows messages
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) {
                g_exit = true;
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        // Small sleep to avoid busy-waiting
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    // Cleanup
    CleanSDK();
    CoUninitialize();

    return 0;
}

Pourquoi la boucle de messages est critique : Le SDK utilise COM/messaging Windows pour les callbacks asynchrones. Sans PeekMessage(), le SDK met les messages en attente mais ils ne sont jamais récupérés/distribués, donc les callbacks ne s'exécutent jamais.

Symptômes sans boucle de messages :

  • Timeout d'authentification (même avec JWT valide)
  • Timeout de connexion à la réunion
  • Aucun événement de callback ne se déclenche
  • Semble être un problème réseau/auth mais c'est un problème de boucle de messages

Voir explication détaillée : Guide de la boucle de messages Windows

Problèmes courants et solutions

Problème Solution
Les callbacks ne se déclenchent pas / Auth timeout Ajoutez la boucle de messages Windows → Guide
Erreurs uint32_t / AudioType Corrigez l'ordre d'inclusion → Guide
Erreur de classe abstraite Implémentez toutes les méthodes virtuelles → Guide
Comment implémenter [feature] ? Suivez le pattern universel → Guide
L'authentification échoue Vérifiez le token JWT et les codes d'erreur → Guide
Aucune frame vidéo reçue Appelez StartRawRecording() d'abord → Guide

Dépannage complet : Guide des problèmes courants

Comment implémenter n'importe quel feature

Le SDK dispose de 35+ contrôleurs de features (audio, vidéo, chat, enregistrement, participants, partage d'écran, salles de sous-commission, webinaires, Q&A, sondages, tableau blanc, sous-titres, compagnon IA, etc.).

Pattern universel qui fonctionne pour TOUS les features :

  1. Obtenir le contrôleur (singleton) :

    IMeetingAudioController* audioCtrl = meetingService->GetMeetingAudioController();
IMeetingChatController* chatCtrl = meetingService->GetMeetingChatController();
// ... 33 contrôleurs supplémentaires disponibles

  2. Implémenter l'observateur d'événements (pattern observer) :

    class MyAudioListener : public IMeetingAudioCtrlEvent {
    void onUserAudioStatusChange(IList<IUserAudioStatus*>* lst) override {
        // React to audio events
    }
    // ... implémenter toutes les méthodes requises
};

  3. Enregistrer et utiliser :

    audioCtrl->SetEvent(new MyAudioListener());
audioCtrl->MuteAudio(userId, true);  // Use feature

Guide complet avec exemples : Pattern architectural du SDK

Exemples disponibles

Exemple Description
SkeletonDemo Minimal join meeting - start here
GetVideoRawData Subscribe to raw video streams
GetAudioRawData Subscribe to raw audio streams
SendVideoRawData Send custom video as virtual camera
SendAudioRawData Send custom audio as virtual mic
GetShareRawData Capture screen share content
LocalRecording Local MP4 recording
ChatDemo In-meeting chat functionality
CaptionDemo Closed caption/live transcription
BreakoutDemo Breakout room management

Références détaillées

🎯 Concepts fondamentaux (COMMENCEZ ICI !)

📚 Exemples complets

🔧 Guides de dépannage

📖 Références

🎨 Guides spécifiques aux features

Dépôts exemples

Dépôt Description
meetingsdk-windows-raw-recording-sample Exemples officiels de capture de données brutes
meetingsdk-windows-local-recording-sample Enregistrement local avec Docker

Lecture des fichiers vidéo/audio bruts

Les fichiers YUV/PCM bruts n'ont pas d'en-têtes - vous devez spécifier le format explicitement.

Lecture vidéo YUV brute

ffplay -video_size 1280x720 -pixel_format yuv420p -f rawvideo output.yuv

Convertir YUV en MP4

ffmpeg -video_size 1280x720 -pixel_format yuv420p -f rawvideo -i output.yuv -c:v libx264 output.mp4

Lecture audio PCM brut

ffplay -f s16le -ar 32000 -ac 1 audio.pcm

Convertir PCM en WAV

ffmpeg -f s16le -ar 32000 -ac 1 -i audio.pcm output.wav

Combiner vidéo + audio

ffmpeg -video_size 1280x720 -pixel_format yuv420p -f rawvideo -i output.yuv ^
       -f s16le -ar 32000 -ac 1 -i audio.pcm ^
       -c:v libx264 -c:a aac -shortest output.mp4

Flags clés : | Flag | Description | |------|-------------| | -video_size WxH | Dimensions des frames (ex. 1280x720) | | -pixel_format yuv420p | Format I420/YUV420 planar | | -f rawvideo | Vidéo brute (pas de conteneur) | | -f s16le | PCM 16 bits signé little-endian | | -ar 32000 | Fréquence d'échantillonnage (Zoom utilise 32 kHz) | | -ac 1 | Mono (utilisez -ac 2 pour stéréo) |

Exigences d'authentification (mise à jour 2026)

Important : À partir du 2 mars 2026, les applications rejoignant des réunions en dehors de leur compte doivent être autorisées.

Utilisez l'une des options suivantes :

  • App Privilege Token (OBF) - Recommandé pour les bots (app_privilege_token dans JoinParam)
  • ZAK Token - Zoom Access Key (userZAK dans JoinParam)
  • On Behalf Token - Pour des cas d'usage spécifiques (onBehalfToken dans JoinParam)

📖 Bibliothèque complète de documentation

Cette skill comprend des guides exhaustifs créés à partir du débogage réel :

🎯 Commencer ici

📚 Par catégorie

Concepts fondamentaux :

Exemples complets :

Dépannage :

Références :

🚨 Problèmes les plus critiques (tiré du débogage réel)

  1. Les callbacks ne se déclenchent pas → Boucle de messages Windows manquante (99 % des problèmes)

  2. Erreurs de build → Dépendances des en-têtes du SDK (uint32_t, AudioType, etc.)

  3. Erreurs de classe abstraite → Implémentations de méthodes virtuelles manquantes

💡 Insight clé

Une fois que vous apprenez le pattern en 3 étapes, vous pouvez implémenter N'IMPORTE LEQUEL des 35+ features :

  1. Obtenir le contrôleur → 2. Implémenter l'observateur d'événements → 3. Enregistrer et utiliser

Voir : Pattern architectural du SDK

Ressources officielles

Version de la documentation : Basée sur Zoom Windows Meeting SDK v6.7.2.26830

Besoin d'aide ? Commencez par SKILL.md pour une navigation complète.

Fusionné depuis meeting-sdk/windows/SKILL.md

Index complet de la documentation Zoom Windows Meeting SDK

🚀 Chemin de démarrage rapide

Si vous êtes nouveau au SDK, suivez cet ordre :

  1. Lisez le pattern architectural → concepts/sdk-architecture-pattern.md

    • Cela vous enseigne la formule universelle qui s'applique à TOUS les features
    • Une fois que vous comprenez ceci, vous pouvez implémenter n'importe quel feature en lisant les fichiers .h

  2. Corrigez les erreurs de build → troubleshooting/build-errors.md

    • Problèmes de dépendances des en-têtes du SDK
    • Ordre d'inclusion requis

  3. Implémentez l'authentification → examples/authentication-pattern.md

    • Code complet d'authentification JWT fonctionnelle

  4. Corrigez les problèmes de callback → troubleshooting/windows-message-loop.md

    • CRITIQUE : Pourquoi les callbacks ne se déclenchent pas sans boucle de messages Windows
    • Cela a été le problème le plus difficile à diagnostiquer !

  5. Implémentez les méthodes virtuelles → references/interface-methods.md

    • Listes complètes de toutes les méthodes requises
    • Comment éviter les erreurs de classe abstraite

  6. Capturez la vidéo (optionnel) → examples/raw-video-capture.md

    • Format YUV420 expliqué
    • Flux de travail complet de capture de données brutes

  7. Dépannez tous les problèmes → troubleshooting/common-issues.md

    • Liste de contrôle de diagnostic rapide
    • Tableaux des codes d'erreur
    • Référence "Si vous voyez X, faites Y"

📂 Structure de la documentation

meeting-sdk/windows/
├── SKILL.md                           # Aperçu principal de la skill
├── SKILL.md                           # Ce fichier - guide de navigation
│
├── concepts/                          # Patterns architecturaux fondamentaux
│   ├── sdk-architecture-pattern.md   # LE DOCUMENT LE PLUS IMPORTANT
│   │                                  # Formule universelle pour N'IMPORTE QUEL feature
│   ├── singleton-hierarchy.md        # Guide de navigation pour les services SDK
│   │                                  # Arbre de services 4 niveaux profonds, quand/comment
│   ├── custom-ui-architecture.md     # Comment fonctionne le rendu d'interface personnalisée
│   │                                  # Child HWNDs, D3D, layout, événements
│   └── custom-ui-vs-raw-data.md      # Interface rendue par SDK vs auto-rendue
│                                      # Guide de décision pour l'approche d'interface personnalisée
│
├── examples/                          # Code complet fonctionnel
│   ├── authentication-pattern.md     # Auth JWT avec code complet
│   ├── raw-video-capture.md          # Capture vidéo avec détails YUV420
│   │                                  # Enregistrement vs streaming, permissions
│   ├── custom-ui-video-rendering.md  # Interface personnalisée avec conteneur vidéo
│   │                                  # Layout haut-parleur actif + galerie
│   ├── breakout-rooms.md             # Guide complet des salles de sous-commission
│   │                                  # 5 rôles, créer/gérer/rejoindre
│   ├── chat.md                       # Envoyer/recevoir des messages de chat
│   │                                  # Texte riche, threading, transfert de fichiers
│   ├── captions-transcription.md     # Transcription en direct et sous-titres
│   │                                  # Traduction multi-langue
│   ├── local-recording.md            # Enregistrement local en MP4
│   │                                  # Flux de permission, surveillance de l'encodeur
│   ├── share-raw-data-capture.md     # Capture de données brutes de partage d'écran
│   │                                  # Frames YUV420 du contenu partagé
│   └── send-raw-data.md              # Caméra/mic/partage virtuel
│                                      # Envoyer vidéo/audio/partage personnalisé
│
├── troubleshooting/                   # Guides de résolution de problèmes
│   ├── windows-message-loop.md       # CRITIQUE - Pourquoi les callbacks échouent
│   ├── build-errors.md               # Correctifs des dépendances des en-têtes + MSBuild
│   └── common-issues.md              # Flux de diagnostic rapide
│
└── references/                        # Documentation de référence
    ├── interface-methods.md           # Méthodes virtuelles requises
    │                                  # Auth(6) + Meeting(9) + CustomUI(13)
    ├── windows-reference.md           # Configuration de la plateforme
    ├── authorization.md               # Génération JWT
    ├── bot-authentication.md          # Types de tokens bot
    ├── breakout-rooms.md              # Fonctionnalités des salles de sous-commission
    └── ai-companion.md                # Fonctionnalités du compagnon IA

🎯 Par cas d'usage

Je veux construire un bot de réunion

  1. Pattern architectural du SDK - Comprendre le pattern
  2. Pattern d'authentification - Rejoindre les réunions
  3. Boucle de messages Windows - Corriger les problèmes de callback
  4. Méthodes d'interface - Implémenter les callbacks

J'obtiens des erreurs de build

  1. Guide des erreurs de build - Dépendances des en-têtes du SDK
  2. Méthodes d'interface - Erreurs de classe abstraite
  3. Problèmes courants - Erreurs d'édition de liens

J'obtiens des erreurs à l'exécution

  1. Boucle de messages Windows - Les callbacks ne se déclenchent pas
  2. Pattern d'authentification - Timeout d'authentification
  3. Problèmes courants - Tableaux des codes d'erreur

Je veux construire une application d'interface personnalisée

  1. Architecture d'interface personnalisée - Comment fonctionne le rendu du SDK
  2. Interface SDK-rendue vs auto-rendue - Choisissez votre approche
  3. Rendu vidéo d'interface personnalisée - Code complet fonctionnel
  4. Méthodes d'interface - 13 méthodes virtuelles d'interface personnalisée
  5. Guide des erreurs de build - MSBuild depuis git bash

Je veux capturer vidéo/audio

  1. Capture vidéo brute - Flux vidéo complet
    • Approches enregistrement vs streaming
    • Exigences de permission (hôte, tokens OAuth)
    • Capture audio PCM
  2. Capture de données brutes de partage - Capture de partage d'écran
    • S'abonner à RAW_DATA_TYPE_SHARE
    • Gérer la résolution dynamique
  3. Pattern architectural du SDK - Pattern contrôleur
  4. Problèmes courants - Aucune frame reçue

Je veux utiliser les salles de sous-commission

  1. Guide des salles de sous-commission - Flux de travail complet des salles de sous-commission
    • 5 rôles : Créateur, Admin, Données, Assistant, Participant
    • Créer, configurer, gérer, rejoindre/quitter les salles
  2. Problèmes courants - Codes d'erreur des salles de sous-commission

Je veux implémenter le chat

  1. Guide du chat - Envoyer/recevoir des messages
    • Formatage de texte riche (gras, italique, liens)
    • Messages privés et threading
    • Événements de transfert de fichiers

Je veux utiliser la transcription en direct

  1. Guide des sous-titres et transcription - Transcription en direct
    • Conversion automatique de la parole en texte
    • Traduction multi-langue
    • Sous-titres codés manuels (fonctionnalité hôte)

Je veux enregistrer les réunions

  1. Guide d'enregistrement local - Enregistrement local en MP4
    • Flux de demande de permission
    • Surveillance de l'encodeur zTscoder.exe
    • Vue galerie vs haut-parleur actif

Je veux implémenter un feature spécifique

  1. Pattern architectural du SDK - COMMENCEZ ICI !
  2. Trouvez le contrôleur dans SDK/x64/h/meeting_service_interface.h
  3. Trouvez l'en-tête dans SDK/x64/h/meeting_service_components/
  4. Suivez le pattern universel : Obtenir le contrôleur → Implémenter l'observateur → Utiliser les méthodes

Je veux comprendre l'architecture du SDK

  1. Pattern architectural du SDK - Aperçu architectural complet
  2. Hiérarchie singleton - Naviguer l'arbre des services (4 niveaux)
  3. Méthodes d'interface - Pattern observateur des événements
  4. Pattern d'authentification - Pattern de service

🔥 Documents les plus critiques

1. Pattern architectural du SDK (⭐ DOCUMENT MAÎTRE)

concepts/sdk-architecture-pattern.md

C'est LE document le plus important. Il enseigne le pattern universel en 3 étapes :

  1. Obtenir le contrôleur (pattern singleton)
  2. Implémenter l'observateur d'événements (pattern observer)
  3. Enregistrer et utiliser

Une fois que vous comprenez ce pattern, vous pouvez implémenter n'importe lequel des 35+ features en lisant simplement les en-têtes du SDK.

Insight clé : Le SDK Zoom suit une architecture parfaitement cohérente. Chaque feature fonctionne de la même manière.

2. Boucle de messages Windows (⚠️ PROBLÈME LE PLUS COURANT)

troubleshooting/windows-message-loop.md

99 % des problèmes "les callbacks ne se déclenchent pas" sont causés par une boucle de messages Windows manquante. Ce document explique :

  • Pourquoi le SDK nécessite la boucle PeekMessage()
  • Comment l'implémenter correctement
  • Comment diagnostiquer les problèmes de callback

C'était le bug le plus difficile à trouver lors du développement (a pris ~2 heures).

3. Guide des erreurs de build

troubleshooting/build-errors.md

Les en-têtes du SDK ont des bugs de dépendance qui causent des erreurs de build. Ce document fournit :

  • Ordre d'inclusion requis
  • Correctif <cstdint> manquant
  • Correctif AudioType manquant
  • Correctif YUVRawDataI420 manquant

📊 Par type de document

Concepts (Pourquoi et Comment)

Exemples (Code complet fonctionnel)

Dépannage (Résolution de problèmes)

Références (Information de consultation)

💡 Apprentissages clés tirés du débogage réel

Ces documents ont été créés à partir du débogage réel d'un exemple Zoom SDK non fonctionnel. Voici les insights clés :

Découvertes critiques :

  1. La boucle de messages Windows est OBLIGATOIRE (pas optionnelle)

    • Le SDK utilise la pompe de messages Windows pour les callbacks
    • Sans elle, les callbacks sont en attente mais ne se déclenchent jamais
    • Se manifeste comme "timeout d'authentification" même avec JWT valide
    • Voir : Guide de la boucle de messages Windows

  2. Les en-têtes du SDK ont des bugs de dépendance

    • #include <cstdint> manquant dans les en-têtes du SDK
    • meeting_participants_ctrl_interface.h n'inclut pas meeting_audio_interface.h
    • rawdata_renderer_interface.h forward-déclare seulement YUVRawDataI420
    • Voir : Guide des erreurs de build

  3. L'ordre d'inclusion est CRITIQUE

    • <windows.h> DOIT être EN PREMIER
    • <cstdint> DOIT être EN SECOND
    • Puis les en-têtes du SDK dans un ordre spécifique
    • Voir : Guide des erreurs de build

  4. TOUTES les méthodes virtuelles doivent être implémentées

    • Y compris les méthodes conditionnelles WIN32
    • Le SDK v6.7.2 requiert 6 méthodes auth + 9 méthodes meeting
    • Les différentes versions ont des exigences différentes
    • Voir : Guide des méthodes d'interface

  5. L'architecture est magnifiquement cohérente

    • Chaque feature suit le même pattern en 3 étapes
    • Les contrôleurs sont des singletons
    • Les observateurs d'événements utilisent le pattern observer
    • Une fois que vous apprenez le pattern, vous pouvez implémenter n'importe quel feature
    • Voir : Pattern architectural du SDK

🎓 Chemin d'apprentissage par niveau de compétence

Débutant (Nouveau au SDK Zoom)

  1. Lisez Pattern architectural du SDK pour comprendre la conception globale
  2. Suivez Pattern d'authentification pour rejoindre votre première réunion
  3. Référencez Problèmes courants quand vous rencontrez des problèmes

Intermédiaire (Familier avec les bases du SDK)

  1. Plongez dans Pattern architectural du SDK - implémentez plusieurs features
  2. Apprenez Capture vidéo brute pour le traitement des médias
  3. Utilisez Méthodes d'interface comme référence

Avancé (Construction de bots de production)

  1. Étudiez Pattern architectural du SDK - apprenez à implémenter N'IMPORTE QUEL feature
  2. Maîtrisez Boucle de messages Windows - comprenez le flux asynchrone des callbacks
  3. Référencez directement les en-têtes du SDK en utilisant le pattern universel

🔍 Comment trouver ce que vous avez besoin

"Mon code ne se compile pas"

→ Guide des erreurs de build

"L'authentification expire"

→ Boucle de messages Windows

"Les callbacks ne se déclenchent jamais"

→ Boucle de messages Windows

"Erreur de classe abstraite"

→ Méthodes d'interface

"Comment implémenter [feature] ?"

→ Pattern architectural du SDK

"Comment rejoindre une réunion ?"

→ Pattern d'authentification

"Comment capturer la vidéo ?"

→ Capture vidéo brute

"Qu'est-ce qu'un code d'erreur signifie ?"

→ Problèmes courants - Tableaux complets des codes d'erreur (SDKERR, AUTHRET, Login, BO, Phone, OBF)

"Comment utiliser les salles de sous-commission ?"

→ Guide des salles de sous-commission

"Comment fonctionne le SDK ?"

→ Pattern architectural du SDK

"Comment naviguer vers un contrôleur/feature spécifique ?"

→ Hiérarchie singleton

"Comment envoyer/recevoir des messages de chat ?"

→ Guide du chat

"Comment utiliser la transcription en direct ?"

→ Guide des sous-titres et transcription

"Comment enregistrer localement ?"

→ Guide d'enregistrement local

"Comment capturer le partage d'écran ?"

→ Capture de données brutes de partage

📝 Version du document

Tous les documents sont basés sur Zoom Windows Meeting SDK v6.7.2.26830.

Les différentes versions du SDK peuvent avoir :

  • Différentes méthodes de callback requises
  • Différents codes d'erreur
  • Comportement API différent

Si vous utilisez une version différente, utilisez grep "= 0" SDK/x64/h/*.h pour vérifier les méthodes requises.

Rappelez-vous : Pattern architectural du SDK est le moyen le plus rapide de comprendre comment le SDK Meeting Windows s'articule. Lisez-le en premier si vous déboguez des problèmes d'interface personnalisée ou de flux d'événements.

Opérations

  • RUNBOOK.md - Liste de vérification de vérification préalable et débogage en 5 minutes.

Skills similaires

quality-playbook
github / awesome-copilot

Générer un système qualité complet et personnalisé pour tout projet logiciel.

32 867
aiconfig-migrate
launchdarkly / agent-skills

Migrer une application d'invites LLM codées en dur vers LaunchDarkly AI Configs en cinq étapes.

10
shopify-hydrogen
shopify / agent-skills

Implémenter des fonctionnalités Hydrogen Shopify via des recettes de cookbook prêtes à l'emploi.

31
skill-creator
anthropics / skills

Créer, tester et affiner des skills pour agents IA de façon itérative.

133 545
wiki
factory-ai / factory-plugins

Générer une wiki interconnectée à partir d'un dépôt de code analysé en profondeur.

72