Gesprekken beheren en sturen met Gespreksautomatisering

Aanroepautomatisering maakt gebruik van een REST API-interface voor het ontvangen van aanvragen voor acties en het verstrekken van antwoorden om te melden of de aanvraag is verzonden of niet. Vanwege de asynchrone aard van het aanroepen hebben de meeste acties overeenkomende gebeurtenissen die worden geactiveerd wanneer de actie is voltooid of mislukt. In deze handleiding worden de acties beschreven die beschikbaar zijn voor het sturen van oproepen, zoals CreateCall, Transfer, Redirect en het beheren van deelnemers. Acties worden vergezeld van voorbeeldcode over het aanroepen van de genoemde actie en sequentiediagrammen die de verwachte gebeurtenissen beschrijven nadat een actie is aangeroepen. Met deze diagrammen kunt u visualiseren hoe u uw servicetoepassing kunt programmeren met Gespreksautomatisering.

Call Automation ondersteunt verschillende andere acties voor het beheren van oproepmedia en -opname met afzonderlijke handleidingen.

Als vereiste raden we u aan deze artikelen te lezen om optimaal gebruik te maken van deze handleiding:

1. Handleiding voor aanroepautomatiseringsconcepten waarin het programmeermodel voor actiegebeurtenissen en callbacks voor gebeurtenissen wordt beschreven.
2. Meer informatie over gebruikers-id's zoals CommunicationUserIdentifier en PhoneNumberIdentifier die in deze handleiding worden gebruikt.

Voor alle codevoorbeelden client is CallAutomationClient-object dat kan worden gemaakt zoals weergegeven en callConnection het CallConnection-object is verkregen uit Answer of CreateCall-antwoord. U kunt deze ook verkrijgen via callbackgebeurtenissen die door uw toepassing zijn ontvangen.

csharp

var client = new CallAutomationClient("<resource_connection_string>"); 

Java

 CallAutomationClient client = new CallAutomationClientBuilder().connectionString("<resource_connection_string>").buildClient();

JavaScript

const client = new CallAutomationClient("<resource_connection_string>");

Python

call_automation_client = CallAutomationClient.from_connection_string("<resource_connection_string>")

Een uitgaande oproep maken

U kunt een oproep van 1:1 of een groepsgesprek plaatsen naar een communicatiegebruiker of telefoonnummer (openbaar nummer of het nummer van Communication Services dat eigendom is van Communication Services). Wanneer u een PSTN-eindpunt aanroept, moet u ook een telefoonnummer opgeven dat wordt gebruikt als de bronaanroeper-id en wordt weergegeven in de oproepmelding naar het PSTN-doeleindpunt. Als u een aanroep naar een Communication Services-gebruiker wilt plaatsen, moet u een CommunicationUserIdentifier-object opgeven in plaats van PhoneNumberIdentifier.

csharp

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

Java

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

JavaScript

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

Python

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)

Wanneer u een groepsgesprek voert dat een telefoonnummer bevat, moet u een telefoonnummer opgeven dat wordt gebruikt als nummer van een beller-id voor het PSTN-eindpunt.

csharp

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

Java

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

JavaScript

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

Python

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

Het antwoord bevat een CallConnection-object dat u kunt gebruiken om verdere acties uit te voeren voor deze aanroep zodra deze is verbonden. Zodra de oproep is beantwoord, worden twee gebeurtenissen gepubliceerd naar het callback-eindpunt dat u eerder hebt opgegeven:

1. CallConnected gebeurtenis die aangeeft dat de oproep is ingesteld bij de aanroep.
2. ParticipantsUpdated gebeurtenis die de meest recente lijst met deelnemers in het gesprek bevat.

In het geval dat de aanroep mislukt, ontvangt u een CallDisconnected en CreateCallFailed gebeurtenis met foutcodes voor verdere probleemoplossing (zie deze pagina voor meer informatie over foutcodes).

Verbinding maken met een gesprek

