Freigeben über

Verwalten der Anrufaufzeichnung auf dem Client

  • Artikel

Wichtig

Die in diesem Artikel beschriebenen Funktionen befinden sich derzeit in der öffentlichen Vorschauphase. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und ist nicht für Produktionsworkloads vorgesehen. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Zusätzliche Nutzungsbestimmungen für Microsoft Azure-Vorschauen.

Die Anrufaufzeichnung ermöglicht es Ihren Benutzern, ihre Anrufe, die Sie über Azure Communication Services tätigen, aufzuzeichnen. In diesem Artikel erfahren Sie, wie Sie die Aufzeichnung auf der Clientseite verwalten. Bevor Sie beginnen, müssen Sie die Aufzeichnung auf der Serverseite einrichten.

Voraussetzungen

Unterstützung

In den folgenden Tabellen wird die Unterstützung von Aufzeichnungen in Azure Communication Services definiert.

Identitäten und Anruftypen

Die folgenden Tabellen zeigen die Unterstützung der Aufzeichnung für bestimmte Anruftypen und Identitäten.

Identities Teams-Besprechung Raum 1:1-Anruf Gruppenanruf 1:1 Teams-Interoperabilitätsanruf Gruppenteams-Interoperabilitätsanruf
Communication Services-Benutzer ✔️[1] ✔️[2] ✔️[2] ✔️[2] ✔️[1] ✔️[1][2]
Microsoft 365-Benutzer ✔️[1] ✔️[2] ✔️[1] ✔️[1][2]

[1] Diese Anruftypen unterstützen die Cloud- und Complianceaufzeichnung in Teams.
[2] Diese Anruftypen unterstützen die Azure Communication Services-Aufzeichnung.

Vorgänge

Die folgenden Tabellen zeigen die Unterstützung einzelner APIs beim Aufruf des SDK für einzelne Identitätstypen.

Vorgänge Communication Services-Benutzer Microsoft 365-Benutzer
Erhalten einer Benachrichtigung, dass die Aufzeichnung gestartet oder beendet wurde ✔️ ✔️
Erhalten des Aufzeichnungszustands ✔️ ✔️
Erhalten einer Benachrichtigung, dass eine Aufzeichnung verfügbar ist ✔️[1] ✔️[1]
Erfahren, ob eine explizite Einwilligung erforderlich ist ✔️[2] ✔️[2]
Explizite Einwilligung in die Aufzeichnung ✔️[2] ✔️[2]

[1] Der Benutzer wird nicht benachrichtigt, dass eine Aufzeichnung verfügbar ist. Sie können die Teams-Cloudaufzeichnung über die Microsoft Graph-API abrufen. Sie können in Azure Communication Services eine Benachrichtigung abonnieren, wenn eine Aufzeichnung verfügbar ist.

[2] Diese Funktionalität ist nur in Teams-Besprechungen und -Interoperabilitätsgruppenanrufen verfügbar.

SDKs

Die folgenden Tabellen zeigen die Unterstützung der Aufzeichnung in einzelnen Azure Communication Services SDKs.

Plattformen Web Web-Benutzeroberfläche iOS iOS-Benutzeroberfläche Android Android-Benutzeroberfläche Windows
Unterstützt ✔️ ✔️[1] ✔️[1] ✔️[1] ✔️[1] ✔️[1] ✔️[1]

[1] Diese SDKs unterstützen keine explizite Einwilligung.

Das SDK installieren

Verwenden Sie den Befehl npm install, um die Common und Calling SDKs von Azure Communication Services für JavaScript zu installieren:

npm install @azure/communication-common --save
npm install @azure/communication-calling --save

Initialisieren erforderlicher Objekte

Für die meisten Anrufvorgänge ist eine CallClient-Instanz erforderlich. Wenn Sie eine neue CallClient-Instanz erstellen, können Sie diese mit benutzerdefinierten Optionen wie einer Logger-Instanz konfigurieren.

Mit der CallClient-Instanz können Sie eine CallAgent-Instanz erstellen, indem Sie den Agent für die Anruferstellung (createCallAgent) aufrufen. Durch diese Methode wird ein CallAgent-Instanzobjekt asynchron zurückgegeben.

Die Methode createCallAgent verwendet CommunicationTokenCredential als Argument, welches ein Benutzerzugriffstoken akzeptiert.

