Jak kontrolować i kierować wywołaniami za pomocą usługi Call Automation
Artykuł
Usługa Call Automation używa interfejsu API REST do odbierania żądań dotyczących akcji i dostarczania odpowiedzi w celu powiadomienia o tym, czy żądanie zostało pomyślnie przesłane, czy nie. Ze względu na asynchroniczny charakter wywoływania większość akcji ma odpowiednie zdarzenia, które są wyzwalane po pomyślnym zakończeniu akcji lub niepomyślnie. W tym przewodniku opisano akcje dostępne dla wywołań kierowniczych, takich jak CreateCall, Transfer, Redirect i zarządzanie uczestnikami. Akcje są dołączone do przykładowego kodu na temat wywoływania tej akcji i diagramów sekwencji opisujących zdarzenia oczekiwane po wywołaniu akcji. Te diagramy ułatwiają wizualizowanie sposobu programowania aplikacji usługi za pomocą usługi Call Automation.
Usługa Call Automation obsługuje różne inne akcje do zarządzania nośnikami połączeń i nagrywania, które mają oddzielne przewodniki.
W ramach wymagań wstępnych zalecamy przeczytanie tych artykułów, aby jak najlepiej wykorzystać ten przewodnik:
Dowiedz się więcej o identyfikatorach użytkowników, takich jak CommunicationUserIdentifier i PhoneNumberIdentifier używanych w tym przewodniku.
W przypadku wszystkich przykładów kodu obiekt CallAutomationClient, client który można utworzyć, jak pokazano, i callConnection jest obiektem CallConnection uzyskanym z odpowiedzi Answer lub CreateCall. Można go również uzyskać z zdarzeń wywołania zwrotnego odebranych przez aplikację.
Możesz umieścić połączenie 1:1 lub grupę do użytkownika komunikacji lub numeru telefonu (publiczny lub komunikacyjny numer własności).
Podczas wywoływania punktu końcowego PSTN należy również podać numer telefonu, który jest używany jako identyfikator obiektu wywołującego źródła i wyświetlany w powiadomieniu o wywołaniu do docelowego punktu końcowego PSTN.
Aby umieścić wywołanie użytkownika usług Communication Services, należy podać obiekt CommunicationUserIdentifier zamiast PhoneNumberIdentifier.
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)
Podczas nawiązywania połączenia grupowego zawierającego numer telefonu należy podać numer telefonu używany jako numer identyfikacyjny rozmówcy do punktu końcowego PSTN.
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,
)
Odpowiedź zawiera obiekt CallConnection, którego można użyć do podjęcia dalszych akcji dla tego wywołania po nawiązaniu połączenia. Po udzieleniu odpowiedzi na połączenie dwa zdarzenia są publikowane w podanym wcześniej punkcie końcowym wywołania zwrotnego:
CallConnected zdarzenie z powiadomieniem, że wywołanie zostało nawiązane z wywołaniem wywoływanym.
ParticipantsUpdated zdarzenie zawierające najnowszą listę uczestników połączenia.
W przypadku niepowodzenia wywołania zostanie wyświetlone CallDisconnected zdarzenie i CreateCallFailed z kodami błędów w celu dalszego rozwiązywania problemów (zobacz tę stronę , aby uzyskać więcej informacji na temat kodów błędów).
Nawiązywanie połączenia z połączeniem
Akcja połącz umożliwia usłudze nawiązanie połączenia z trwającym wywołaniem i podjęcie na nim akcji. Jest to przydatne w przypadku zarządzania wywołaniem usługi Rooms lub uruchamianiem wywołania przez aplikacje klienckie 1:1 lub grupy, które nie są częścią automatyzacji wywołań. Połączenie jest ustanawiane przy użyciu właściwości CallLocator i może być typami: ServerCallLocator, GroupCallLocator i RoomCallLocator. Te identyfikatory można znaleźć po utworzeniu wywołania lub utworzeniu pokoju, a także opublikowanym w ramach zdarzenia CallStarted .
Aby nawiązać połączenie z dowolnym wywołaniem 1:1 lub grupą, użyj obiektu ServerCallLocator. Jeśli uruchomiono połączenie przy użyciu elementu GroupCallId, możesz również użyć klasy GroupCallLocator.
Uri callbackUri = new Uri("https://<myendpoint>/Events"); //the callback endpoint where you want to receive subsequent events
CallLocator serverCallLocator = new ServerCallLocator("<ServerCallId>");
ConnectCallResult response = await client.ConnectCallAsync(serverCallLocator, callbackUri);
String callbackUri = "https://<myendpoint>/Events"; //the callback endpoint where you want to receive subsequent events
CallLocator serverCallLocator = new ServerCallLocator("<ServerCallId>");
ConnectCallResult response = client.connectCall(serverCallLocator, callbackUri).block();
const callbackUri = "https://<myendpoint>/Events"; // the callback endpoint where you want to receive subsequent events
const serverCallLocator = { kind: "serverCallLocator", id: "<serverCallId>" };
const response = await client.connectCall(serverCallLocator, callbackUri);
callback_uri = "https://<myendpoint>/Events" # the callback endpoint where you want to receive subsequent events
server_call_locator = ServerCallLocator("<server_call_id>")
call_connection_properties = client.connect_call(call_locator=server_call_locator, callback_url=callback_uri)
Aby nawiązać połączenie z usługą Rooms, użyj funkcji RoomCallLocator, która przyjmuje parametr RoomId. Dowiedz się więcej o pokojach i sposobie używania interfejsu API usługi Call Automation do zarządzania trwającymi połączeniami w pokojach.
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.ConnectCallAsync(roomCallLocator, callbackUri);
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();
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);
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)
Pomyślna odpowiedź zawiera obiekt CallConnection, którego można użyć do wykonania dalszych akcji dla tego wywołania. Dwa zdarzenia są publikowane w podanym wcześniej punkcie końcowym wywołania zwrotnego:
CallConnected zdarzenie z powiadomieniem o pomyślnym nawiązaniu połączenia.
ParticipantsUpdated zdarzenie zawierające najnowszą listę uczestników połączenia.
W dowolnym momencie po pomyślnym nawiązaniu połączenia, jeśli usługa zostanie odłączona od tego wywołania, otrzymasz powiadomienie za pośrednictwem zdarzenia CallDisconected. Nie można nawiązać połączenia z wywołaniem w pierwszej kolejności powoduje wystąpienie zdarzenia ConnectFailed.
Odpowiedz na połączenie przychodzące
Po zasubskrybowaniu odbierania powiadomień połączeń przychodzących do zasobu otrzymasz połączenie przychodzące. Podczas odpowiadania na połączenie należy podać adres URL wywołania zwrotnego. Usługi komunikacyjne publikują wszystkie kolejne zdarzenia dotyczące tego wywołania do tego adresu 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
)
Odpowiedź zawiera obiekt CallConnection, którego można użyć do podjęcia dalszych akcji dla tego wywołania po nawiązaniu połączenia. Po udzieleniu odpowiedzi na połączenie dwa zdarzenia są publikowane w podanym wcześniej punkcie końcowym wywołania zwrotnego:
CallConnected zdarzenie z powiadomieniem, że połączenie zostało nawiązane z obiektem wywołującym.
ParticipantsUpdated zdarzenie zawierające najnowszą listę uczestników połączenia.
W przypadku niepowodzenia operacji odpowiedzi otrzymasz AnswerFailed zdarzenie z kodami błędów w celu dalszego rozwiązywania problemów (zobacz tę stronę , aby uzyskać więcej informacji na temat kodów błędów).
Odrzucanie połączenia
Możesz odrzucić połączenie przychodzące, jak pokazano poniżej. Możesz podać przyczynę odrzucenia: brak, zajęty lub zabroniony. Jeśli nic nie zostanie podane, żadna z nich nie zostanie wybrana domyślnie.
Żadne zdarzenia nie są publikowane dla akcji odrzucania.
Przekierowywanie połączenia
Możesz przekierować połączenie przychodzące do innego punktu końcowego bez odpowiadania na nie. Przekierowanie wywołania eliminuje możliwość kontrolowania wywołania za pomocą usługi Call Automation.
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,
)
Żadne zdarzenia nie są publikowane dla przekierowania. Jeśli elementem docelowym jest użytkownik usługi Communication Services lub numer telefonu należący do zasobu, generuje nowe zdarzenie IncomingCall z polem "to" ustawionym na określony element docelowy.
Przeniesienie uczestnika w rozmowie
Gdy aplikacja odpowiada na wywołanie lub umieszcza wywołanie wychodzące do punktu końcowego, ten punkt końcowy może zostać przeniesiony do innego docelowego punktu końcowego. Przeniesienie wywołania 1:1 spowoduje usunięcie aplikacji z wywołania, a tym samym usunięcie jej możliwości kontrolowania wywołania przy użyciu usługi Call Automation. Zaproszenie wywołania do obiektu docelowego spowoduje wyświetlenie identyfikatora obiektu wywołującego przesyłanego punktu końcowego. Podanie niestandardowego identyfikatora wywołującego nie jest obsługiwane.
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();
Gdy aplikacja odpowiada na wywołanie grupy lub umieszcza wywołanie grupy wychodzącej do punktu końcowego lub dodała uczestnika do wywołania 1:1, punkt końcowy może zostać przeniesiony z wywołania do innego punktu końcowego docelowego, z wyjątkiem punktu końcowego automatyzacji wywołania. Przeniesienie uczestnika w wywołaniu grupy spowoduje usunięcie punktu końcowego przesyłanego z wywołania. Zaproszenie wywołania do obiektu docelowego spowoduje wyświetlenie identyfikatora obiektu wywołującego przesyłanego punktu końcowego. Podanie niestandardowego identyfikatora wywołującego nie jest obsługiwane.
// 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>"
)
Diagram sekwencji przedstawia oczekiwany przepływ, gdy aplikacja umieszcza wywołanie wychodzące, a następnie przesyła je do innego punktu końcowego.
Dodawanie uczestnika do połączenia
Możesz dodać uczestnika (użytkownika lub numer telefonu usług komunikacyjnych) do istniejącego połączenia. Podczas dodawania numeru telefonu należy podać identyfikator rozmówców. Ten identyfikator osoby wywołującej jest wyświetlany w powiadomieniu o wywołaniu do dodawanego uczestnika.
// 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
)
Aby dodać użytkownika usług Communication Services, podaj parametr CommunicationUserIdentifier zamiast PhoneNumberIdentifier. W tym przypadku identyfikator obiektu wywołującego nie jest obowiązkowy.
Aplikacja AddParticipant publikuje AddParticipantSucceeded zdarzenie lub AddParticipantFailed wraz z udostępnieniem ParticipantUpdated najnowszej listy uczestników połączenia.
// 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();
Element RemoveParticipant opublikuje RemoveParticipantSucceeded wydarzenie lub RemoveParticipantFailed wraz ze zdarzeniem ParticipantUpdated zawierającym najnowszą listę uczestników połączenia. Usunięty uczestnik zostanie pominięty z listy.
Zawieszanie się na wywołaniu
Akcja zawieszania się może służyć do usunięcia aplikacji z wywołania lub zakończenia wywołania grupy przez ustawienie parametruEveryone na true. W przypadku wywołania 1:1 zawiesza się przerwanie połączenia z innym uczestnikiem domyślnie.