Steuern und Weiterleiten von Anrufen mit der Anrufautomatisierung
Artikel
Die Anrufautomatisierung verwendet eine REST-API-Schnittstelle, um Anforderungen für Aktionen zu empfangen und Antworten bereitzustellen, um darüber zu informieren, ob die Anforderung erfolgreich übermittelt wurde. Da Anrufe asynchron erfolgen, verfügen die meisten Aktionen über entsprechende Ereignisse, die ausgelöst werden, wenn die Aktion erfolgreich oder mit Fehlern abgeschlossen wird. In diesem Leitfaden werden die verfügbaren Aktionen für die Steuerung von Anrufen behandelt, z. B. das Erstellen von Anrufen, die Übertragung, Umleitung und Verwaltung von Teilnehmenden. Die Aktionen werden mit Beispielcode zum Aufrufen der besagten Aktion und Sequenzdiagramme ergänzt, mit denen die nach dem Aufrufen einer Aktion erwarteten Ereignisse beschrieben werden. Mithilfe dieser Diagramme können Sie visualisieren, wie Sie Ihre Dienstanwendung mit der Anrufautomatisierung programmieren.
Die Anrufautomatisierung unterstützt verschiedene andere Aktionen zum Verwalten von Anrufmedien und Aufzeichnungen mit separaten Leitfäden.
Als Voraussetzung empfehlen wir Ihnen, diese Artikel zu lesen, um dieses Handbuch optimal zu nutzen:
Im Leitfaden mit Konzepten der Anrufautomatisierung werden das Programmiermodell für Aktionen und Ereignisse sowie Ereignisrückrufe beschrieben.
Erfahren Sie mehr über Benutzerbezeichner wie CommunicationUserIdentifier und PhoneNumberIdentifier, die in diesem Leitfaden verwendet werden.
Für alle Codebeispiele ist client das CallAutomationClient-Objekt, das wie gezeigt erstellt werden kann, und callConnection ist das CallConnection-Objekt, das aus der Antwort oder der CreateCall-Antwort abgerufen wird. Sie können es auch aus Rückrufereignissen abrufen, die von Ihrer Anwendung empfangen wurden.
Sie können einen 1:1- oder Gruppenanruf mit Kommunikationsbenutzer*innen oder Telefonnummern (öffentliche oder Communication Services-Nummer) tätigen.
Beim Anrufen eines PSTN-Endpunkts müssen Sie auch eine Telefonnummer angeben, die als Quellanrufer-ID verwendet und in der Anrufbenachrichtigung an den Ziel-PSTN-Endpunkt angezeigt wird.
Um einen Aufruf eines Kommunikationsdienste-Benutzers zu tätigen, müssen Sie anstelle von Telefon NumberIdentifier ein CommunicationUserIdentifier-Objekt bereitstellen.
Uri callbackUri = new Uri("https://<myendpoint>/Events"); //the callback endpoint where you want to receive subsequent events
var callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the Azure Communication Services provisioned phone number for the caller
var callThisPerson = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber); // person to call
CreateCallResult response = await client.CreateCallAsync(callThisPerson, callbackUri);
String callbackUri = "https://<myendpoint>/Events"; //the callback endpoint where you want to receive subsequent events
PhoneNumberIdentifier callerIdNumber = new PhoneNumberIdentifier("+18001234567"); // This is the Azure Communication Services provisioned phone number for the caller
CallInvite callInvite = new CallInvite(new PhoneNumberIdentifier("+16471234567"), callerIdNumber); // person to call
CreateCallResult response = client.createCall(callInvite, callbackUri).block();
const callInvite = {
targetParticipant: { phoneNumber: "+18008008800" }, // person to call
sourceCallIdNumber: { phoneNumber: "+18888888888" } // This is the Azure Communication Services provisioned phone number for the caller
};
const callbackUri = "https://<myendpoint>/Events"; // the callback endpoint where you want to receive subsequent events
const response = await client.createCall(callInvite, callbackUri);
callback_uri = "https://<myendpoint>/Events" # the callback endpoint where you want to receive subsequent events
caller_id_number = PhoneNumberIdentifier(
"+18001234567"
) # This is the Azure Communication Services provisioned phone number for the caller
call_invite = CallInvite(
target=PhoneNumberIdentifier("+16471234567"),
source_caller_id_number=caller_id_number,
)
call_connection_properties = client.create_call(call_invite, callback_uri)
Wenn Sie einen Gruppenanruf tätigen, der eine Telefonnummer enthält, müssen Sie eine Telefonnummer angeben, die als Anrufer-ID-Nummer für den PSTN-Endpunkt verwendet wird.
Uri callbackUri = new Uri("https://<myendpoint>/Events"); //the callback endpoint where you want to receive subsequent events
var pstnEndpoint = new PhoneNumberIdentifier("+16041234567");
var voipEndpoint = new CommunicationUserIdentifier("<user_id_of_target>"); //user id looks like 8:a1b1c1-...
var groupCallOptions = new CreateGroupCallOptions(new List<CommunicationIdentifier>{ pstnEndpoint, voipEndpoint }, callbackUri)
{
SourceCallerIdNumber = new PhoneNumberIdentifier("+16044561234"), // This is the Azure Communication Services provisioned phone number for the caller
};
CreateCallResult response = await client.CreateGroupCallAsync(groupCallOptions);
String callbackUri = "https://<myendpoint>/Events"; //the callback endpoint where you want to receive subsequent events
PhoneNumberIdentifier callerIdNumber = new PhoneNumberIdentifier("+18001234567"); // This is the Azure Communication Services provisioned phone number for the caller
List<CommunicationIdentifier> targets = new ArrayList<>(Arrays.asList(new PhoneNumberIdentifier("+16471234567"), new CommunicationUserIdentifier("<user_id_of_target>")));
CreateGroupCallOptions groupCallOptions = new CreateGroupCallOptions(targets, callbackUri);
groupCallOptions.setSourceCallIdNumber(callerIdNumber);
Response<CreateCallResult> response = client.createGroupCallWithResponse(createGroupCallOptions).block();
const callbackUri = "https://<myendpoint>/Events"; // the callback endpoint where you want to receive subsequent events
const participants = [
{ phoneNumber: "+18008008800" },
{ communicationUserId: "<user_id_of_target>" }, //user id looks like 8:a1b1c1-...
];
const createCallOptions = {
sourceCallIdNumber: { phoneNumber: "+18888888888" }, // This is the Azure Communication Services provisioned phone number for the caller
};
const response = await client.createGroupCall(participants, callbackUri, createCallOptions);
callback_uri = "https://<myendpoint>/Events" # the callback endpoint where you want to receive subsequent events
caller_id_number = PhoneNumberIdentifier(
"+18888888888"
) # This is the Azure Communication Services provisioned phone number for the caller
pstn_endpoint = PhoneNumberIdentifier("+18008008800")
voip_endpoint = CommunicationUserIdentifier(
"<user_id_of_target>"
) # user id looks like 8:a1b1c1-...
call_connection_properties = client.create_group_call(
target_participants=[voip_endpoint, pstn_endpoint],
callback_url=callback_uri,
source_caller_id_number=caller_id_number,
)
Die Antwort enthält das CallConnection-Objekt, das Sie verwenden können, um weitere Aktionen für diesen Aufruf auszuführen, sobald eine Verbindung besteht. Sobald der Anruf beantwortet wurde, werden zwei Ereignisse an dem rückrufendpunkt veröffentlicht, den Sie zuvor bereitgestellt haben:
Das CallConnected-Ereignis ist die Benachrichtigung, dass der Anruf mit der oder dem Angerufenen eingerichtet wurde.
Das ParticipantsUpdated-Ereignis enthält die aktuelle Liste der Teilnehmenden am Anruf.
Annehmen eines eingehenden Anrufs
Nachdem Sie Abonniert haben, um eingehende Anrufbenachrichtigungen an Ihre Ressource zu erhalten, beantworten Sie einen eingehenden Anruf. Wenn Sie einen Anruf annehmen, müssen Sie eine Rückruf-URL angeben. Kommunikationsdienste posten alle nachfolgenden Ereignisse zu diesem Aufruf dieser URL.
incoming_call_context = "<IncomingCallContext_From_IncomingCall_Event>"
callback_uri = "https://<myendpoint>/Events" # the callback endpoint where you want to receive subsequent events
call_connection_properties = client.answer_call(
incoming_call_context=incoming_call_context, callback_url=callback_uri
)
Die Antwort enthält das CallConnection-Objekt, das Sie verwenden können, um weitere Aktionen für diesen Aufruf auszuführen, sobald eine Verbindung besteht. Sobald der Anruf beantwortet wurde, werden zwei Ereignisse an dem rückrufendpunkt veröffentlicht, den Sie zuvor bereitgestellt haben:
Das CallConnected-Ereignis ist die Benachrichtigung, dass der Anruf mit der oder dem Anrufer*in eingerichtet wurde.
Das ParticipantsUpdated-Ereignis enthält die aktuelle Liste der Teilnehmenden am Anruf.
Ablehnen eines Anrufs
Sie können einen eingehenden Anruf wie unten gezeigt ablehnen. Sie können einen Ablehnungsgrund angeben: keiner, besetzt oder gesperrt. Wenn keine Angabe erfolgt, wird standardmäßig „keiner“ ausgewählt.
Für Ablehnungsaktionen werden keine Ereignisse veröffentlicht.
Umleiten eines Anrufs
Sie können einen eingehenden Anruf an einen anderen Endpunkt umleiten, ohne ihn zu beantworten. Durch das Umleiten eines Anrufs wird die Möglichkeit Ihrer Anwendung entfernt, den Anruf mithilfe der Anrufautomatisierung zu steuern.
string incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>";
var target = new CallInvite(new CommunicationUserIdentifier("<user_id_of_target>")); //user id looks like 8:a1b1c1-...
_ = await client.RedirectCallAsync(incomingCallContext, target);
String incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>";
CallInvite target = new CallInvite(new CommunicationUserIdentifier("<user_id_of_target>")); //user id looks like 8:a1b1c1-...
RedirectCallOptions redirectCallOptions = new RedirectCallOptions(incomingCallContext, target);
Response<Void> response = client.redirectCallWithResponse(redirectCallOptions).block();
var callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the Azure Communication Services provisioned phone number for the caller
var target = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber);
PhoneNumberIdentifier callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the Azure Communication Services provisioned phone number for the caller
CallInvite target = new CallInvite(new PhoneNumberIdentifier("+18001234567"), callerIdNumber);
caller_id_number = PhoneNumberIdentifier(
"+18888888888"
) # This is the Azure Communication Services provisioned phone number for the caller
call_invite = CallInvite(
target=PhoneNumberIdentifier("+16471234567"),
source_caller_id_number=caller_id_number,
)
Für Umleitungsaktionen werden keine Ereignisse veröffentlicht. Wenn es sich bei dem Ziel um einen Benutzer der Kommunikationsdienste oder eine Telefonnummer handelt, die sich im Besitz Ihrer Ressource befindet, wird ein neues IncomingCall-Ereignis generiert, wobei das Feld "to" auf das von Ihnen angegebene Ziel festgelegt ist.
Übertragen eines Teilnehmers im Anruf
Wenn Ihre Anwendung einen Anruf annimmt oder einen ausgehenden Anruf an einen Endpunkt tätigt, kann dieser Endpunkt an einen anderen Zielendpunkt durchgestellt werden. Durch das Übertragen eines 1:1-Anrufs wird Ihre Anwendung aus dem Anruf entfernt und somit die Möglichkeit entfernt, den Anruf mithilfe der Anrufautomatisierung zu steuern. Die Anrufeinladung an das Ziel zeigt die Anrufer-ID des Endpunkts an, der übertragen wird. Das Bereitstellen einer benutzerdefinierten Anrufer-ID wird nicht unterstützt.
var transferDestination = new CommunicationUserIdentifier("<user_id>");
var transferOption = new TransferToParticipantOptions(transferDestination) {
OperationContext = "<Your_context>",
OperationCallbackUri = new Uri("<uri_endpoint>") // Sending event to a non-default endpoint.
};
// adding customCallingContext
transferOption.CustomCallingContext.AddVoip("customVoipHeader1", "customVoipHeaderValue1");
transferOption.CustomCallingContext.AddVoip("customVoipHeader2", "customVoipHeaderValue2");
TransferCallToParticipantResult result = await callConnection.TransferCallToParticipantAsync(transferOption);
CommunicationIdentifier transferDestination = new CommunicationUserIdentifier("<user_id>");
TransferCallToParticipantOptions options = new TransferCallToParticipantOptions(transferDestination)
.setOperationContext("<operation_context>")
.setOperationCallbackUrl("<url_endpoint>"); // Sending event to a non-default endpoint.
// set customCallingContext
options.getCustomCallingContext().addVoip("voipHeaderName", "voipHeaderValue");
Response<TransferCallResult> transferResponse = callConnectionAsync.transferToParticipantCallWithResponse(options).block();
Wenn Ihre Anwendung einen Gruppenanruf beantwortet oder einen ausgehenden Gruppenanruf an einen Endpunkt sendet oder einen Teilnehmer zu einem 1:1-Anruf hinzugefügt hat, kann ein Endpunkt vom Anruf an einen anderen Zielendpunkt übertragen werden, mit Ausnahme des Endpunkts der Anrufautomatisierung. Durch das Übertragen eines Teilnehmers in einem Gruppenanruf wird der Endpunkt, der vom Anruf übertragen wird, entfernt. Die Anrufeinladung an das Ziel zeigt die Anrufer-ID des Endpunkts an, der übertragen wird. Das Bereitstellen einer benutzerdefinierten Anrufer-ID wird nicht unterstützt.
// Transfer User
var transferDestination = new CommunicationUserIdentifier("<user_id>");
var transferee = new CommunicationUserIdentifier("<transferee_user_id>");
var transferOption = new TransferToParticipantOptions(transferDestination);
transferOption.Transferee = transferee;
// adding customCallingContext
transferOption.CustomCallingContext.AddVoip("customVoipHeader1", "customVoipHeaderValue1");
transferOption.CustomCallingContext.AddVoip("customVoipHeader2", "customVoipHeaderValue2");
transferOption.OperationContext = "<Your_context>";
transferOption.OperationCallbackUri = new Uri("<uri_endpoint>");
TransferCallToParticipantResult result = await callConnection.TransferCallToParticipantAsync(transferOption);
// Transfer PSTN User
var transferDestination = new PhoneNumberIdentifier("<target_phoneNumber>");
var transferee = new PhoneNumberIdentifier("<transferee_phoneNumber>");
var transferOption = new TransferToParticipantOptions(transferDestination);
transferOption.Transferee = transferee;
// adding customCallingContext
transferOption.CustomCallingContext.AddSipUui("uuivalue");
transferOption.CustomCallingContext.AddSipX("header1", "headerValue");
transferOption.OperationContext = "<Your_context>";
// Sending event to a non-default endpoint.
transferOption.OperationCallbackUri = new Uri("<uri_endpoint>");
TransferCallToParticipantResult result = await callConnection.TransferCallToParticipantAsync(transferOption);
// Transfer User
CommunicationIdentifier transferDestination = new CommunicationUserIdentifier("<user_id>");
CommunicationIdentifier transferee = new CommunicationUserIdentifier("<transferee_user_id>");
TransferCallToParticipantOptions options = new TransferCallToParticipantOptions(transferDestination);
options.setTransferee(transferee);
options.setOperationContext("<Your_context>");
options.setOperationCallbackUrl("<url_endpoint>");
// set customCallingContext
options.getCustomCallingContext().addVoip("voipHeaderName", "voipHeaderValue");
Response<TransferCallResult> transferResponse = callConnectionAsync.transferToParticipantCallWithResponse(options).block();
// Transfer Pstn User
CommunicationIdentifier transferDestination = new PhoneNumberIdentifier("<taget_phoneNumber>");
CommunicationIdentifier transferee = new PhoneNumberIdentifier("<transferee_phoneNumber>");
TransferCallToParticipantOptions options = new TransferCallToParticipantOptions(transferDestination);
options.setTransferee(transferee);
options.setOperationContext("<Your_context>");
options.setOperationCallbackUrl("<url_endpoint>");
// set customCallingContext
options.getCustomCallingContext().addSipUui("UUIvalue");
options.getCustomCallingContext().addSipX("sipHeaderName", "value");
Response<TransferCallResult> transferResponse = callConnectionAsync.transferToParticipantCallWithResponse(options).block();
# Transfer to user
transfer_destination = CommunicationUserIdentifier("<user_id>")
transferee = CommnunicationUserIdentifer("transferee_user_id")
call_connection_client = call_automation_client.get_call_connection("<call_connection_id_from_ongoing_call>")
# create custom context
voip_headers = {"customVoipHeader1", "customVoipHeaderValue1"}
result = call_connection_client.transfer_call_to_participant(
target_participant=transfer_destination,
transferee=transferee,
voip_headers=voip_headers,
opration_context="Your context",
operationCallbackUrl="<url_endpoint>"
)
# Transfer to PSTN user
transfer_destination = PhoneNumberIdentifer("<target_phoneNumber>")
transferee = PhoneNumberIdentifer("transferee_phoneNumber")
# create custom context
sip_headers={}
sip_headers.add("X-MS-Custom-headerName", "headerValue")
sip_headers.add("User-To-User","uuivale")
call_connection_client = call_automation_client.get_call_connection("<call_connection_id_from_ongoing_call>")
result = call_connection_client.transfer_call_to_participant(
target_participant=transfer_destination,
transferee=transferee,
sip_headers=sip_headers,
opration_context="Your context",
operationCallbackUrl="<url_endpoint>"
)
Das Sequenzdiagramm zeigt den erwarteten Fluss, wenn Ihre Anwendung einen ausgehenden Anruf platziert und dann an einen anderen Endpunkt überträgt.
Hinzufügen eines Teilnehmers zu einem Anruf
Sie können einem vorhandenen Anruf einen Teilnehmer (Benutzer oder Telefonnummer der Kommunikationsdienste) hinzufügen. Beim Hinzufügen einer Telefonnummer muss eine Anrufer-ID angegeben werden. Diese Anrufer-ID wird in der Anrufbenachrichtigung angezeigt, der dem Teilnehmer hinzugefügt wird.
// Add user
var addThisPerson = new CallInvite(new CommunicationUserIdentifier("<user_id>"));
// add custom calling context
addThisPerson.CustomCallingContext.AddVoip("myHeader", "myValue");
AddParticipantsResult result = await callConnection.AddParticipantAsync(addThisPerson);
// Add PSTN user
var callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the Azure Communication Services provisioned phone number for the caller
var addThisPerson = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber);
// add custom calling context
addThisPerson.CustomCallingContext.AddSipUui("value");
addThisPerson.CustomCallingContext.AddSipX("header1", "customSipHeaderValue1");
// Use option bag to set optional parameters
var addParticipantOptions = new AddParticipantOptions(new CallInvite(addThisPerson))
{
InvitationTimeoutInSeconds = 60,
OperationContext = "operationContext",
OperationCallbackUri = new Uri("uri_endpoint"); // Sending event to a non-default endpoint.
};
AddParticipantsResult result = await callConnection.AddParticipantAsync(addParticipantOptions);
// Add user
CallInvite callInvite = new CallInvite(new CommunicationUserIdentifier("<user_id>"));
// add custom calling context
callInvite.getCustomCallingContext().addVoip("voipHeaderName", "voipHeaderValue");
AddParticipantOptions addParticipantOptions = new AddParticipantOptions(callInvite)
.setOperationContext("<operation_context>")
.setOperationCallbackUrl("<url_endpoint>");
Response<AddParticipantResult> addParticipantResultResponse = callConnectionAsync.addParticipantWithResponse(addParticipantOptions).block();
// Add PSTN user
PhoneNumberIdentifier callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the Azure Communication Services provisioned phone number for the caller
CallInvite callInvite = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber);
// add custom calling context
callInvite.getCustomCallingContext().addSipUui("value");
callInvite.getCustomCallingContext().addSipX("header1", "customSipHeaderValue1");
AddParticipantOptions addParticipantOptions = new AddParticipantOptions(callInvite)
.setOperationContext("<operation_context>")
.setOperationCallbackUrl("<url_endpoint>");
Response<AddParticipantResult> addParticipantResultResponse = callConnectionAsync.addParticipantWithResponse(addParticipantOptions).block();
# Add user
voip_headers = {"voipHeaderName", "voipHeaderValue"}
target = CommunicationUserIdentifier("<acs_user_id>")
call_connection_client = call_automation_client.get_call_connection(
"<call_connection_id_from_ongoing_call>"
)
result = call_connection_client.add_participant(
target,
voip_headers=voip_headers,
opration_context="Your context",
operationCallbackUrl="<url_endpoint>"
)
# Add PSTN user
caller_id_number = PhoneNumberIdentifier(
"+18888888888"
) # This is the Azure Communication Services provisioned phone number for the caller
sip_headers = {}
sip_headers["User-To-User"] = "value"
sip_headers["X-MS-Custom-headerName"] = "headerValue"
target = PhoneNumberIdentifier("+18008008800"),
call_connection_client = call_automation_client.get_call_connection(
"<call_connection_id_from_ongoing_call>"
)
result = call_connection_client.add_participant(
target,
sip_headers=sip_headers,
opration_context="Your context",
operationCallbackUrl="<url_endpoint>",
source_caller_id_number=caller_id_number
)
Um Communication Services-Benutzer*innen hinzuzufügen, geben Sie anstelle von PhoneNumberIdentifier die CommunicationUserIdentifier an. Die Anrufer-ID ist in diesem Fall nicht obligatorisch.
AddParticipant veröffentlicht eine oder AddParticipantFailed ein AddParticipantSucceeded Ereignis zusammen mit einer ParticipantUpdated bereitstellenden Liste der Teilnehmer im Anruf.
// add a participant
var addThisPerson = new CallInvite(new CommunicationUserIdentifier("<user_id>"));
var addParticipantResponse = await callConnection.AddParticipantAsync(addThisPerson);
// cancel the request with optional parameters
var cancelAddParticipantOperationOptions = new CancelAddParticipantOperationOptions(addParticipantResponse.Value.InvitationId)
{
OperationContext = "operationContext",
OperationCallbackUri = new Uri("uri_endpoint"); // Sending event to a non-default endpoint.
}
await callConnection.CancelAddParticipantOperationAsync(cancelAddParticipantOperationOptions);
// Add user
CallInvite callInvite = new CallInvite(new CommunicationUserIdentifier("<user_id>"));
AddParticipantOperationOptions addParticipantOperationOptions = new AddParticipantOptions(callInvite);
Response<AddParticipantResult> addParticipantOperationResultResponse = callConnectionAsync.addParticipantWithResponse(addParticipantOptions).block();
// cancel the request
CancelAddParticipantOperationOptions cancelAddParticipantOperationOptions = new CancelAddParticipantOperationOptions(addParticipantResultResponse.invitationId)
.setOperationContext("<operation_context>")
.setOperationCallbackUrl("<url_endpoint>");
callConnectionAsync.cancelAddParticipantOperationWithResponse(cancelAddParticipantOperationOptions).block();
var removeThisUser = new CommunicationUserIdentifier("<user_id>");
// 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 callConnection.RemoveParticipantAsync(removeParticipantOptions);
CommunicationIdentifier removeThisUser = new CommunicationUserIdentifier("<user_id>");
RemoveParticipantOptions removeParticipantOptions = new RemoveParticipantOptions(removeThisUser)
.setOperationContext("<operation_context>")
.setOperationCallbackUrl("<url_endpoint>");
Response<RemoveParticipantResult> removeParticipantResultResponse = callConnectionAsync.removeParticipantWithResponse(removeParticipantOptions).block();
RemoveParticipant veröffentlicht ein RemoveParticipantSucceeded Ereignis oder RemoveParticipantFailed ein Ereignis zusammen mit einem ParticipantUpdated Ereignis, das die neueste Liste der Teilnehmer im Anruf bereitstellt. Der entfernte Teilnehmer wird aus der Liste weggelassen.
Auflegen eines Anrufs
Die hangUp-Aktion (Auflegen) kann verwendet werden, um Ihre Anwendung aus dem Aufruf zu entfernen oder einen Gruppenaufruf zu beenden, indem Sie den forEveryone-Parameter auf TRUE festlegen. Bei einem 1:1-Anruf wird der Anruf standardmäßig mit dem anderen Teilnehmer beendet.