Met de verbindingsactie kan uw service een verbinding tot stand brengen met een doorlopende oproep en actie ondernemen. Dit is handig om een Chatgesprek te beheren of wanneer clienttoepassingen een 1:1- of groepsgesprek hebben gestart waarvan gespreksautomatisering geen deel uitmaakt. Verbinding wordt tot stand gebracht met behulp van de eigenschap CallLocator en kan van het type zijn: ServerCallLocator, GroupCallLocator en RoomCallLocator. Deze id's zijn te vinden wanneer de oproep oorspronkelijk tot stand is gebracht of als er een ruimte wordt gemaakt en ook wordt gepubliceerd als onderdeel van de gebeurtenis CallStarted .

Gebruik de ServerCallLocator om verbinding te maken met een 1:1- of groepsoproep. Als u een gesprek hebt gestart met GroupCallId, kunt u ook de GroupCallLocator gebruiken.

csharp

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

Java

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

JavaScript

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

Python

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)

Gebruik RoomCallLocator die RoomId gebruikt om verbinding te maken met een chatgesprek. Meer informatie over ruimten en de wijze waarop de Call Automation-API kan worden gebruikt voor het beheren van een doorlopende chatruimte.

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

Een geslaagd antwoord biedt u het CallConnection-object dat u kunt gebruiken om verdere acties voor deze aanroep uit te voeren. Er worden twee gebeurtenissen gepubliceerd naar het callback-eindpunt dat u eerder hebt opgegeven:

1. CallConnected gebeurtenis die aangeeft dat u verbinding hebt gemaakt met de oproep.
2. ParticipantsUpdated gebeurtenis die de meest recente lijst met deelnemers in het gesprek bevat.

Als de verbinding met uw service na een geslaagde verbinding is verbroken, ontvangt u een melding via een CallDisconected-gebeurtenis. Kan geen verbinding maken met de aanroep in de eerste plaats, resulteert in de gebeurtenis ConnectFailed.

Een inkomende oproep beantwoorden

Zodra u zich hebt geabonneerd om binnenkomende oproepmeldingen naar uw resource te ontvangen, beantwoordt u een inkomende oproep. Wanneer u een oproep beantwoordt, moet u een callback-URL opgeven. Communication Services plaatst alle volgende gebeurtenissen over deze aanroep naar die URL.

csharp

string incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>"; 
Uri callBackUri = new Uri("https://<myendpoint_where_I_want_to_receive_callback_events"); 

var answerCallOptions = new AnswerCallOptions(incomingCallContext, callBackUri);  
AnswerCallResult answerResponse = await client.AnswerCallAsync(answerCallOptions);
CallConnection callConnection = answerResponse.CallConnection; 

Java

String incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>";
String callbackUri = "https://<myendpoint>/Events"; 
 
AnswerCallOptions answerCallOptions = new AnswerCallOptions(incomingCallContext, callbackUri); 
Response<AnswerCallResult> response = client.answerCallWithResponse(answerCallOptions).block(); 

JavaScript

const incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>";
const callbackUri = "https://<myendpoint>/Events";

const { callConnection } = await client.answerCall(incomingCallContext, callbackUri);

Python

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
)

Het antwoord bevat een CallConnection-object dat u kunt gebruiken om verdere acties uit te voeren voor deze aanroep zodra deze is verbonden. Zodra de oproep is beantwoord, worden twee gebeurtenissen gepubliceerd naar het callback-eindpunt dat u eerder hebt opgegeven:

1. CallConnected gebeurtenis die aangeeft dat de oproep tot stand is gebracht met de beller.
2. ParticipantsUpdated gebeurtenis die de meest recente lijst met deelnemers in het gesprek bevat.

In het geval dat de antwoordbewerking mislukt, ontvangt u een AnswerFailed gebeurtenis met foutcodes voor verdere probleemoplossing (zie deze pagina voor meer informatie over foutcodes).

Een oproep weigeren

U kunt ervoor kiezen om een inkomende oproep te weigeren, zoals hieronder wordt weergegeven. U kunt een weigeringsreden opgeven: geen, bezet of verboden. Als er niets wordt opgegeven, wordt er standaard geen gekozen.

csharp

string incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>"; 
var rejectOption = new RejectCallOptions(incomingCallContext); 
rejectOption.CallRejectReason = CallRejectReason.Forbidden; 
_ = await client.RejectCallAsync(rejectOption); 

