Sous-titrage en direct, modération et enregistrement avec Python et Vonage

À la fin de ce billet de blog, vous aurez une meilleure compréhension du SDK Python pour l'API Video de Vonage, ainsi que quelques exemples de code que vous pouvez utiliser comme échafaudage pour créer des expériences de visioconférence riches en fonctionnalités basées sur le navigateur.

Introduction

La pandémie de 2020 a accéléré l'adoption de la vidéoconférence comme outil de communication standard. Aujourd'hui, les réunions vidéo sur le web font partie du quotidien des entreprises, des éducateurs et des consommateurs. Les développeurs peuvent utiliser l Video API de Vonage et le SDK Python pour créer des applications de vidéoconférence sécurisées et en temps réel, avec des fonctions de modération, de transcription et d'enregistrement.

Au fil du temps, la technologie a considérablement évolué, tout comme les exigences qui lui sont imposées. Des solutions qui semblaient autrefois à la pointe du progrès sont aujourd'hui considérées comme des caractéristiques de base. Les plateformes de vidéoconférence modernes sont censées fournir un son et une vidéo de haute qualité, une connectivité fiable et une communication à faible latence.

Cet article de blog explore le SDK Python pour l'API vidéo de Video API de Vonage de Vonage Video et montre comment intégrer des fonctions de modération et d'archivage dans une application de vidéoconférence. Chacune des fonctionnalités abordées est démontrée dans un exemple d'application qui l'accompagne. Si vous ne connaissez pas du tout l'API Video, vous pouvez commencer par ce tutoriel sur la création d'une application de visioconférence. Si vous souhaitez passer directement au code lui-même, vous pouvez utiliser l'application d'exemple en suivant le README dans le référentiel.

Plus précisément, cet article de blog couvre :

• Sous-titrage en direct

• Assourdissement des participants

• Retrait des participants

• Sessions d'enregistrement

• Visualisation des sessions enregistrées

Integrate live interactive video directly into your web, mobile, and desktop applications with the Vonage global video platform.

Comprendre Flask et le tunneling

L'exemple d'application présenté dans ce billet de blog s'appuie sur des concepts techniques et des outils extérieurs à Vonage qui peuvent être utiles dans d'autres domaines du développement logiciel.

Qu'est-ce qu'une application Python Flask ?

L'exemple d'application présenté dans ce billet de blog utilise Flaskun framework web léger mais puissant pour Python. En tant que cadre, il permet aux développeurs de créer rapidement une application web. Nous l'avons choisi pour ce tutoriel en raison de sa facilité d'utilisation et de son approche minimaliste. Contrairement à d'autres frameworks de développement web Python, il nous fournit juste l'essentiel dont nous avons besoin pour créer une solution de visioconférence simple.

Qu'est-ce qu'un tunnel ?

L'application d'exemple fonctionnant localement, elle n'est pas accessible depuis l'internet public. Si votre application locale n'est pas accessible au public, les participants distants ne peuvent pas se connecter à la session vidéo. C'est là que le tunneling entre en jeu. Le tunneling expose les serveurs locaux à l'internet public par le biais d'URL publiques temporaires ou statiques. ngrok est une plateforme logicielle qui fournit ce service. Vous pouvez en savoir plus sur ngrok dans notre article de blog à ce sujet.