Sie können die Methode getDeviceManager für die Instanz CallClient verwenden, um auf deviceManager zuzugreifen.

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()

Optimale Verwaltung der Konnektivität zwischen SDK und Microsoft-Infrastruktur

Die Call Agent-Instanz unterstützt Sie bei der Verwaltung von Anrufen (Annehmen oder Starten von Anrufen). Damit Ihr Calling SDK funktioniert, muss eine Verbindung mit der Microsoft-Infrastruktur hergestellt werden, um Benachrichtigungen über eingehende Anrufe zu erhalten und andere Anrufdetails zu koordinieren. Ihre Call Agent-Instanz kann zwei Status haben:

Connected (Verbunden) – Der connectionState-Wert Connected für Call Agent bedeutet, dass das Client-SDK verbunden ist und Benachrichtigungen von der Microsoft-Infrastruktur empfangen kann.

Disconnected (Getrennt) – Der connectionState-Wert Disconnected für Call Agent weist darauf hin, dass das SDK nicht ordnungsgemäß verbunden werden kann. Call Agent muss neu erstellt werden.

  • invalidToken: Wenn ein Token abgelaufen oder ungültig ist, wird die Call Agent-Instanz mit diesem Fehler getrennt.
  • connectionIssue: Wenn ein Problem mit der Verbindung zwischen dem Client und der Microsoft-Infrastruktur auftritt, gibt Call Agent nach mehreren Versuchen den connectionIssue-Fehler zurück.

Sie können überprüfen, ob Ihre lokale Call Agent-Instanz mit der Microsoft-Infrastruktur verbunden ist, indem Sie den aktuellen Wert der connectionState-Eigenschaft prüfen. Während eines aktiven Anrufs können Sie auf das connectionStateChanged-Ereignis lauschen, um zu bestimmen, ob sich der Call Agent-Status von Connected in Disconnected ändert.

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);

Hinweis

Diese API wird als Vorschau für Entwickler bereitgestellt. Je nachdem, welches Feedback wir dazu erhalten, werden möglicherweise Änderungen vorgenommen. Verwenden Sie diese API nicht in einer Produktionsumgebung. Zum Verwenden dieser API nutzen Sie die Betaversion des Azure Communication Services Calling Web SDK.

Cloudaufzeichnung

Die Aufrufaufzeichnung ist ein erweitertes Feature der zentralen Aufruf-API. Sie müssen zunächst Anruffunktionen aus dem Calling SDK importieren:

import { Features} from "@azure/communication-calling";

Anschließend können Sie das API-Objekt für die Aufzeichnungsfeatures aus der Anrufinstanz abrufen:

const callRecordingApi = call.feature(Features.Recording);

Um zu ermitteln, ob der Anruf aufgezeichnet wird, prüfen Sie die Eigenschaft isRecordingActive von callRecordingApi. Er gibt Boolean zurück.

const isRecordingActive = callRecordingApi.isRecordingActive;

Sie können auch Aufzeichnungsänderungen abonnieren:

const isRecordingActiveChangedHandler = () => {
    console.log(callRecordingApi.isRecordingActive);
};

callRecordingApi.on('isRecordingActiveChanged', isRecordingActiveChangedHandler);

Sie können eine Liste der Aufzeichnungen mithilfe der Eigenschaft recordings von callRecordingApi abrufen. Zurückgegeben wird RecordingInfo[]. Dieses Element enthält den aktuellen Zustand der Cloudaufzeichnung.

const recordings = callRecordingApi.recordings;