Java

String incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>";  
RejectCallOptions rejectCallOptions = new RejectCallOptions(incomingCallContext) 
        .setCallRejectReason(CallRejectReason.BUSY); 
Response<Void> response = client.rejectCallWithResponse(rejectCallOptions).block(); 

JavaScript

const incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>";
const rejectOptions = {
    callRejectReason: KnownCallRejectReason.Forbidden,
};
await client.rejectCall(incomingCallContext, rejectOptions);

Python

incoming_call_context = "<IncomingCallContext_From_IncomingCall_Event>"
client.reject_call(
    incoming_call_context=incoming_call_context,
    call_reject_reason=CallRejectReason.FORBIDDEN,
)

Er worden geen gebeurtenissen gepubliceerd voor de weigeringsactie.

Een oproep omleiden

U kunt ervoor kiezen om een binnenkomende oproep om te leiden naar een ander eindpunt zonder deze te beantwoorden. Als u een oproep omleidt, wordt de mogelijkheid van uw toepassing om het gesprek te beheren met behulp van Gespreksautomatisering verwijderd.

csharp

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

Java

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

JavaScript

const incomingCallContext = "<IncomingCallContext_From_IncomingCall_Event>";
const target = { targetParticipant: { communicationUserId: "<user_id_of_target>" } }; //user id looks like 8:a1b1c1-...
await client.redirectCall(incomingCallContext, target);

Python

incoming_call_context = "<IncomingCallContext_From_IncomingCall_Event>"
call_invite = CallInvite(
    CommunicationUserIdentifier("<user_id_of_target>")
  )  # user id looks like 8:a1b1c1-...
client.redirect_call(
    incoming_call_context=incoming_call_context, target_participant=call_invite
)

Als u de oproep wilt omleiden naar een telefoonnummer, maakt u de doel- en beller-id met PhoneNumberIdentifier.

csharp

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

Java

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

JavaScript

const callerIdNumber = { phoneNumber: "+16044561234" };
const target = {
    targetParticipant: { phoneNumber: "+16041234567" }, 
    sourceCallIdNumber: callerIdNumber,
};

Python

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

Er worden geen gebeurtenissen gepubliceerd voor omleiding. Als het doel een Communication Services-gebruiker of een telefoonnummer is dat eigendom is van uw resource, wordt er een nieuwe IncomingCall-gebeurtenis gegenereerd met het veld 'aan' ingesteld op het doel dat u hebt opgegeven.

Een deelnemer in gesprek doorschakelen

Wanneer uw toepassing een oproep beantwoordt of een uitgaande aanroep naar een eindpunt plaatst, kan dat eindpunt worden overgedragen naar een ander doeleindpunt. Als u een oproep van 1:1 overdraagt, wordt uw toepassing verwijderd uit de oproep en wordt de mogelijkheid om het gesprek te beheren met behulp van Gespreksautomatisering verwijderd. De oproepnodiging voor het doel geeft de nummerweergave weer van het eindpunt dat wordt overgedragen. Het opgegeven van een aangepaste nummerweergave wordt niet ondersteund.

csharp

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

Java

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

JavaScript

const transferDestination = { communicationUserId: "<user_id>" };
const options = { operationContext: "<Your_context>", operationCallbackUrl: "<url_endpoint>" };
// adding customCallingContext
const customCallingContext: CustomCallingContext = [];
customCallingContext.push({ kind: "voip", key: "customVoipHeader1", value: "customVoipHeaderValue1" })
options.customCallingContext = customCallingContext;

const result = await callConnection.transferCallToParticipant(transferDestination, options);

Python

transfer_destination = CommunicationUserIdentifier("<user_id>")
call_connection_client = call_automation_client.get_call_connection("<call_connection_id_from_ongoing_call>")
# set custom context
voip_headers = {"customVoipHeader1", "customVoipHeaderValue1"}

result = call_connection_client.transfer_call_to_participant(
    target_participant=transfer_destination,
    voip_headers=voip_headers,
    opration_context="Your context",
    operationCallbackUrl="<url_endpoint>"
)