Video API Core Concepts (Concepts de base de l'API vidéo)

Les utilisateurs finaux s'attendent à des appels vidéo transparents et ininterrompus qui fonctionnent parfaitement. Cependant, atteindre ce niveau de fiabilité implique une complexité considérable sous la surface.

La communication vidéo en temps réel présente plusieurs défis techniques. Les appelants se connectent via différents matériels, opèrent sur des infrastructures de connectivité variées et couvrent plusieurs régions géographiques. En outre, les conditions du réseau fluctuent pendant les sessions actives : un smartphone peut passer de la connectivité Wi-Fi aux données mobiles, les protocoles de sécurité de l'entreprise peuvent restreindre certains trafics UDP (User Datagram Protocol), ou un vieil ordinateur peut connaître des goulets d'étranglement au niveau du traitement.

L'API Video de Vonage permet aux développeurs d'intégrer la vidéo en temps réel de haute qualité, la messagerie instantanée, le partage d'écran et les fonctions connexes dans les applications Web et mobiles. Pour offrir cette capacité, l'API Video s'appuie sur la technologie WebRTC comme base pour la transmission des flux audio et vidéo. Les concepts suivants sont importants lorsque l'on travaille avec l'API Video :

• Session: Une session est un groupe logique de connexions et de flux. Les connexions au sein d'une même session peuvent échanger des messages. Une session agit comme une salle virtuelle où les participants communiquent.

• Connexion: Un point d'extrémité qui participe à une session et qui est capable d'envoyer et de recevoir des messages. Une connexion est soit connectée et peut recevoir des messages, soit déconnectée et ne peut pas recevoir de messages.

• Flux: Un flux de médias circule entre deux connexions. Il s'agit des octets contenant le média qui sont échangés. Les médias peuvent être uniquement de l'audio, ou de l'audio et de la vidéo. Vous pouvez également créer des partages d'écran et des flux personnalisés.

• Jeton: La plateforme Video API utilise des jetons pour l'autorisation, de sorte que vous n'avez pas à vous soucier de la création d'utilisateurs sur la plateforme. Dans cet exemple d'application, nous utilisons des jetons pour créer des participants à la session vidéo à la volée.

• Éditeur: Il s'agit du client qui publie un flux de médias.

• Abonné: Un client qui reçoit des flux de médias.

• Signalisation: Il s'agit de l'envoi de texte et de données sous forme de messages entre les clients connectés à une session. Ces messages permettent aux développeurs de créer un chat textuel de base, d'envoyer des instructions d'un client à l'autre et de créer d'autres expériences intéressantes.

Pour approfondir ces termes et concepts clés, consultez le Glossaire de Video API ou consultez la documentation Video API. Vous pouvez également consulter notre introduction à l'API Video sur YouTube :

Quelle est la différence entre un SDK côté client et un SDK côté serveur ?

La plateforme Video API permet d'intégrer des vidéos interactives en temps réel et de haute qualité, des messageries, des partages d'écran et bien d'autres choses encore dans des applications web et mobiles. La plateforme comprend des bibliothèques client pour les plateformes web, mobile et de bureau, ainsi que des SDK côté serveur.

Qu'est-ce qu'un SDK ?

SDK est l'abréviation de "software development kit" (kit de développement logiciel). Un SDK est un ensemble d'outils installables conçus pour faciliter la mise en œuvre d'une plate-forme ou d'une technologie particulière par les développeurs. Le SDK Python pour l'API Video permet aux développeurs Python d'intégrer plus facilement Vonage dans leurs Applications, car il traduit l'API en modèles et structures spécifiques au langage.

Les SDK côté client et côté serveur fournissent tous deux ce type d'outils. La différence réside dans leur emplacement dans l'architecture d'une application. Les SDK côté client aident les développeurs à créer des interfaces utilisateur, des expériences interactives et des fonctions de communication en temps réel. Pour cette raison, les SDK côté client sont généralement écrits pour JavaScript et ses cadres et bibliothèques, ainsi que pour les systèmes d'exploitation mobiles et de bureau.

À l'inverse, un SDK côté serveur fournit des outils pour le développement du backend. Il s'agit de la partie d'une application responsable de la gestion des demandes, du traitement des données, de la logique métier supplémentaire, de la sécurité et de l'authentification. Comme leur nom l'indique, les SDK côté serveur aident les développeurs à écrire des logiciels qui seront déployés sur un serveur (généralement dans le nuage) et sont donc généralement écrits pour Python, Java, Node.js ou PHP.

Le tableau suivant résume les différences entre les SDK côté client et côté serveur :

Dans cet article de blog, nous allons couvrir le SDK Python pour l'API Video de Vonage. Il s'agit d'un SDK côté serveur qui vous permet de créer et de modérer des sessions, de générer des jetons et de travailler avec l'archivage. Vous pouvez en savoir plus sur la façon dont les API Video côté client et côté serveur interagissent dans notre documentation.

Construire une application de Video Conferencing avec le SDK Python

L'application d'exemple présentée dans ce billet de blog utilise Python et Flask pour le backend et JavaScript sur le frontend pour créer et coordonner une session vidéo. L'application prend en charge les fonctionnalités suivantes :

• Création d'une session Video

• Permettre aux présentateurs de publier des flux

• Permettre aux présentateurs de :

  • Activer le sous-titrage en direct

  • Mettre en sourdine ou supprimer des participants

  • Démarrer l'archivage des sessions

Si vous souhaitez mettre en place le code et le faire fonctionner, vous pouvez suivre le README dans le repo de l'application exemple. exemple d'application. La création de sessions et l'activation du chat en temps réel entre les participants sont abordées dans notre article de blog sur la la création d'une application de vidéoconférence.

Activation du sous-titrage en direct

Les sous-titres en direct peuvent améliorer l'expérience utilisateur et l'engagement des utilisateurs d'une application. Le sous-titrage améliore le score d'accessibilité de votre application. Les réglementations en matière d'accessibilité dans certaines régions peuvent exiger la prise en charge du sous-titrage. Les sous-titres peuvent améliorer la compréhension dans des environnements bruyants ou non contrôlés, améliorant ainsi l'expérience globale de l'utilisateur.

Vous pouvez utiliser l Live Captions API pour transcrire des flux audio et générer des sous-titres en temps réel pour votre application. L'API Video Live Captions utilise un service de transcription pour fournir des sous-titres en temps réel aux participants d'une session.

Veuillez noter que les sous-titres en direct sont un produit basé sur l'utilisation : Live Captions est un produit basé sur l'utilisation. L'utilisation est facturée en fonction du nombre de flux audio de participants (ou d'identifiants de flux) envoyés au service de transcription. Pour plus d'informations, voir la page de tarification de l'API Live Captions.

