Schnellstart: Verwalten eines Chatroom-Anrufs

Einführung

Während eines Azure Communication Services (ACS)-Chatroom-Anrufs können Sie den Anruf mithilfe von Anruf-SDKs oder Anrufautomatisierungs-SDKs oder beides verwalten. In einem Chatroom-Anruf können Sie In-Call-Aktionen mithilfe der Rollen steuern, die Teilnehmern zugewiesen sind, und Eigenschaften, die im Raum konfiguriert sind. Die Rollensteuerungsfunktionen des Teilnehmers pro Teilnehmer sind zulässig, während Room-Eigenschaften für den gesamten Chatroom-Anruf gelten.

Calling SDKs

Das Anruf-SDK ist eine clientseitige Anrufbibliothek, mit der Teilnehmer in einem Chatroom-Anruf mehrere In-Call-Vorgänge ausführen können, z. B. Bildschirmfreigabe, Video ein-/ausschalten, Stummschalten/Stummschaltung aufheben usw. Die vollständige Liste der Funktionen finden Sie unter SDK-Anrufe-Übersicht.

Sie steuern die Funktionen basierend auf Rollen, die Teilnehmern im Anruf zugewiesen sind. Beispielsweise kann nur der Referent Bildschirmfreigaben machen. Informationen zu Teilnehmerrollen und -berechtigungen finden Sie unter Räume-Konzepte.

Anrufautomatisierungs-SDKs

Das Anrufautomatisierungs-SDK ist eine serverseitige Bibliothek, mit der Administratoren einen laufenden Chatroom-Anruf in einer zentralen und kontrollierten Umgebung verwalten können. Im Gegensatz zum Aufrufen des SDK sind Anrufautomatisierungs-SDK-Vorgänge rollenunabhängig. Daher kann ein Anrufadministrator mehrere Anrufvorgänge im Namen der Teilnehmer des Chatrooms ausführen.

In den folgenden Listen werden allgemeine In-Call-Aktionen beschrieben, die in einem Chatroom verfügbar sind.

Herstellen einer Verbindung mit einem Raumanruf

Die Anrufautomatisierung muss eine Verbindung mit einem vorhandenen Chatroom-Anruf herstellen, bevor In-Call-Vorgänge ausgeführt werden. Die CallConnected oder ConnectFailed Ereignisse werden mithilfe von Rückrufmechanismen ausgelöst, um anzugeben, ob ein Verbindungsvorgang erfolgreich war oder fehlgeschlagen ist.

csharp

Uri callbackUri = new Uri("https://<myendpoint>/Events"); //the callback endpoint where you want to receive subsequent events
CallLocator roomCallLocator = new RoomCallLocator("<RoomId>");
ConnectCallResult response = await client.ConnectAsync(roomCallLocator, callbackUri);

Java

String callbackUri = "https://<myendpoint>/Events"; //the callback endpoint where you want to receive subsequent events
CallLocator roomCallLocator =  new RoomCallLocator("<RoomId>");
ConnectCallResult response = client.connectCall(roomCallLocator, callbackUri).block();

JavaScript

const roomCallLocator = { kind: "roomCallLocator", id: "<RoomId>" };
const callbackUri = "https://<myendpoint>/Events"; // the callback endpoint where you want to receive subsequent events 
const response = await client.connectCall(roomCallLocator, callbackUri);

Python

callback_uri = "https://<myendpoint>/Events"  # the callback endpoint where you want to receive subsequent events
room_call_locator = RoomCallLocator("<room_id>")
call_connection_properties = client.connect_call(call_locator=room_call_locator, callback_url=callback_uri)

Sobald die Verbindung mit einem Chatroom-Anruf erfolgreich hergestellt wurde, wird ein CallConnect Ereignis über den Rückruf-URI benachrichtigt. Sie können callConnectionId verwenden, um bei Bedarf eine Anrufverbindung für den Chatroom-Anruf abzurufen. Die folgenden Beispielcodeausschnitte verwenden callConnectionId, um diese Funktion zu veranschaulichen.