Wanneer uw toepassing een groepsoproep beantwoordt of een uitgaande groepsoproep naar een eindpunt plaatst of een deelnemer aan een oproep van 1:1 heeft toegevoegd, kan een eindpunt worden overgebracht van de oproep naar een ander doeleindpunt, met uitzondering van het eindpunt voor gespreksautomatisering. Als u een deelnemer overdraagt in een groepsgesprek, wordt het eindpunt dat wordt overgedragen uit de oproep verwijderd. De oproepnodiging voor het doel geeft de nummerweergave weer van het eindpunt dat wordt overgedragen. Het opgegeven van een aangepaste nummerweergave wordt niet ondersteund.

csharp

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

Java

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

JavaScript

// Transfer User
const transferDestination = { communicationUserId: "<user_id>" };
const transferee = { communicationUserId: "<transferee_user_id>" };
const options = { transferee: transferee, operationContext: "<Your_context>", operationCallbackUrl: "<url_endpoint>" };

// adding customCallingContext
const customCallingContext: CustomCallingContext = [];
customContext.push({ kind: "voip", key: "customVoipHeader1", value: "customVoipHeaderValue1" })
options.customCallingContext = customCallingContext;

const result = await callConnection.transferCallToParticipant(transferDestination, options);

// Transfer pstn User
const transferDestination = { phoneNumber: "<taget_phoneNumber>" };
const transferee = { phoneNumber: "<transferee_phoneNumber>" };
const options = { transferee: transferee, operationContext: "<Your_context>", operationCallbackUrl: "<url_endpoint>" };

// adding customCallingContext
const customCallingContext: CustomCallingContext = [];
customContext.push({ kind: "sipuui", key: "", value: "uuivalue" });
customContext.push({ kind: "sipx", key: "headerName", value: "headerValue" })
options.customCallingContext = customCallingContext;

const result = await callConnection.transferCallToParticipant(transferDestination, options);

Python

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

Het sequentiediagram toont de verwachte stroom wanneer uw toepassing een uitgaande aanroep plaatst en deze vervolgens overdraagt naar een ander eindpunt.

Een deelnemer toevoegen aan een gesprek

U kunt een deelnemer (Communication Services-gebruiker of telefoonnummer) toevoegen aan een bestaand gesprek. Wanneer u een telefoonnummer toevoegt, is het verplicht om een nummerweergave op te geven. Deze nummerweergave wordt weergegeven bij oproepmelding aan de deelnemer die wordt toegevoegd.

csharp

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

Java

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

JavaScript

// Add user
// add custom calling context
const customCallingContext: CustomCallingContext = [];
customContext.push({ kind: "voip", key: "voipHeaderName", value: "voipHeaderValue" })

const addThisPerson = {
    targetParticipant: { communicationUserId: "<acs_user_id>" },
    customCallingContext: customCallingContext,
};
const addParticipantResult = await callConnection.addParticipant(addThisPerson, {
            operationCallbackUrl: "<url_endpoint>",
            operationContext: "<operation_context>"
});

// Add PSTN user
const callerIdNumber = { phoneNumber: "+16044561234" }; // This is the Azure Communication Services provisioned phone number for the caller
// add custom calling context
const customCallingContext: CustomCallingContext = [];
customContext.push({ kind: "sipuui", key: "", value: "value" });
customContext.push({ kind: "sipx", key: "headerName", value: "headerValue" })
const addThisPerson = {
    targetParticipant: { phoneNumber: "+16041234567" }, 
    sourceCallIdNumber: callerIdNumber,
    customCallingContext: customCallingContext,
};
const addParticipantResult = await callConnection.addParticipant(addThisPerson, {
            operationCallbackUrl: "<url_endpoint>",
            operationContext: "<operation_context>"
});

Python

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

Als u een Communication Services-gebruiker wilt toevoegen, geeft u een CommunicationUserIdentifier op in plaats van PhoneNumberIdentifier. Nummerweergave is in dit geval niet verplicht.

AddParticipant publiceert een AddParticipantSucceeded of AddParticipantFailed gebeurtenis, samen met de ParticipantUpdated meest recente lijst met deelnemers aan het gesprek.

Een aanvraag voor een deelnemer toevoegen annuleren