Pour pouvoir utiliser les sous-titres en direct, votre session doit être créée avec l'option "Media Router et pour activer les sous-titres, un participant a besoin d'un jeton avec le rôle de "Modérateur.

Dans le SDK Python, ces options sont gérées par les commandes SessionOptions et TokenOptions respectivement :

session_options = SessionOptions(media_mode=MediaMode.ROUTED)
video_session = vonage_client.video.create_session(options=session_options)

if presenter:
    token_options = TokenOptions(session_id=session_id, role=TokenRole.MODERATOR)
else:
    token_options = TokenOptions(session_id=session_id, role=TokenRole.PUBLISHER)
    
token = vonage_client.video.generate_client_token(token_options).decode("utf-8")

Dans l'exemple de code exemple de codenous accordons à presenters la possibilité d'activer les sous-titres en générant un jeton avec le rôle MODERATOR rôle.

Pour en savoir plus sur les jetons, les rôles des jetons et les capacités de chaque rôle, reportez-vous à la documentation.

Les points de terminaison suivants sont ceux que nous utilisons pour communiquer avec le backend et envoyer une demande à l'API Live Captions. Le point de terminaison pour démarrer les sous-titres utilise un identifiant de session et un jeton pour créer un objet CaptionsOption qui est ensuite transmis à la fonction start_options à la fonction La fonction renvoie un objet CaptionsData objet.

@app.route("/captions/start", methods=["POST"])
def start_captions():
    """Endpoint to start captions"""
    data = request.get_json()
    print(f"Start captions request data: ==> {data}")
    session_id = data.get("sessionId")
    token_id = data.get("token")

    if not session.get("is_presenter"):
        return jsonify({"error": "Unauthorized"}), 403

    if not session_id or not token_id:
        return jsonify({"error": "sessionId or token is missing"}), 400

    options = CaptionsOptions(
        session_id=session_id,
        token=token_id,
    )

    captions: CaptionsData = vonage_client.video.start_captions(options)

    return jsonify({"caption_id": captions.captions_id})

L'identifiant de la légende est transmis au frontend et utilisé pour afficher l'audio transcrit dans l'interface utilisateur. Dans l'exemple d'application, les sous-titres apparaissent sous la vidéo. Veuillez noter qu'il peut s'écouler un certain temps avant que les sous-titres ne commencent à apparaître.

