Afficher l’état de transcription des appels sur le client
Vous devez recueillir le consentement de tous les participants à l’appel avant de pouvoir les transcrire. Microsoft Teams permet aux utilisateurs de commencer la transcription dans les réunions ou les appels. Vous recevrez un événement quand la transcription a démarré sur lequel vous pouvez vérifier l’état de la transcription, si la transcription a démarré avant que vous ayez rejoint l’appel ou la réunion.
Prérequis
- Compte Azure avec un abonnement actif. Créez un compte gratuitement.
- Une ressource Communication Services déployée. Créez une ressource Communication Services.
- Un jeton d’accès utilisateur pour activer le client appelant. Pour plus d’informations, consultez Créer et gérer des jetons d’accès.
- Facultatif : suivez le guide de démarrage rapide permettant d’ajouter l’appel vocal à votre application.
Support
Les tableaux suivants définissent la prise en charge de la transcription des appels dans Azure Communication Services.
Identités et types d’appels
Les tableaux suivants montrent la prise en charge de la transcription pour un type d’appel et une identité spécifiques.
Identités | Réunion Teams | Salle | Appel 1:1 | Appel de groupe | Appel d’interopérabilité Teams 1:1 | Appel d’interopérabilité Teams de groupe |
---|---|---|---|---|---|---|
Utilisateur de Communication Services | ✔️ | ✔️ | ✔️ | |||
Utilisateur Microsoft 365 | ✔️ | ✔️ | ✔️ |
Opérations
Les tableaux suivants montrent la prise en charge des API individuelles dans le Kit de développement logiciel (SDK) d’appel pour des types d’identité individuels.
Opérations | Utilisateur de Communication Services | Utilisateur Microsoft 365 |
---|---|---|
Obtenir un événement indiquant que la transcription a démarré | ✔️ | ✔️ |
Obtenir l’état de la transcription | ✔️ | ✔️ |
Démarrer ou arrêter la transcription |
SDK
Les tableaux suivants montrent la prise en charge de la transcription dans les Kits de développement logiciel (SDK) Azure Communication Services individuels.
Platforms | web | Interface utilisateur web | iOS | Interface utilisateur iOS | Android | Interface utilisateur Android | Windows |
---|---|---|---|---|---|---|---|
Est pris en charge | ✔️ | ✔️ | ✔️ | ✔️ | ✔️ | ✔️ | ✔️ |
Installer le SDK
Utilisez la commande npm install
pour installer le SDK Azure Communication Services Common et le SDK Azure Communication Services Calling pour JavaScript :
npm install @azure/communication-common --save
npm install @azure/communication-calling --save
Initialiser les objets nécessaires
Une instance CallClient
est requise pour la plupart des opérations d’appel. Lorsque vous créez une instance CallClient
, vous pouvez la configurer avec des options personnalisées comme une instance Logger
.
Avec l’instance CallClient
, vous pouvez créer une instance CallAgent
en appelant createCallAgent
. Cette méthode renvoie un objet d’instance CallAgent
de manière asynchrone.
La méthode createCallAgent
utilise CommunicationTokenCredential
comme argument. Elle accepte un jeton d’accès utilisateur.
Vous pouvez utiliser la méthode getDeviceManager
sur l’instance CallClient
pour accéder à deviceManager
.
const { CallClient } = require('@azure/communication-calling');
const { AzureCommunicationTokenCredential} = require('@azure/communication-common');
const { AzureLogger, setLogLevel } = require("@azure/logger");
// Set the logger's log level
setLogLevel('verbose');
// Redirect log output to console, file, buffer, REST API, or whatever location you want
AzureLogger.log = (...args) => {
console.log(...args); // Redirect log output to console
};
const userToken = '<USER_TOKEN>';
callClient = new CallClient(options);
const tokenCredential = new AzureCommunicationTokenCredential(userToken);
const callAgent = await callClient.createCallAgent(tokenCredential, {displayName: 'optional Azure Communication Services user name'});
const deviceManager = await callClient.getDeviceManager()
Comment gérer au mieux la connectivité du SDK à l’infrastructure Microsoft
L’instance Call Agent
vous aide à gérer les appels (pour rejoindre ou démarrer des appels). Pour fonctionner, votre SDK d’appel doit se connecter à l’infrastructure Microsoft pour recevoir des notifications d’appels entrants et coordonner d’autres détails de l’appel. Votre Call Agent
a deux états possibles :
Connecté : un Call Agent
dont la valeur connectionStatue est égale à Connected
signifie que le SDK client est connecté et capable de recevoir des notifications de l’infrastructure Microsoft.
Déconnecté : un Call Agent
dont la valeur connectionStatue est égale à Disconnected
indique qu’un problème empêche le SDK de se connecter correctement. Call Agent
doit être recréé.
invalidToken
: si un jeton a expiré ou n’est pas valide, l’instanceCall Agent
se déconnecte avec cette erreur.connectionIssue
: en cas de problème de connexion du client à l’infrastructure Microsoft, après plusieurs tentatives,Call Agent
lève l’erreurconnectionIssue
.
Vous pouvez vérifier si votre Call Agent
local est connecté à l’infrastructure Microsoft en inspectant la valeur actuelle de la propriété connectionState
. Pendant un appel actif, vous pouvez écouter l’événement connectionStateChanged
pour déterminer si Call Agent
passe de l’état Connecté à l’état Déconnecté.
const connectionState = callAgentInstance.connectionState;
console.log(connectionState); // it may return either of 'Connected' | 'Disconnected'
const connectionStateCallback = (args) => {
console.log(args); // it will return an object with oldState and newState, each of having a value of either of 'Connected' | 'Disconnected'
// it will also return reason, either of 'invalidToken' | 'connectionIssue'
}
callAgentInstance.on('connectionStateChanged', connectionStateCallback);
Avertissement
En raison des modifications apportées à Microsoft Teams, JavaScript appelant des Kits de développement logiciel (SDK) avec les versions 1.21 et antérieures arrête la transcription Teams et empêche les utilisateurs Teams de démarrer la transcription. Si vous souhaitez tirer parti de la transcription Teams dans les appels et les réunions, vous devez mettre à niveau votre Kit de développement logiciel (SDK) d’appel vers au moins la version 1.22.
Transcription des appels
Transcription
est une fonctionnalité étendue de la classe Call
. Vous devez d’abord obtenir l’objet d’API de la fonctionnalité de transcription.
const callTranscriptionFeature = call.feature(Features.Transcription);
Vous pouvez vérifier l’état de la transcription dans la propriété isTranscriptionActive
. Si la valeur est définie sur true
, c’est que la transcription est active.
const isTranscriptionActive = callTranscriptionFeature.isTranscriptionActive;
Vous pouvez vous abonner à un événement déclenché quand l’état de la transcription change :
const isTranscriptionActiveChangedHandler = () => {
console.log(callTranscriptionFeature.isTranscriptionActive);
};
callTranscriptionFeature.on('isTranscriptionActiveChanged', isTranscriptionActiveChangedHandler);
Vous pouvez vous désabonner de l’événement avec le code suivant :
callTranscriptionFeature.off('isTranscriptionActiveChanged', isTranscriptionActiveChangedHandler);
Installer le SDK
Localisez votre fichier build.gradle au niveau du projet et ajoutez mavenCentral()
à la liste des référentiels sous buildscript
et allprojects
:
buildscript {
repositories {
...
mavenCentral()
...
}
}
allprojects {
repositories {
...
mavenCentral()
...
}
}
Ensuite, dans votre fichier build.gradle au niveau du module, ajoutez les lignes suivantes à la section dependencies
:
dependencies {
...
implementation 'com.azure.android:azure-communication-calling:1.0.0'
...
}
Initialiser les objets nécessaires
Pour créer une instance CallAgent
, vous devez appeler la méthode createCallAgent
sur une instance CallClient
. Cet appel retourne de façon asynchrone un objet d’instance CallAgent
.
La méthode createCallAgent
prend CommunicationUserCredential
en tant qu’argument, qui encapsule un jeton d’accès.
Pour accéder à DeviceManager
, vous devez d’abord créer une instance callAgent
. Vous pouvez ensuite utiliser la méthode CallClient.getDeviceManager
pour obtenir DeviceManager
.
String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential).get();
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();
Pour définir un nom d’affichage pour l’appelant, utilisez cette autre méthode :
String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisplayName("Alice Bob");
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential, callAgentOptions).get();
Avertissement
Jusqu’à la version 1.1.0 et la version bêta 1.1.0-beta.1 d’Azure Communication Services Calling Android SDK, isTranscriptionActive
et addOnIsTranscriptionActiveChangedListener
font partie de l’objet Call
. Pour les nouvelles versions bêta, ces API ont été déplacées comme une fonctionnalité étendue de Call
tout comme décrit ci-dessous.
La transcription des appels est une fonctionnalité étendue de l’objet Call
principal. Vous devez d’abord obtenir l’objet de la fonctionnalité de transcription :
TranscriptionCallFeature callTranscriptionFeature = call.feature(Features.TRANSCRIPTION);
Ensuite, pour vérifier si l’appel est en cours d’enregistrement, vérifiez la propriété isTranscriptionActive
de callTranscriptionFeature
. Elle retourne boolean
.
boolean isTranscriptionActive = callTranscriptionFeature.isTranscriptionActive();
Vous pouvez également vous abonner aux modifications apportées à la transcription :
private void handleCallOnIsTranscriptionChanged(PropertyChangedEvent args) {
boolean isTranscriptionActive = callTranscriptionFeature.isTranscriptionActive();
}
callTranscriptionFeature.addOnIsTranscriptionActiveChangedListener(handleCallOnIsTranscriptionChanged);
Configurer votre système
Créer le projet Xcode
Dans Xcode, créez un projet iOS et sélectionnez le modèle Single View App. Ce guide de démarrage rapide utilise l’infrastructure SwiftUI. Vous devez donc définir le langage sur Swift et l’interface sur SwiftUI.
Vous n’allez pas créer de tests au cours de ce guide démarrage rapide. N’hésitez pas à désactiver la case Inclure des tests.
Installer le package et les dépendances à l’aide de CocoaPods
Créez un Podfile pour votre application, comme cet exemple :
platform :ios, '13.0' use_frameworks! target 'AzureCommunicationCallingSample' do pod 'AzureCommunicationCalling', '~> 1.0.0' end
Exécutez
pod install
.Ouvrez
.xcworkspace
en utilisant Xcode.
Demander l’accès au microphone
Pour accéder au microphone de l’appareil, vous devez mettre à jour la liste des propriétés d’informations de votre application à l’aide de NSMicrophoneUsageDescription
. Vous définissez la valeur associée sur une chaîne qui sera incluse dans la boîte de dialogue utilisée par le système pour demander l’accès de l’utilisateur.
Cliquez avec le bouton droit sur l’entrée Info.plist de l’arborescence du projet, puis sélectionnez Ouvrir en tant que>Code source. Ajoutez les lignes suivantes à la section <dict>
tout en haut, puis enregistrez le fichier.
<key>NSMicrophoneUsageDescription</key>
<string>Need microphone access for VOIP calling.</string>
Configurer le framework d’application
Ouvrez le fichier ContentView.swift de votre projet. Ajoutez une déclaration import
en haut du fichier pour importer la bibliothèque AzureCommunicationCalling
. En outre, importez AVFoundation
. Vous en aurez besoin pour les demandes d’autorisations audio dans le code.
import AzureCommunicationCalling
import AVFoundation
Initialiser CallAgent
Pour créer une instance de CallAgent
à partir de CallClient
, vous devez utiliser une méthode callClient.createCallAgent
qui retourne de manière asynchrone un objet CallAgent
après qu’il a été initialisé.
Pour créer un client d’appel, transmettez un objet CommunicationTokenCredential
:
import AzureCommunication
let tokenString = "token_string"
var userCredential: CommunicationTokenCredential?
do {
let options = CommunicationTokenRefreshOptions(initialToken: token, refreshProactively: true, tokenRefresher: self.fetchTokenSync)
userCredential = try CommunicationTokenCredential(withOptions: options)
} catch {
updates("Couldn't created Credential object", false)
initializationDispatchGroup!.leave()
return
}
// tokenProvider needs to be implemented by Contoso, which fetches a new token
public func fetchTokenSync(then onCompletion: TokenRefreshOnCompletion) {
let newToken = self.tokenProvider!.fetchNewToken()
onCompletion(newToken, nil)
}
Transmettez l’objet CommunicationTokenCredential
que vous avez créé à CallClient
et définissez le nom complet :
self.callClient = CallClient()
let callAgentOptions = CallAgentOptions()
options.displayName = " iOS Azure Communication Services User"
self.callClient!.createCallAgent(userCredential: userCredential!,
options: callAgentOptions) { (callAgent, error) in
if error == nil {
print("Create agent succeeded")
self.callAgent = callAgent
} else {
print("Create agent failed")
}
})
Avertissement
Jusqu’à la version 1.1.0 et la version bêta 1.1.0-beta.1 d’Azure Communication Services Calling iOS SDK, isTranscriptionActive
fait partie de l’objet Call
, et didChangeTranscriptionState
fait partie du délégué CallDelegate
. Pour les nouvelles versions bêta, ces API ont été déplacées comme une fonctionnalité étendue de Call
tout comme décrit ci-dessous.
La transcription des appels est une fonctionnalité étendue de l’objet Call
principal. Vous devez d’abord obtenir l’objet de la fonctionnalité de transcription :
let callTranscriptionFeature = call.feature(Features.transcription)
Ensuite, pour vérifier si l’appel est en cours d’enregistrement, vérifiez la isTranscriptionActive
propriété de callTranscriptionFeature
. Elle retourne Bool
.
let isTranscriptionActive = callTranscriptionFeature.isTranscriptionActive;
Vous pouvez également vous abonner à l’enregistrement des modifications en implémentant le délégué TranscriptionCallFeatureDelegate
sur votre classe avec l’événement didChangeTranscriptionState
:
callTranscriptionFeature.delegate = self
// didChangeTranscriptionState is a member of TranscriptionCallFeatureDelegate
public func transcriptionCallFeature(_ transcriptionCallFeature: TranscriptionCallFeature, didChangeTranscriptionState args: PropertyChangedEventArgs) {
let isTranscriptionActive = callTranscriptionFeature.isTranscriptionActive
}
Configurer votre système
Créer le projet Visual Studio
Pour une application UWP, dans Visual Studio 2022, créez un projet Application vide (Windows universel). Après avoir entré le nom du projet, n’hésitez pas à choisir un kit de développement logiciel (SDK) Windows d’une version ultérieure à 10.0.17763.0.
Pour une application WinUI 3, créez un projet avec le modèle Application vide, Empaquetée (WinUI 3 dans Desktop) pour configurer une application WinUI 3 monopage. Le SDK d’application Windows version 1.3 ou ultérieure est nécessaire.
Installer le package et les dépendances à l’aide du Gestionnaire de package NuGet
Les API et les bibliothèques du Kit de développement logiciel (SDK) Appel sont accessibles au public via un package NuGet.
Les étapes suivantes illustrent comment rechercher, télécharger et installer le package NuGet du kit de développement logiciel (SDK) Calling :
- Ouvrez le Gestionnaire de package NuGet en sélectionnant Outils>Gestionnaire de package NuGet>Gérer les packages NuGet pour la solution.
- Sélectionnez Parcourir, puis entrez
Azure.Communication.Calling.WindowsClient
dans la zone de recherche. - Vérifiez que la case Inclure la préversion est activée.
- Sélectionnez le package
Azure.Communication.Calling.WindowsClient
, puisAzure.Communication.Calling.WindowsClient
1.4.0-beta.1 ou une version plus récente. - Activez la case correspondant au projet Communication Services dans l’onglet de droite.
- Sélectionnez le bouton Installer.
La transcription des appels est une fonctionnalité étendue de l’objet Call
principal. Vous devez d’abord obtenir l’objet de la fonctionnalité de transcription :
TranscriptionCallFeature transcriptionFeature = call.Features.Transcription;
Ensuite, pour vérifier si l’appel est en cours d’enregistrement, vérifiez la propriété IsTranscriptionActive
de transcriptionFeature
. Elle retourne boolean
.
boolean isTranscriptionActive = transcriptionFeature.isTranscriptionActive;
Vous pouvez également vous abonner aux modifications apportées à la transcription :
private async void Call__OnIsTranscriptionActiveChanged(object sender, PropertyChangedEventArgs args)
boolean isTranscriptionActive = transcriptionFeature.IsTranscriptionActive();
}
transcriptionFeature.IsTranscriptionActiveChanged += Call__OnIsTranscriptionActiveChanged;