csharp

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

Java

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

JavaScript

// Add user
const addThisPerson = {
    targetParticipant: { communicationUserId: "<acs_user_id>" },
};
const { invitationId } = await callConnection.addParticipant(addThisPerson, {
            operationCallbackUrl: "<url_endpoint>",
            operationContext: "<operation_context>"
});

// cancel the request
await callConnection.cancelAddParticipantOperation(invitationId, {
            operationCallbackUrl: "<url_endpoint>",
            operationContext: "<operation_context>"
});

Python

# Add user
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)

# cancel the request
call_connection_client.cancel_add_participant_operation(result.invitation_id, opration_context="Your context", operationCallbackUrl="<url_endpoint>")

Een deelnemer uit een gesprek verwijderen

csharp

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

Java

CommunicationIdentifier removeThisUser = new CommunicationUserIdentifier("<user_id>");
RemoveParticipantOptions removeParticipantOptions = new RemoveParticipantOptions(removeThisUser)
                .setOperationContext("<operation_context>")
                .setOperationCallbackUrl("<url_endpoint>");
Response<RemoveParticipantResult> removeParticipantResultResponse = callConnectionAsync.removeParticipantWithResponse(removeParticipantOptions).block();

JavaScript

const removeThisUser = { communicationUserId: "<user_id>" };
const removeParticipantResult = await callConnection.removeParticipant(removeThisUser, {
            operationCallbackUrl: "<url_endpoint>",
            operationContext: "<operation_context>"
});

Python

remove_this_user = CommunicationUserIdentifier("<user_id>")
call_connection_client = call_automation_client.get_call_connection(
    "<call_connection_id_from_ongoing_call>"
)
result = call_connection_client.remove_participant(remove_this_user, opration_context="Your context", operationCallbackUrl="<url_endpoint>")

RemoveParticipant publiceert een RemoveParticipantSucceeded of RemoveParticipantFailed gebeurtenis, samen met een ParticipantUpdated gebeurtenis die de meest recente lijst met deelnemers aan het gesprek biedt. De verwijderde deelnemer wordt weggelaten uit de lijst.

Een gesprek ophangen

De actie Ophangen kan worden gebruikt om uw toepassing uit de aanroep te verwijderen of om een groepsoproep te beëindigen door de parameter ForEveryone in te stellen op true. Voor een oproep van 1:1 beëindigt ophangen de oproep standaard met de andere deelnemer.

csharp

_ = await callConnection.HangUpAsync(forEveryone: true); 

Java

Response<Void> response = callConnectionAsync.hangUpWithResponse(true).block();

JavaScript

await callConnection.hangUp(true);

Python

call_connection_client.hang_up(is_for_everyone=True)

De gebeurtenis CallDisconnected wordt gepubliceerd zodra de hangUp-actie is voltooid.

Informatie over een gespreksdeelnemer ophalen

csharp

CallParticipant participantInfo = await callConnection.GetParticipantAsync(new CommunicationUserIdentifier("<user_id>"));

Java

CallParticipant participantInfo = callConnection.getParticipant(new CommunicationUserIdentifier("<user_id>")).block();

JavaScript

const participantInfo = await callConnection.getParticipant({ communicationUserId: "<user_id>" });

Python

participant_info = call_connection_client.get_participant(
    CommunicationUserIdentifier("<user_id>")
)

Informatie over alle gespreksdeelnemers

csharp

List<CallParticipant> participantList = (await callConnection.GetParticipantsAsync()).Value.ToList(); 

Java

List<CallParticipant> participantList = Objects.requireNonNull(callConnection.listParticipants().block()).getValues();

JavaScript

const participantList = await callConnection.listParticipants();

Python

participant_list = call_connection_client.list_participants()

Ontvang de meest recente informatie over een gesprek

csharp

CallConnectionProperties callConnectionProperties = await callConnection.GetCallConnectionPropertiesAsync(); 

Java

CallConnectionProperties callConnectionProperties = callConnection.getCallProperties().block(); 

JavaScript

const callConnectionProperties = await callConnection.getCallConnectionProperties();

Python

call_connection_properties = call_connection_client.get_call_properties()