Pour en savoir plus sur l'API Live Captions et voir des exemples de code pour l'implémentation frontale, reportez-vous à la documentation.

Modération de session : Assourdissement et retrait des participants

Les modérateurs peuvent être amenés à contrôler le son des participants ou l'accès à la session afin d'améliorer l'expérience globale de la réunion. Par exemple, un participant peut oublier de couper son microphone, ce qui entraîne des distractions audio involontaires au cours d'une session ; à l'extrême limite de la modération, un participant peut avoir besoin d'être expulsé de force de la session. Un participant ayant les privilèges du rôle de modérateur a accès à ces deux fonctions avec l'API Video.

Mise en sourdine d'un participant

Dans l'exemple d'application, nous définissons un point de terminaison d'inhibition qui fait un appel à l'API. L'API a besoin d'un identifiant de session et d'un identifiant de flux pour réussir.

@app.route("/mute-stream", methods=["POST"])
def mute_stream():
    data = request.json
    session_id = data.get("sessionId")
    stream_id = data.get("streamId")

    vonage_client.video.mute_stream(session_id, stream_id)
    return jsonify({"message": f"Stream {stream_id} muted successfully."}), 200

En outre, les participants ayant le rôle de modérateur peuvent mettre en sourdine tous les dans une session et désactiver la mise en sourdine dans tous les flux. La mise en œuvre de ces fonctions dépasse le cadre de ce billet de blog, mais vous pouvez trouver des exemples de code dans la documentation sur l'inhibition des participants.

Lorsque l'on travaille avec les points de terminaison de l'inhibition, il est important de se rappeler quelques points :

• Il n'existe pas d'API pour dé-muter d'un seul participant. En effet, dans le cas d'utilisation typique d'une session Video, les participants devraient alors rétablir le silence eux-mêmes lorsqu'ils ont besoin de parler.

• L'utilisation de mute_all_streams met en sourdine tous les flux actuels ainsi que tous les flux futurs publiés dans une session. Cette fonction accepte également une liste d'identifiants de flux à exclure de la mise en sourdine forcée.

• Lorsqu'un flux est mis en sourdine à la suite de l'une ou l'autre des actions suivantes mute_stream ou mute_all_streamsl'objet Publisher envoie un événement muteForced dans chaque client publiant un flux en sourdine.

• L'exécution de disable_mute_all_streams supprimera la mise en sourdine forcée des nouveaux flux publiés - les flux existants resteront muets.

Suppression d'un participant

Vous pouvez supprimer un participant en appelant l disconnect_client API. Dans l'exemple d'application, nous définissons un point de terminaison /remove-participant qui appelle cette API. L'API a besoin d'un identifiant de session et d'un identifiant de connexion pour réussir.

@app.route("/remove-participant", methods=["POST"])
def remove_participant():
    data = request.json
    session_id = data.get("sessionId")
    connection_id = data.get("connection_id")

    vonage_client.video.disconnect_client(session_id, connection_id)
    return (
        jsonify({"message": f"Participant {connection_id} removed successfully."}),
        200,
    )

Archivage des sessions

Il peut arriver que vous souhaitiez enregistrer une session vidéo pour la visionner ou la traiter ultérieurement. Vous pouvez le faire avec les méthodes archive du SDK, qui comprennent les fonctionnalités suivantes :

• Démarrage d'un enregistrement d'archives

• Arrêt d'un enregistrement d'archives

• Lister les enregistrements d'archives

• Récupération des informations relatives à l'enregistrement des archives

• Suppression d'une archive

Dans ce billet de blog et dans l'exemple d'application qui l'accompagne, nous nous concentrerons sur le démarrage, l'arrêt et la récupération d'un enregistrement d'archive.

Pour utiliser les méthodes d'archivage, vous devez créer une session en mode Média routé. Vous ne pouvez créer une archive que pour les sessions auxquelles au moins un client est connecté.