recordings.forEach(r => {
    console.log("State: ${r.state}");

Sie können auch recordingsUpdated abonnieren und eine Sammlung aktualisierter Aufzeichnungen abrufen. Dieses Ereignis wird immer dann ausgelöst, wenn eine Aufzeichnungsaktualisierung erfolgt.

const cloudRecordingsUpdatedHandler = (args: { added: SDK.RecordingInfo[], removed: SDK.RecordingInfo[]}) => {
                        console.log('Recording started by: ');
                        args.added?.forEach(a => {
                            console.log('State: ${a.state}');
                        });

                        console.log('Recording stopped by: ');
                        args.removed?.forEach(r => {
                            console.log('State: ${r.state}');
                        });
                    };
callRecordingApi.on('recordingsUpdated', cloudRecordingsUpdatedHandler );

Wenn Ihre Teams-Besprechung oder Ihr Anruf so konfiguriert ist, dass eine explizite Einwilligung für Aufzeichnung und Transkription erforderlich ist, müssen Sie die Einwilligung aller Teilnehmer am Anruf einholen, bevor Sie sie aufzeichnen können. Sie können proaktiv einwilligen, wenn Sie an der Besprechung teilnehmen, oder reaktiv beim Starten der Aufzeichnung. Bis zur ausdrücklichen Einwilligung wird die Audio-, Video- und Bildschirmfreigabe der Teilnehmer während der Aufzeichnung deaktiviert.

Sie können anhand der Eigenschaft isTeamsConsentRequired überprüfen, ob für die Besprechungsaufzeichnung die explizite Einwilligung erforderlich ist. Wenn der Wert auf true festgelegt ist, ist für call eine explizite Einwilligung erforderlich.

const isConsentRequired = callRecordingApi.isTeamsConsentRequired;

Wenn Sie die Einwilligung des Benutzers für die Aufzeichnung bereits erhalten haben, können Sie die grantTeamsConsent()-Methode aufrufen, um die explizite Einwilligung zum Dienst anzugeben. Diese Einwilligung gilt nur für eine call-Sitzung, und Benutzer müssen erneut einwilligen, wenn sie erneut an der Besprechung teilnehmen.

callRecordingApi.grantTeamsConsent();

Versuche zum Aktivieren von Audio-, Video- oder Bildschirmfreigabe schlagen fehl, wenn die Aufzeichnung aktiv und die explizite Einwilligung erforderlich ist, aber noch nicht gegeben wurde. Sie erkennen diese Situation, indem Sie die Eigenschaft reason der Klasse ParticipantCapabilities auf die Funktionen turnVideoOn, unmuteMic und shareScreen überprüfen. Sie finden diese Funktionen im Feature call.feature(Features.Capabilities). Diese Funktionen geben den Grund ExplicitConsentRequired zurück, da Benutzer ihre explizite Einwilligung erteilen müssen.

Das SDK installieren

Wählen Sie Ihre Datei build.gradle auf Projektebene aus, und fügen Sie mavenCentral() der Liste der Repositorys unter buildscript und allprojects hinzu:

buildscript {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

allprojects {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

Fügen Sie anschließend in der Datei build.gradle auf Modulebene die folgenden Zeilen im Abschnitt dependencies hinzu:

dependencies {
    ...
    implementation 'com.azure.android:azure-communication-calling:1.0.0'
    ...
}

Initialisieren der erforderlichen Objekte

Zum Erstellen einer CallAgent-Instanz müssen Sie die createCallAgent-Methode für eine CallClient-Instanz aufrufen. Dieser Aufruf gibt asynchron ein CallAgent-Instanzobjekt zurück.

Die createCallAgent-Methode verwendet CommunicationUserCredential als Argument, womit ein Zugriffstoken gekapselt wird.

Um auf DeviceManager zuzugreifen, müssen Sie zuerst eine callAgent-Instanz erstellen. Anschließend können Sie die CallClient.getDeviceManager-Methode zum Abrufen von DeviceManager verwenden.

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();

Zum Festlegen eines Anzeigenamens für den Anrufer verwenden Sie diese alternative Methode:

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();

Aufzeichnen von Anrufen

Hinweis

Diese API wird als Vorschau für Entwickler bereitgestellt. Je nachdem, welches Feedback wir dazu erhalten, werden möglicherweise Änderungen vorgenommen. Verwenden Sie diese API nicht in einer Produktionsumgebung. Zum Verwenden dieser API nutzen Sie die Betaversion des Azure Communication Services Calling Android SDK.

Die Anrufaufzeichnung ist ein erweitertes Feature des zentralen Call-Objekts.

Warnung

Bis zur Version 1.1.0 und Betaversion 1.1.0-beta.1 des Azure Communication Services Calling Android SDK sind isRecordingActive und addOnIsRecordingActiveChangedListener Teil des Call-Objekts. Für die neuen Betaversionen wurden diese APIs als erweitertes Feature von Call verschoben.

Sie müssen zunächst das Objekt der Aufzeichnungsfunktion abrufen:

RecordingCallFeature callRecordingFeature = call.feature(Features.RECORDING);

Um anschließend herauszufinden, ob der Anruf aufgezeichnet wird, prüfen Sie die Eigenschaft isRecordingActive von callRecordingFeature. Er gibt boolean zurück.

boolean isRecordingActive = callRecordingFeature.isRecordingActive();

Sie können auch Aufzeichnungsänderungen abonnieren:

private void handleCallOnIsRecordingChanged(PropertyChangedEvent args) {
  boolean isRecordingActive = callRecordingFeature.isRecordingActive();
}

callRecordingFeature.addOnIsRecordingActiveChangedListener(handleCallOnIsRecordingChanged);

Wenn Sie die Aufzeichnung aus Ihrer Anwendung heraus starten möchten, sehen Sie sich zunächst die Übersicht über die Anrufaufzeichnung an. Dort finden Sie die Schritte zum Einrichten der Anrufaufzeichnung.

Sobald Sie die Anrufaufzeichnung auf Ihrem Server eingerichtet haben, müssen Sie von Ihrer Android-Anwendung aus den ServerCallId-Wert des Anrufs abrufen und ihn dann an Ihren Server senden, um den Aufzeichnungsprozess zu starten. Sie ermitteln den Wert ServerCallId mithilfe von getServerCallId() aus der CallInfo-Klasse. Sie ermitteln die CallInfo-Klasse im Klassenobjekt mithilfe von getInfo().

try {
    String serverCallId = call.getInfo().getServerCallId().get();
    // Send serverCallId to your recording server to start the call recording.
} catch (ExecutionException | InterruptedException e) {

} catch (UnsupportedOperationException unsupportedOperationException) {

}

Wenn Sie mit der Aufzeichnung auf dem Server beginnen, wird das Ereignis handleCallOnIsRecordingChanged ausgelöst, und der Wert von callRecordingFeature.isRecordingActive() lautet true.

Genau wie beim Starten der Anrufaufzeichnung müssen Sie, wenn Sie die Aufzeichnung beenden möchten, ServerCallId abrufen und an Ihren Aufzeichnungsserver senden, sodass dieser die Aufzeichnung beenden kann:

try {
    String serverCallId = call.getInfo().getServerCallId().get();
    // Send serverCallId to your recording server to stop the call recording.
} catch (ExecutionException | InterruptedException e) {

} catch (UnsupportedOperationException unsupportedOperationException) {

}

Wenn Sie die Aufzeichnung auf dem Server beenden, wird das Ereignis handleCallOnIsRecordingChanged ausgelöst, und der Wert von callRecordingFeature.isRecordingActive() lautet false.

Einrichten des Systems

Führen Sie die unten angegebenen Schritte aus, um Ihr System einzurichten.

Erstellen des Xcode-Projekts

Erstellen Sie in Xcode ein neues iOS-Projekt, und wählen Sie die Vorlage Single View App (Einzelansicht-App) aus. In diesem Artikel wird das SwiftUI-Framework verwendet. Legen Sie daher Sprache auf Swift und Schnittstelle auf SwiftUI fest.

Sie werden in diesem Artikel keine Tests erstellen. Sie können das Kontrollkästchen Tests einschließen deaktivieren.

Screenshot: Fenster zum Erstellen eines Projekts in Xcode

Installieren des Pakets und der Abhängigkeiten mithilfe von CocoaPods

  1. Erstellen Sie eine Podfile-Datei für die Anwendung, wie in diesem Beispiel:

    platform :ios, '13.0'
use_frameworks!
target 'AzureCommunicationCallingSample' do
    pod 'AzureCommunicationCalling', '~> 1.0.0'
end

  2. Führen Sie pod install aus.

  3. Öffnen Sie .xcworkspace mithilfe von Xcode.

Anfordern des Zugriffs auf das Mikrofon

Um auf das Mikrofon des Geräts zuzugreifen, müssen Sie die Liste der Informationseigenschaften Ihrer App mithilfe von NSMicrophoneUsageDescription aktualisieren. Legen Sie den zugehörigen Wert auf eine Zeichenfolge fest. Diese wird in den Dialog aufgenommen, mit dem das System den Zugriff beim Benutzer anfordert.

Klicken Sie mit der rechten Maustaste auf den Eintrag info.plist in der Projektstruktur, und wählen Sie dann Öffnen als>Quellcode aus. Fügen Sie im Abschnitt <dict> der obersten Ebene die folgenden Zeilen hinzu, und speichern Sie dann die Datei.

<key>NSMicrophoneUsageDescription</key>
<string>Need microphone access for VOIP calling.</string>

Einrichten des App-Frameworks

Öffnen Sie die Datei ContentView.swift Ihres Projekts. Fügen Sie am Anfang der Datei eine import-Deklaration hinzu, um die AzureCommunicationCalling-Bibliothek zu importieren. Importieren Sie außerdem AVFoundation. Sie ist für Audioberechtigungsanforderungen im Code erforderlich.

import AzureCommunicationCalling
import AVFoundation

Initialisieren von „CallAgent“

Um eine CallAgent-Instanz auf der Grundlage von CallClient zu erstellen, müssen Sie eine Methode vom Typ callClient.createCallAgent verwenden, die asynchron ein Objekt vom Typ CallAgent zurückgibt, nachdem es initialisiert wurde.

Übergeben Sie für die Erstellung eines Anrufclients ein Objekt vom Typ 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)
}

Übergeben Sie das von Ihnen erstellte CommunicationTokenCredential-Objekt an CallClient, und legen Sie den Anzeigenamen fest:

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")
        }
})