Hinzufügen eines PSTN-Teilnehmers

Mithilfe der Anrufautomatisierung können Sie eine PstN-Nummer anrufen und den Teilnehmer zu einem Chatroom-Anruf hinzufügen. Sie müssen jedoch einen Room einrichten, um die PSTN-Auswahloption (EnabledPSTNDialout auf true festgelegt) zu aktivieren, und die Azure Communication Services-Ressource muss über eine gültige Telefonnummer verfügen.

Weitere Informationen finden Sie unter Räume – Schnellstart.

csharp

var callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the ACS-provisioned phone number for the caller  
var callThisPerson = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber); // The target phone number to dial out to
CreateCallResult response = await client.GetCallConnection(callConnectionId).AddParticipantAsync(callThisPerson);

Java

PhoneNumberIdentifier callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the ACS-provisioned phone number for the caller
CallInvite callInvite = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber); // The phone number participant to dial out to
AddParticipantOptions addParticipantOptions = new AddParticipantOptions(callInvite);
Response<AddParticipantResult> addParticipantResultResponse = client.getCallConnectionAsync(callConnectionId)
    .addParticipantWithResponse(addParticipantOptions).block();

JavaScript

const callInvite = {
    targetParticipant: { phoneNumber: "+18008008800" }, // The phone number participant to dial out to
    sourceCallIdNumber: { phoneNumber: "+18888888888" } // This is the ACS-provisioned phone number for the caller
};
const response = await client.getCallConnection(callConnectionId).addParticipant(callInvite);

Python

caller_id_number = PhoneNumberIdentifier(
    "+18888888888"
) # TThis is the ACS-provisioned phone number for the caller
target = PhoneNumberIdentifier("+18008008800"), # The phone number participant to dial out to

call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)
result = call_connection_client.add_participant(
    target,
    opration_context="Your context",
    operationCallbackUrl="<url_endpoint>"
)

Entfernen eines PSTN-Teilnehmers

csharp

var removeThisUser = new PhoneNumberIdentifier("+16044561234");

// Remove a participant from the call with optional parameters
var removeParticipantOptions = new RemoveParticipantOptions(removeThisUser)
{
    OperationContext = "operationContext",
    OperationCallbackUri = new Uri("uri_endpoint"); // Sending event to a non-default endpoint
}

RemoveParticipantsResult result = await client.GetCallConnection(callConnectionId).RemoveParticipantAsync(removeParticipantOptions);

Java

CommunicationIdentifier removeThisUser = new PhoneNumberIdentifier("+16044561234");
RemoveParticipantOptions removeParticipantOptions = new RemoveParticipantOptions(removeThisUser)
                .setOperationContext("<operation_context>")
                .setOperationCallbackUrl("<url_endpoint>");
Response<RemoveParticipantResult> removeParticipantResultResponse = client.getCallConnectionAsync(callConnectionId)
    .removeParticipantWithResponse(removeParticipantOptions);

JavaScript

const removeThisUser = { phoneNumber: "+16044561234" };
const removeParticipantResult = await client.getCallConnection(callConnectionId).removeParticipant(removeThisUser);

Python

remove_this_user = PhoneNumberIdentifier("+16044561234")
call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)
result = call_connection_client.remove_participant(remove_this_user, opration_context="Your context", operationCallbackUrl="<url_endpoint>")

DTMF senden

Senden Sie eine Liste der DTMF-Töne an externe Teilnehmende.

csharp

var tones = new DtmfTone[] { DtmfTone.One, DtmfTone.Two, DtmfTone.Three, DtmfTone.Pound }; 
var sendDtmfTonesOptions = new SendDtmfTonesOptions(tones, new PhoneNumberIdentifier(calleePhonenumber))
{ 
	OperationContext = "dtmfs-to-ivr" 
}; 