Dans l'application d'exemple, nous définissons le point de terminaison suivant, qui crée un objet CreateArchiveRequest pour capturer les paramètres de l'archive, puis le transmet à la fonction start_archive fonction :

@app.route("/archive/start", methods=["POST"])
def start_archive():
    """Endpoint to start archiving"""
    data = request.get_json()
    session_id = data.get("sessionId")

    if not session_id:
        return jsonify({"error": "sessionId is required"}), 400
    if not session.get("is_presenter"):
        return jsonify({"error": "Unauthorized"}), 403

    archive_options = CreateArchiveRequest(session_id=session_id)
    archive: Archive = vonage_client.video.start_archive(archive_options)

    archive_id = archive.id

    return jsonify({"archive_id": archive_id, "status": archive.status})

En utilisant l'identifiant d'archive obtenu, nous pouvons alors définir un point de terminaison pour arrêter l'enregistrement de l'archive :

@app.route("/archive/<archive_id>/stop", methods=["POST"])
def stop_archive(archive_id):
    """Endpoint to stop archiving"""

    if not archive_id:
        return jsonify({"error": "archiveId is required"}), 400

    archive: Archive = vonage_client.video.stop_archive(archive_id)
    return jsonify({"archive_id": archive.id, "status": archive.status})

Lorsque vous arrêtez l'enregistrement d'une archive, la plateforme Video de Vonage crée un fichier MP4 ou - dans le cas d'archives de flux individuels - un fichier ZIP. Lorsqu'une archive est prête, son état devient availableet la méthode get_archive renvoie l'URL de l'archive. Cette méthode est utilisée en conjonction avec l'interrogation sur le frontend de l'application d'exemple pour définir un point de terminaison qui rend un lien vers l'archive.

@app.get("/archive/<archive_id>/status")
def archive_status(archive_id):
    """Endpoint to check status of archive"""
    try:
        archive = vonage_client.video.get_archive(archive_id)
        return jsonify(
            {
                "status": archive.status,
                "url": archive.url,
            }
        )
    except Exception as e:
        return jsonify({"error": str(e)}), 500

Cet exemple de code ne présente que les bases de l'enregistrement d'archives à l'aide de l'API Video. Pour en savoir plus sur les possibilités offertes par l'archivage vidéo, reportez-vous à la documentation.

En résumé

Le SDK Python de l'API Video de Vonage facilite la création d'applications vidéo en temps réel avec des capacités avancées de modération et d'archivage. Dans cet exemple d'application, nous avons exploré comment créer des sessions, gérer les autorisations des participants, activer les sous-titres en direct, modérer les participants et enregistrer des sessions vidéo pour une lecture ultérieure.

Ces fonctionnalités sont essentielles pour les expériences de vidéoconférence modernes, en particulier dans les applications qui nécessitent une accessibilité, des contrôles de modération ou une persistance de session. En combinant le SDK Python avec Flask et la plateforme Video API, les développeurs peuvent rapidement prototyper et déployer des flux de travail de communication en temps réel fiables.

En combinant un simple backend Flask avec un frontend alimenté par JavaScript, vous disposez d'un modèle pour une application de vidéoconférence fonctionnelle. Vous pouvez étendre cette base avec des fonctionnalités plus avancées comme les contrôles de modération, l'enregistrement, le partage d'écran, ou l'amélioration de l'UI/UX pour répondre à votre cas d'utilisation. Pour une itération plus rapide, le Terrain de jeu de l'API Video de Vonage vous permet d'essayer facilement différentes fonctionnalités directement dans votre navigateur !

Autres lectures et ressources

• Meilleures pratiques pour démarrer avec Vonage Video: Meilleures pratiques pour intégrer l'API Video de Vonage dans vos Applications.

• Archivage vidéo avec l'API Video de Vonage et React: Découvrez quatre modes d'archivage vidéo avec l'API Video de Vonage - notamment Experience Composer.

• Démarrer avec l'API de sous-titrage en direct de Vonage en Node.js: Apprenez à ajouter des sous-titres en temps réel à vos appels Video de Vonage en utilisant l'API Live Captions avec Node.js et un simple frontend.