Aufzeichnen von Anrufen

Hinweis

Diese API wird als Vorschau für Entwickler bereitgestellt. Je nachdem, welches Feedback wir dazu erhalten, werden möglicherweise Änderungen vorgenommen. Verwenden Sie diese API nicht in einer Produktionsumgebung. Zum Verwenden dieser API nutzen Sie die Betaversion des Azure Communication Services Calling iOS SDK.

Die Anrufaufzeichnung ist ein erweitertes Feature des zentralen Call-Objekts.

Warnung

Bis zur Version 1.1.0 und Betaversion 1.1.0-beta.1 des Azure Communication Services Calling iOS SDK war isRecordingActive Teil des Call-Objekts und didChangeRecordingState Teil des CallDelegate-Delegaten. Für die neuen Betaversionen wurden diese APIs als erweitertes Feature von Call verschoben.

Sie müssen zunächst das Objekt der Aufzeichnungsfunktion abrufen:

let callRecordingFeature = call.feature(Features.recording)

Um anschließend herauszufinden, ob der Anruf aufgezeichnet wird, prüfen Sie die Eigenschaft isRecordingActive von callRecordingFeature. Er gibt Bool zurück.

let isRecordingActive = callRecordingFeature.isRecordingActive;

Sie können die Aufzeichnung von Änderungen auch abonnieren, indem Sie den RecordingCallFeatureDelegate-Delegaten für Ihre Klasse mit dem Ereignis didChangeRecordingState implementieren:

callRecordingFeature.delegate = self

// didChangeRecordingState is a member of RecordingCallFeatureDelegate
public func recordingCallFeature(_ recordingCallFeature: RecordingCallFeature, didChangeRecordingState args: PropertyChangedEventArgs) {
    let isRecordingActive = recordingFeature.isRecordingActive
}

Wenn Sie die Aufzeichnung aus Ihrer Anwendung heraus starten möchten, sehen Sie sich zunächst die Übersicht über die Anrufaufzeichnung an. Dort finden Sie die Schritte zum Einrichten der Anrufaufzeichnung.

Sobald Sie die Anrufaufzeichnung auf Ihrem Server eingerichtet haben, müssen Sie von Ihrer iOS-Anwendung aus den ServerCallId-Wert des Anrufs abrufen und ihn dann an Ihren Server senden, um den Aufzeichnungsprozess zu starten. Sie ermitteln den Wert ServerCallId mithilfe von getServerCallId() aus der CallInfo-Klasse. Sie ermitteln die CallInfo-Klasse im Klassenobjekt mithilfe von getInfo().

// Send serverCallId to your recording server to start the call recording.
let serverCallId = call.info.getServerCallId(){ (serverId, error) in }

Wenn Sie mit der Aufzeichnung auf dem Server beginnen, wird das Ereignis didChangeRecordingState ausgelöst, und der Wert von recordingFeature.isRecordingActive lautet true.

Genau wie beim Starten der Anrufaufzeichnung müssen Sie, wenn Sie die Aufzeichnung beenden möchten, ServerCallId abrufen und an Ihren Aufzeichnungsserver senden, sodass dieser die Aufzeichnung beenden kann:

// Send serverCallId to your recording server to stop the call recording.
let serverCallId = call.info.getServerCallId(){ (serverId, error) in }

Wenn Sie die Aufzeichnung auf dem Server beenden, wird das Ereignis didChangeRecordingState ausgelöst, und der Wert von recordingFeature.isRecordingActive lautet false.

Einrichten des Systems

Führen Sie die unten angegebenen Schritte aus, um Ihr System einzurichten.

Erstellen des Visual Studio-Projekts

Erstellen Sie für eine UWP-App (Universelle Windows-Plattform) in Visual Studio 2022 ein neues Projekt vom Typ Leere App (universelles Windows). Nachdem Sie den Projektnamen eingegeben haben, können Sie ein beliebiges Windows SDK höher als Version 10.0.17763.0 auswählen.

Für eine WinUI 3-App erstellen Sie ein neues Projekt mit der Vorlage Leere App, Gepackt (WinUI 3 in Desktop), um eine WinUI 3-Single-Page-Webanwendung einzurichten. Windows-App SDK-Version 1.3 oder höher ist erforderlich.

Installieren Sie das Paket und die Abhängigkeiten mit dem NuGet-Paket-Manager

Die Calling SDK-APIs und -Bibliotheken sind über ein NuGet-Paket öffentlich verfügbar.

So können Sie das NuGet-Paket für das Calling SDK suchen, herunterladen und installieren:

  1. Öffnen Sie den NuGet-Paket-Manager, indem Sie Tools>NuGet-Paket-Manager>NuGet-Pakete für Lösung verwalten auswählen.
  2. Wählen Sie Durchsuchen aus, und geben Sie dann Azure.Communication.Calling.WindowsClient in das Suchfeld ein.
  3. Stellen Sie sicher, dass das Kontrollkästchen Vorabversion einbeziehen aktiviert ist.
  4. Wählen Sie das Paket Azure.Communication.Calling.WindowsClient und dann Azure.Communication.Calling.WindowsClient 1.4.0-beta.1 oder eine neuere Version aus.
  5. Aktivieren Sie das Kontrollkästchen für das Azure Communication Services-Projekt im rechten Bereich.
  6. Wählen Sie Installieren aus.

Aufzeichnen von Anrufen

Die Anrufaufzeichnung ist ein erweitertes Feature des zentralen Call-Objekts. Sie müssen zunächst das Objekt der Aufzeichnungsfunktion abrufen:

RecordingCallFeature recordingFeature = call.Features.Recording;

Um anschließend herauszufinden, ob der Anruf aufgezeichnet wird, prüfen Sie die Eigenschaft IsRecordingActive von recordingFeature. Er gibt boolean zurück.

boolean isRecordingActive = recordingFeature.IsRecordingActive;

Sie können auch Aufzeichnungsänderungen abonnieren:

private async void Call__OnIsRecordingActiveChanged(object sender, PropertyChangedEventArgs args)
  boolean isRecordingActive = recordingFeature.IsRecordingActive;
}

recordingFeature.IsRecordingActiveChanged += Call__OnIsRecordingActiveChanged;

Complianceaufzeichnung

Die Complianceaufzeichnung basiert auf der Microsoft Teams-Richtlinie. Sie können sie mithilfe dieses Tutorials aktivieren: Einführung in die richtlinienbasierte Aufzeichnung von Teams für Anrufe & Besprechungen.

Die richtlinienbasierte Aufzeichnung wird automatisch gestartet, wenn ein Benutzer, der über die Richtlinie verfügt, einem Anruf beitritt. Um eine Benachrichtigung von Azure Communication Services zur Aufzeichnung zu erhalten, verwenden Sie den folgenden Code:

const callRecordingApi = call.feature(Features.Recording);

const isComplianceRecordingActive = callRecordingApi.isRecordingActive;

const isComplianceRecordingActiveChangedHandler = () => {
    console.log(callRecordingApi.isRecordingActive);
};

callRecordingApi.on('isRecordingActiveChanged', isComplianceRecordingActiveChangedHandler);

Sie können die Complianceaufzeichnung auch mithilfe eines benutzerdefinierten Aufzeichnungs-Bots implementieren. Sehen Sie sich dieses GitHub-Beispiel an.

Nächste Schritte