var sendDtmfAsyncResult = await callAutomationClient.GetCallConnection(callConnectionId).GetCallMedia().SendDtmfTonesAsync(sendDtmfTonesOptions);

Java

List<DtmfTone> tones = Arrays.asList(DtmfTone.ONE, DtmfTone.TWO, DtmfTone.THREE, DtmfTone.POUND); 
SendDtmfTonesOptions options = new SendDtmfTonesOptions(tones, new PhoneNumberIdentifier(c2Target)); 
options.setOperationContext("dtmfs-to-ivr"); 
client.getCallConnectionAsync(callConnectionId)
	.getCallMediaAsync() 
	.sendDtmfTonesWithResponse(options) 
	.block(); 

JavaScript

const tones = [DtmfTone.One, DtmfTone.Two, DtmfTone.Three];
const sendDtmfTonesOptions: SendDtmfTonesOptions = {
	operationContext: "dtmfs-to-ivr"
};
const result: SendDtmfTonesResult = await client.getCallConnection(callConnectionId)
	.getCallMedia()
	.sendDtmfTones(tones, {
		phoneNumber: c2Target
	}, sendDtmfTonesOptions);
console.log("sendDtmfTones, result=%s", result);

Python

tones = [DtmfTone.ONE, DtmfTone.TWO, DtmfTone.THREE]
call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)

result = call_connection_client.send_dtmf_tones(
	tones = tones,
	target_participant = PhoneNumberIdentifier(c2_target),
	operation_context = "dtmfs-to-ivr")

Anrufaufzeichnung

Azure Communication Services-Räume unterstützen Aufzeichnungsfunktionen, einschließlich start, stop, pause, resume usw., die von der Anrufautomatisierung bereitgestellt werden. In den folgenden Codeausschnitten können Sie eine Aufzeichnung in einem Chatroom-Anruf starten/beenden/anhalten/fortsetzen. Eine vollständige Liste der Aktionen finden Sie unter Aufzeichnung der Anrufautomatisierung.

csharp

// Start recording
StartRecordingOptions recordingOptions = new StartRecordingOptions(new ServerCallLocator("<ServerCallId>"))
{
   RecordingContent = RecordingContent.Audio,
   RecordingChannel = RecordingChannel.Unmixed,
   RecordingFormat = RecordingFormat.Wav,
   RecordingStateCallbackUri = new Uri("<CallbackUri>"),
   RecordingStorage = RecordingStorage.CreateAzureBlobContainerRecordingStorage(new Uri("<YOUR_STORAGE_CONTAINER_URL>"))
};
Response<RecordingStateResult> response = await callAutomationClient.GetCallRecording()
.StartAsync(recordingOptions);

// Pause recording using recordingId received in response of start recording.
var pauseRecording = await callAutomationClient.GetCallRecording ().PauseAsync(recordingId);

// Resume recording using recordingId received in response of start recording.
var resumeRecording = await callAutomationClient.GetCallRecording().ResumeAsync(recordingId);

// Stop recording using recordingId received in response of start recording.
var stopRecording = await callAutomationClient.GetCallRecording().StopAsync(recordingId);

Java

// Start recording
StartRecordingOptions recordingOptions = new StartRecordingOptions(new ServerCallLocator("<serverCallId>"))
                    .setRecordingChannel(RecordingChannel.UNMIXED)
                    .setRecordingFormat(RecordingFormat.WAV)
                    .setRecordingContent(RecordingContent.AUDIO)
                    .setRecordingStateCallbackUrl("<recordingStateCallbackUrl>");

Response<RecordingStateResult> response = callAutomationClient.getCallRecording()
.startWithResponse(recordingOptions, null);

// Pause recording using recordingId received in response of start recording
Response<Void> response = callAutomationClient.getCallRecording()
              .pauseWithResponse(recordingId, null);

// Resume recording using recordingId received in response of start recording
Response<Void> response = callAutomationClient.getCallRecording()
               .resumeWithResponse(recordingId, null);

// Stop recording using recordingId received in response of start recording
Response<Void> response = callAutomationClient.getCallRecording()
               .stopWithResponse(recordingId, null);

JavaScript

// Start recording
var locator: CallLocator = { id: "<ServerCallId>", kind: "serverCallLocator" };

var options: StartRecordingOptions =
{
  callLocator: locator,
  recordingContent: "audio",
  recordingChannel:"unmixed",
  recordingFormat: "wav",
  recordingStateCallbackEndpointUrl: "<CallbackUri>"
};
var response = await callAutomationClient.getCallRecording().start(options);

// Pause recording using recordingId received in response of start recording
var pauseRecording = await callAutomationClient.getCallRecording().pause(recordingId);

// Resume recording using recordingId received in response of start recording.
var resumeRecording = await callAutomationClient.getCallRecording().resume(recordingId);

// Stop recording using recordingId received in response of start recording
var stopRecording = await callAutomationClient.getCallRecording().stop(recordingId);

Python

# Start recording
response = call_automation_client.start_recording(call_locator=ServerCallLocator(server_call_id),
            recording_content_type = RecordingContent.Audio,
            recording_channel_type = RecordingChannel.Unmixed,
            recording_format_type = RecordingFormat.Wav,
            recording_state_callback_url = "<CallbackUri>")

# Pause recording using recording_id received in response of start recording
pause_recording = call_automation_client.pause_recording(recording_id = recording_id)

# Resume recording using recording_id received in response of start recording
resume_recording = call_automation_client.resume_recording(recording_id = recording_id)

# Stop recording using recording_id received in response of start recording
stop_recording = call_automation_client.stop_recording(recording_id = recording_id)

Beenden eines Anrufs

Sie können die Anrufautomatisierungs-SDK Hang Up-Aktion verwenden, um einen Aufruf zu beenden. Nach Abschluss der Hang Up-Aktion veröffentlicht das SDK ein CallDisconnected Ereignis.

csharp

_ = await client.GetCallConnection(callConnectionId).HangUpAsync(forEveryone: true); 

Java

Response<Void> response = client.getCallConnectionAsync(callConnectionId).hangUpWithResponse(true).block();

JavaScript

await callConnection.hangUp(true);

Python

call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)

call_connection_client.hang_up(is_for_everyone=True)

Andere Aktionen

Die folgenden In-Call-Aktionen werden auch in einem Chatroom-Anruf unterstützt.

1. Hinzufügen eines Teilnehmers (ACS-ID)
2. Entfernen eines Teilnehmers (ACS-ID)
3. Abbrechen des Hinzufügens eines Teilnehmers (ACS-ID und PSTN-Nummer)
4. Anruf auflegen
5. Abrufen eines Teilnehmer (ACS-ID und PSTN-Nummer)
6. Abrufen mehrerer Teilnehmer (ACS-ID und PSTN-Nummer)
7. Abrufen der neuesten Informationen zu einem Anruf
8. Wiedergeben von Audiodateien und Text
9. Wiedergeben aller Audiodateien und Text
10. Erkennen von DTMF und Sprache
11. Fortlaufende DTMF-Erkennung

Weitere Informationen finden Sie unter Anrufaktionen und Medienaktionen.

Nächste Schritte

In diesem Abschnitt haben Sie Folgendes gelernt:

• Teilnehmen an einem Raumanruf aus Ihrer Anwendung
• Hinzufügen von In-Call-Aktionen zu einem Chatroom-Anruf mithilfe von Anruf-SDKs
• Hinzufügen von In-Call-Aktionen zu einem Chatroomanruf mithilfe von Anrufautomatisierungs-SDKs

Das könnte Sie auch interessieren:

• Informationen zum Räume-Konzepte
• Erfahren Sie mehr über Features von Anruf-SDKs
• Erfahren Sie mehr über Konzepte der Anrufautomatisierung