Snabbstart: Ringa ett utgående samtal med hjälp av Samtalsautomation

  • Artikel

Api:er för Samtalsautomatisering i Azure Communication Services är ett kraftfullt sätt att skapa interaktiva samtalsupplevelser. I den här snabbstarten går vi igenom ett sätt att göra ett utgående anrop och identifiera olika händelser i anropet.

Förutsättningar

Exempelkod

Ladda ned eller klona snabbstartsexempelkod från GitHub.

Navigera till CallAutomation_OutboundCalling mappen och öppna lösningen i en kodredigerare.

Konfigurera och vara värd för Din Azure DevTunnel

Azure DevTunnels är en Azure-tjänst som gör att du kan dela lokala webbtjänster som finns på Internet. Kör kommandona för att ansluta din lokala utvecklingsmiljö till det offentliga Internet. DevTunnels skapar en beständig slutpunkts-URL och ger anonym åtkomst. Vi använder den här slutpunkten för att meddela ditt program om samtalshändelser från Azure Communication Services Call Automation-tjänsten.

devtunnel create --allow-anonymous
devtunnel port create -p 8080
devtunnel host

Uppdatera programkonfigurationen

Uppdatera sedan Program.cs filen med följande värden:

  • acsConnectionString: Anslutningssträng för din Azure Communication Services-resurs. Du hittar dina Azure Communication Services-anslutningssträng med hjälp av anvisningarna här.
  • callbackUriHost: När du har initierat DevTunnel-värden uppdaterar du det här fältet med den URI:n.
  • acsPhonenumber: uppdatera det här fältet med det Azure Communication Services-telefonnummer som du har köpt. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • targetPhonenumber: uppdatera fältet med det telefonnummer som du vill att programmet ska ringa upp. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • cognitiveServiceEndpoint: uppdatera fältet med din Azure AI-tjänstslutpunkt.
  • targetTeamsUserId: (Valfritt) uppdateringsfält med det Microsoft Teams-användar-ID som du vill lägga till i anropet. Se Använda Graph API för att hämta Teams användar-ID.
// Your ACS resource connection string 
var acsConnectionString = "<ACS_CONNECTION_STRING>"; 

// Your ACS resource phone number will act as source number to start outbound call 
var acsPhonenumber = "<ACS_PHONE_NUMBER>"; 
 
// Target phone number you want to receive the call. 
var targetPhonenumber = "<TARGET_PHONE_NUMBER>";

// Base url of the app 
var callbackUriHost = "<CALLBACK_URI_HOST_WITH_PROTOCOL>"; 

// Your cognitive service endpoint 
var cognitiveServiceEndpoint = "<COGNITIVE_SERVICE_ENDPOINT>";

// (Optional) User Id of the target teams user you want to receive the call.
var targetTeamsUserId = "<TARGET_TEAMS_USER_ID>";

Ringa ett utgående samtal

För att göra det utgående anropet från Azure Communication Services använder det här exemplet det targetPhonenumber du definierade tidigare i programmet för att skapa anropet med hjälp av API:et CreateCallAsync . Den här koden ringer ett utgående samtal med hjälp av måltelefonnumret.

PhoneNumberIdentifier target = new PhoneNumberIdentifier(targetPhonenumber);
PhoneNumberIdentifier caller = new PhoneNumberIdentifier(acsPhonenumber);
var callbackUri = new Uri(callbackUriHost + "/api/callbacks");
CallInvite callInvite = new CallInvite(target, caller);
var createCallOptions = new CreateCallOptions(callInvite, callbackUri) {
  CallIntelligenceOptions = new CallIntelligenceOptions() {
    CognitiveServicesEndpoint = new Uri(cognitiveServiceEndpoint)
  }
};
CreateCallResult createCallResult = await callAutomationClient.CreateCallAsync(createCallOptions);

Hantera händelser för samtalsautomatisering

Tidigare i vårt program registrerade callbackUriHost vi till Call Automation Service. Värden anger den slutpunkt som tjänsten kräver för att meddela oss om samtalshändelser som inträffar. Vi kan sedan iterera genom händelserna och identifiera specifika händelser som vårt program vill förstå. I koden nedan svarar vi på CallConnected händelsen.

app.MapPost("/api/callbacks", async (CloudEvent[] cloudEvents, ILogger < Program > logger) => {
  foreach(var cloudEvent in cloudEvents) {
    logger.LogInformation($"Event received: {JsonConvert.SerializeObject(cloudEvent)}");
    CallAutomationEventBase parsedEvent = CallAutomationEventParser.Parse(cloudEvent);
    logger.LogInformation($"{parsedEvent?.GetType().Name} parsedEvent received for call connection id: {parsedEvent?.CallConnectionId}");
    var callConnection = callAutomationClient.GetCallConnection(parsedEvent.CallConnectionId);
    var callMedia = callConnection.GetCallMedia();
    if (parsedEvent is CallConnected) {
      //Handle Call Connected Event
    }
  }
});

(Valfritt) Lägga till en Microsoft Teams-användare i anropet

Du kan lägga till en Microsoft Teams-användare i anropet AddParticipantAsync med hjälp av metoden med ett MicrosoftTeamsUserIdentifier och Teams-användarens ID. Du måste först slutföra det nödvändiga steget auktorisering för din Azure Communication Services-resurs för att aktivera anrop till Microsoft Teams-användare. Du kan också skicka in en SourceDisplayName för att styra texten som visas i popup-meddelandet för Teams-användaren.

await callConnection.AddParticipantAsync(
    new CallInvite(new MicrosoftTeamsUserIdentifier(targetTeamsUserId))
    {
        SourceDisplayName = "Jack (Contoso Tech Support)"
    });

Börja spela in ett samtal

Call Automation-tjänsten gör det också möjligt att starta inspelning och lagra inspelningar av röst- och videosamtal. Du kan läsa mer om de olika funktionerna i API:erna för samtalsinspelning här.

CallLocator callLocator = new ServerCallLocator(parsedEvent.ServerCallId);
var recordingResult = await callAutomationClient.GetCallRecording().StartAsync(new StartRecordingOptions(callLocator));
recordingId = recordingResult.Value.RecordingId;

Spela upp välkomstmeddelande och identifiera

TextSourceMed hjälp av kan du ge tjänsten den text som du vill ska syntetiseras och användas för ditt välkomstmeddelande. Azure Communication Services Call Automation-tjänsten spelar upp det här meddelandet vid CallConnected händelsen.

Sedan skickar vi texten till CallMediaRecognizeChoiceOptions och anropar StartRecognizingAsyncsedan . På så sätt kan ditt program identifiera det alternativ som anroparen väljer.

if (parsedEvent is CallConnected callConnected) {
  logger.LogInformation($"Start Recording...");
  CallLocator callLocator = new ServerCallLocator(parsedEvent.ServerCallId);
  var recordingResult = await callAutomationClient.GetCallRecording().StartAsync(new StartRecordingOptions(callLocator));
  recordingId = recordingResult.Value.RecordingId;

  var choices = GetChoices();

  // prepare recognize tones 
  var recognizeOptions = GetMediaRecognizeChoiceOptions(mainMenu, targetPhonenumber, choices);

  // Send request to recognize tones 
  await callMedia.StartRecognizingAsync(recognizeOptions);
}

CallMediaRecognizeChoiceOptions GetMediaRecognizeChoiceOptions(string content, string targetParticipant, List < RecognitionChoice > choices, string context = "") {
  var playSource = new TextSource(content) {
    VoiceName = SpeechToTextVoice
  };

  var recognizeOptions = new CallMediaRecognizeChoiceOptions(targetParticipant: new PhoneNumberIdentifier(targetParticipant), choices) {
    InterruptCallMediaOperation = false,
      InterruptPrompt = false,
      InitialSilenceTimeout = TimeSpan.FromSeconds(10),
      Prompt = playSource,
      OperationContext = context
  };
  return recognizeOptions;
}

List < RecognitionChoice > GetChoices() {
  return new List < RecognitionChoice > {
    new RecognitionChoice("Confirm", new List < string > {
      "Confirm",
      "First",
      "One"
    }) {
      Tone = DtmfTone.One
    },
    new RecognitionChoice("Cancel", new List < string > {
      "Cancel",
      "Second",
      "Two"
    }) {
      Tone = DtmfTone.Two
    }
  };
}

Hantera alternativhändelser

Azure Communication Services Call Automation utlöser api/callbacks den webhook som vi har konfigurerat och meddelar oss om RecognizeCompleted händelsen. Händelsen ger oss möjlighet att svara på mottagna indata och utlösa en åtgärd. Programmet spelar sedan upp ett meddelande till anroparen baserat på de specifika indata som tagits emot.

if (parsedEvent is RecognizeCompleted recognizeCompleted) {
  var choiceResult = recognizeCompleted.RecognizeResult as ChoiceResult;
  var labelDetected = choiceResult?.Label;
  var phraseDetected = choiceResult?.RecognizedPhrase;

  // If choice is detected by phrase, choiceResult.RecognizedPhrase will have the phrase detected,  
  // If choice is detected using dtmf tone, phrase will be null  
  logger.LogInformation("Recognize completed succesfully, labelDetected={labelDetected}, phraseDetected={phraseDetected}", labelDetected, phraseDetected);

  var textToPlay = labelDetected.Equals(ConfirmChoiceLabel, StringComparison.OrdinalIgnoreCase) ? ConfirmedText : CancelText;

  await HandlePlayAsync(callMedia, textToPlay);
}

async Task HandlePlayAsync(CallMedia callConnectionMedia, string text) {
  // Play goodbye message 
  var GoodbyePlaySource = new TextSource(text) {
    VoiceName = "en-US-NancyNeural"
  };
  await callConnectionMedia.PlayToAllAsync(GoodbyePlaySource);
}

Lägg på och stoppa inspelningen

Slutligen, när vi identifierar ett villkor som är meningsfullt för oss att avsluta samtalet, kan vi använda HangUpAsync metoden för att lägga på samtalet.

if ((parsedEvent is PlayCompleted) || (parsedEvent is PlayFailed))
{
    logger.LogInformation($"Stop recording and terminating call.");
    callAutomationClient.GetCallRecording().Stop(recordingId);
    await callConnection.HangUpAsync(true);
}

Kör koden

Om du vill köra programmet med VS Code öppnar du ett terminalfönster och kör följande kommando

dotnet run

Förutsättningar

Exempelkod

Ladda ned eller klona snabbstartsexempelkod från GitHub.

Navigera till CallAutomation_OutboundCalling mappen och öppna lösningen i en kodredigerare.

Konfigurera och vara värd för Din Azure DevTunnel

Azure DevTunnels är en Azure-tjänst som gör att du kan dela lokala webbtjänster som finns på Internet. Kör DevTunnel-kommandona för att ansluta din lokala utvecklingsmiljö till det offentliga Internet. DevTunnels skapar sedan en tunnel med en beständiga slutpunkts-URL och som ger anonym åtkomst. Azure Communication Services använder den här slutpunkten för att meddela ditt program om samtalshändelser från Azure Communication Services Call Automation-tjänsten.

devtunnel create --allow-anonymous
devtunnel port create -p MY_SPRINGAPP_PORT
devtunnel host

Uppdatera programkonfigurationen

Öppna application.yml sedan filen i /resources mappen för att konfigurera följande värden:

  • connectionstring: Anslutningssträng för din Azure Communication Services-resurs. Du hittar dina Azure Communication Services-anslutningssträng med hjälp av anvisningarna här.
  • basecallbackuri: När du har initierat DevTunnel-värden uppdaterar du det här fältet med den URI:n.
  • callerphonenumber: uppdatera det här fältet med det Azure Communication Services-telefonnummer som du har köpt. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • targetphonenumber: uppdatera fältet med det telefonnummer som du vill att programmet ska ringa upp. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • cognitiveServiceEndpoint: uppdatera fältet med din Azure AI-tjänstslutpunkt.
  • targetTeamsUserId: (Valfritt) uppdateringsfält med det Microsoft Teams-användar-ID som du vill lägga till i anropet. Se Använda Graph API för att hämta Teams användar-ID.
acs:
  connectionstring: <YOUR ACS CONNECTION STRING> 
  basecallbackuri: <YOUR DEV TUNNEL ENDPOINT> 
  callerphonenumber: <YOUR ACS PHONE NUMBER ex. "+1425XXXAAAA"> 
  targetphonenumber: <YOUR TARGET PHONE NUMBER ex. "+1425XXXAAAA"> 
  cognitiveServiceEndpoint: <YOUR COGNITIVE SERVICE ENDPOINT>
  targetTeamsUserId: <(OPTIONAL) YOUR TARGET TEAMS USER ID ex. "ab01bc12-d457-4995-a27b-c405ecfe4870">

Ringa ett utgående samtal och spela upp media

För att göra det utgående anropet från Azure Communication Services använder det här exemplet den targetphonenumber du definierade i application.yml filen för att skapa anropet med hjälp av API:et createCallWithResponse .

PhoneNumberIdentifier caller = new PhoneNumberIdentifier(appConfig.getCallerphonenumber());
PhoneNumberIdentifier target = new PhoneNumberIdentifier(appConfig.getTargetphonenumber());
CallInvite callInvite = new CallInvite(target, caller);
CreateCallOptions createCallOptions = new CreateCallOptions(callInvite, appConfig.getCallBackUri());
CallIntelligenceOptions callIntelligenceOptions = new CallIntelligenceOptions().setCognitiveServicesEndpoint(appConfig.getCognitiveServiceEndpoint());
createCallOptions = createCallOptions.setCallIntelligenceOptions(callIntelligenceOptions);
Response<CreateCallResult> result = client.createCallWithResponse(createCallOptions, Context.NONE);

(Valfritt) Lägga till en Microsoft Teams-användare i anropet

Du kan lägga till en Microsoft Teams-användare i anropet addParticipant med hjälp av metoden med ett MicrosoftTeamsUserIdentifier och Teams-användarens ID. Du måste först slutföra det nödvändiga steget auktorisering för din Azure Communication Services-resurs för att aktivera anrop till Microsoft Teams-användare. Du kan också skicka in en SourceDisplayName för att styra texten som visas i popup-meddelandet för Teams-användaren.

client.getCallConnection(callConnectionId).addParticipant(
    new CallInvite(new MicrosoftTeamsUserIdentifier(targetTeamsUserId))
        .setSourceDisplayName("Jack (Contoso Tech Support)"));

Börja spela in ett samtal

Call Automation-tjänsten gör det också möjligt att starta inspelning och lagra inspelningar av röst- och videosamtal. Du kan läsa mer om de olika funktionerna i API:erna för samtalsinspelning här.

ServerCallLocator serverCallLocator = new ServerCallLocator(
    client.getCallConnection(callConnectionId)
        .getCallProperties()
        .getServerCallId());
        
StartRecordingOptions startRecordingOptions = new StartRecordingOptions(serverCallLocator);

Response<RecordingStateResult> response = client.getCallRecording()
    .startWithResponse(startRecordingOptions, Context.NONE);

recordingId = response.getValue().getRecordingId();

Svara på samtalshändelser

Tidigare i vårt program registrerade basecallbackuri vi till Call Automation Service. URI anger slutpunkten som tjänsten använder för att meddela oss om samtalshändelser som inträffar. Vi kan sedan iterera genom händelserna och identifiera specifika händelser som vårt program vill förstå. I koden nedan svarar vi på CallConnected händelsen.

List<CallAutomationEventBase> events = CallAutomationEventParser.parseEvents(reqBody);
for (CallAutomationEventBase event : events) {
    String callConnectionId = event.getCallConnectionId();
    if (event instanceof CallConnected) {
        log.info("CallConnected event received");
    }
    else if (event instanceof RecognizeCompleted) {
        log.info("Recognize Completed event received");
    }
}

Spela upp välkomstmeddelande och identifiera

TextSourceMed hjälp av kan du ge tjänsten den text som du vill ska syntetiseras och användas för ditt välkomstmeddelande. Azure Communication Services Call Automation-tjänsten spelar upp det här meddelandet vid CallConnected händelsen.

Sedan skickar vi texten till CallMediaRecognizeChoiceOptions och anropar StartRecognizingAsyncsedan . På så sätt kan ditt program identifiera det alternativ som anroparen väljer.

var playSource = new TextSource().setText(content).setVoiceName("en-US-NancyNeural");

var recognizeOptions = new CallMediaRecognizeChoiceOptions(new PhoneNumberIdentifier(targetParticipant), getChoices())
  .setInterruptCallMediaOperation(false)
  .setInterruptPrompt(false)
  .setInitialSilenceTimeout(Duration.ofSeconds(10))
  .setPlayPrompt(playSource)
  .setOperationContext(context);

client.getCallConnection(callConnectionId)
  .getCallMedia()
  .startRecognizing(recognizeOptions);

private List < RecognitionChoice > getChoices() {
  var choices = Arrays.asList(
    new RecognitionChoice().setLabel(confirmLabel).setPhrases(Arrays.asList("Confirm", "First", "One")).setTone(DtmfTone.ONE),
    new RecognitionChoice().setLabel(cancelLabel).setPhrases(Arrays.asList("Cancel", "Second", "Two")).setTone(DtmfTone.TWO)
  );

  return choices;
}

Hantera alternativhändelser

Azure Communication Services Call Automation utlöser api/callbacks den webhook som vi har konfigurerat och meddelar oss om RecognizeCompleted händelsen. Händelsen ger oss möjlighet att svara på mottagna indata och utlösa en åtgärd. Programmet spelar sedan upp ett meddelande till anroparen baserat på de specifika indata som tagits emot.

else if (event instanceof RecognizeCompleted) {
  log.info("Recognize Completed event received");

  RecognizeCompleted acsEvent = (RecognizeCompleted) event;

  var choiceResult = (ChoiceResult) acsEvent.getRecognizeResult().get();

  String labelDetected = choiceResult.getLabel();

  String phraseDetected = choiceResult.getRecognizedPhrase();

  log.info("Recognition completed, labelDetected=" + labelDetected + ", phraseDetected=" + phraseDetected + ", context=" + event.getOperationContext());

  String textToPlay = labelDetected.equals(confirmLabel) ? confirmedText : cancelText;

  handlePlay(callConnectionId, textToPlay);
}

private void handlePlay(final String callConnectionId, String textToPlay) {
  var textPlay = new TextSource()
    .setText(textToPlay)
    .setVoiceName("en-US-NancyNeural");

  client.getCallConnection(callConnectionId)
    .getCallMedia()
    .playToAll(textPlay);
}

Lägg på samtalet

Slutligen, när vi identifierar ett villkor som är meningsfullt för oss att avsluta samtalet, kan vi använda hangUp metoden för att lägga på samtalet.

client.getCallConnection(callConnectionId).hangUp(true);

Kör koden

Gå till katalogen som innehåller filen pom.xml och använd följande mvn-kommandon:

  • Kompilera programmet: mvn compile
  • Skapa paketet: mvn package
  • Kör appen: mvn exec:java

Förutsättningar

Exempelkod

Ladda ned eller klona snabbstartsexempelkod från GitHub.

Navigera till CallAutomation_OutboundCalling mappen och öppna lösningen i en kodredigerare.

Konfigurera miljön

Ladda ned exempelkoden och navigera till projektkatalogen npm och kör kommandot som installerar nödvändiga beroenden och konfigurerar utvecklarmiljön.

npm install

Konfigurera och vara värd för Azure DevTunnel

Azure DevTunnels är en Azure-tjänst som gör att du kan dela lokala webbtjänster som finns på Internet. Använd DevTunnel CLI-kommandona för att ansluta din lokala utvecklingsmiljö till det offentliga Internet. Vi använder den här slutpunkten för att meddela ditt program om samtalshändelser från Azure Communication Services Call Automation-tjänsten.

devtunnel create --allow-anonymous
devtunnel port create -p 8080
devtunnel host

Uppdatera programkonfigurationen

Uppdatera .env sedan filen med följande värden:

  • CONNECTION_STRING: Anslutningssträng för din Azure Communication Services-resurs. Du hittar dina Azure Communication Services-anslutningssträng med hjälp av anvisningarna här.
  • CALLBACK_URI: När du har initierat DevTunnel-värden uppdaterar du det här fältet med den URI:n.
  • TARGET_PHONE_NUMBER: uppdatera fältet med det telefonnummer som du vill att programmet ska ringa upp. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • ACS_RESOURCE_PHONE_NUMBER: uppdatera det här fältet med det Azure Communication Services-telefonnummer som du har köpt. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • COGNITIVE_SERVICES_ENDPOINT: uppdatera fältet med din Azure AI-tjänstslutpunkt.
  • TARGET_TEAMS_USER_ID: (Valfritt) uppdateringsfält med det Microsoft Teams-användar-ID som du vill lägga till i anropet. Se Använda Graph API för att hämta Teams användar-ID.
CONNECTION_STRING="<YOUR_CONNECTION_STRING>" 
ACS_RESOURCE_PHONE_NUMBER ="<YOUR_ACS_NUMBER>" 
TARGET_PHONE_NUMBER="<+1XXXXXXXXXX>" 
CALLBACK_URI="<VS_TUNNEL_URL>" 
COGNITIVE_SERVICES_ENDPOINT="<COGNITIVE_SERVICES_ENDPOINT>" 
TARGET_TEAMS_USER_ID="<TARGET_TEAMS_USER_ID>"

Ringa ett utgående samtal och spela upp media

Om du vill ringa utgående samtal från Azure Communication Services använder du det telefonnummer som du angav i miljön. Kontrollera att telefonnumret är i formatet E164-telefonnummer (t.ex. +18881234567)

Koden gör ett utgående anrop med hjälp av den target_phone_number du har angett och skickar ett utgående anrop till det numret:

const callInvite: CallInvite = {
	targetParticipant: callee,
	sourceCallIdNumber: {
		phoneNumber: process.env.ACS_RESOURCE_PHONE_NUMBER || "",
	},
};

const options: CreateCallOptions = {
	cognitiveServicesEndpoint: process.env.COGNITIVE_SERVICES_ENDPOINT
};

console.log("Placing outbound call...");
acsClient.createCall(callInvite, process.env.CALLBACK_URI + "/api/callbacks", options);

(Valfritt) Lägga till en Microsoft Teams-användare i anropet

Du kan lägga till en Microsoft Teams-användare i anropet addParticipant med hjälp av metoden med microsoftTeamsUserId egenskapen . Du måste först slutföra det nödvändiga steget auktorisering för din Azure Communication Services-resurs för att aktivera anrop till Microsoft Teams-användare. Du kan också skicka in en sourceDisplayName för att styra texten som visas i popup-meddelandet för Teams-användaren.

await acsClient.getCallConnection(callConnectionId).addParticipant({
    targetParticipant: { microsoftTeamsUserId: process.env.TARGET_TEAMS_USER_ID },
    sourceDisplayName: "Jack (Contoso Tech Support)"
});

Börja spela in ett samtal

Call Automation-tjänsten gör det också möjligt att starta inspelning och lagra inspelningar av röst- och videosamtal. Du kan läsa mer om de olika funktionerna i API:erna för samtalsinspelning här.

const callLocator: CallLocator = {
    id: serverCallId,
    kind: "serverCallLocator",
};

const recordingOptions: StartRecordingOptions = {
    callLocator: callLocator,
};

const response = await acsClient.getCallRecording().start(recordingOptions);

recordingId = response.recordingId;

Svara på samtalshändelser

Tidigare i vårt program registrerade CALLBACK_URI vi till Call Automation Service. URI anger slutpunkten som tjänsten använder för att meddela oss om anropande händelser som inträffar. Vi kan sedan iterera genom händelserna och identifiera specifika händelser som vårt program vill förstå. Vi svarar på CallConnected händelsen för att få aviseringar och initiera underordnade åtgärder. TextSourceMed hjälp av kan du ge tjänsten den text som du vill ska syntetiseras och användas för ditt välkomstmeddelande. Azure Communication Services Call Automation-tjänsten spelar upp det här meddelandet vid CallConnected händelsen.

Sedan skickar vi texten till CallMediaRecognizeChoiceOptions och anropar StartRecognizingAsyncsedan . På så sätt kan ditt program identifiera det alternativ som anroparen väljer.

callConnectionId = eventData.callConnectionId;
serverCallId = eventData.serverCallId;
console.log("Call back event received, callConnectionId=%s, serverCallId=%s, eventType=%s", callConnectionId, serverCallId, event.type);
callConnection = acsClient.getCallConnection(callConnectionId);
const callMedia = callConnection.getCallMedia();

if (event.type === "Microsoft.Communication.CallConnected") {
 	console.log("Received CallConnected event");
 	await startRecording();
	await startRecognizing(callMedia, mainMenu, "");
}

async function startRecognizing(callMedia: CallMedia, textToPlay: string, context: string) {
	const playSource: TextSource = {
 		text: textToPlay,
 		voiceName: "en-US-NancyNeural",
 		kind: "textSource"
 	};

 	const recognizeOptions: CallMediaRecognizeChoiceOptions = {
 		choices: await getChoices(),
 		interruptPrompt: false,
 		initialSilenceTimeoutInSeconds: 10,
 		playPrompt: playSource,
 		operationContext: context,
 		kind: "callMediaRecognizeChoiceOptions"
 	};

 	await callMedia.startRecognizing(callee, recognizeOptions)
 }

Hantera alternativhändelser

Azure Communication Services Call Automation utlöser api/callbacks den webhook som vi har konfigurerat och meddelar oss om RecognizeCompleted händelsen. Händelsen ger oss möjlighet att svara på mottagna indata och utlösa en åtgärd. Programmet spelar sedan upp ett meddelande till anroparen baserat på de specifika indata som tagits emot.

else if (event.type === "Microsoft.Communication.RecognizeCompleted") { 
	if(eventData.recognitionType === "choices"){ 
        	console.log("Recognition completed, event=%s, resultInformation=%s",eventData, eventData.resultInformation); 
        	var context = eventData.operationContext; 
            	const labelDetected = eventData.choiceResult.label;  
            	const phraseDetected = eventData.choiceResult.recognizedPhrase; 
            	console.log("Recognition completed, labelDetected=%s, phraseDetected=%s, context=%s", labelDetected, phraseDetected, eventData.operationContext); 
            	const textToPlay = labelDetected === confirmLabel ? confirmText : cancelText;            
            	await handlePlay(callMedia, textToPlay); 
        } 
}  
 
async function handlePlay(callConnectionMedia:CallMedia, textContent:string){ 
	const play : TextSource = { text:textContent , voiceName: "en-US-NancyNeural", kind: "textSource"} 
	await callConnectionMedia.playToAll([play]); 
}

Lägg på samtalet

Slutligen, när vi identifierar ett villkor som är meningsfullt för oss att avsluta samtalet, kan vi använda hangUp() metoden för att lägga på samtalet.

  await acsClient.getCallRecording().stop(recordingId);
  callConnection.hangUp(true);

Kör koden

Om du vill köra programmet öppnar du ett terminalfönster och kör följande kommando:

  npm run dev

Förutsättningar

Exempelkod

Ladda ned eller klona snabbstartsexempelkod från GitHub.

Navigera till CallAutomation_OutboundCalling mappen och öppna lösningen i en kodredigerare.

Konfigurera Python-miljön

Skapa och aktivera Python-miljön och installera nödvändiga paket med hjälp av följande kommando. Du kan lära dig mer om att hantera paket här

pip install -r requirements.txt

Konfigurera och vara värd för Azure DevTunnel

Azure DevTunnels är en Azure-tjänst som gör att du kan dela lokala webbtjänster som finns på Internet. Använd kommandona för att ansluta din lokala utvecklingsmiljö till det offentliga Internet. DevTunnels skapar en tunnel med en beständig slutpunkts-URL och som ger anonym åtkomst. Vi använder den här slutpunkten för att meddela ditt program om samtalshändelser från Azure Communication Services Call Automation-tjänsten.

devtunnel create --allow-anonymous
devtunnel port create -p 8080
devtunnel host

Uppdatera programkonfigurationen

Uppdatera main.py sedan filen med följande värden:

  • ACS_CONNECTION_STRING: Anslutningssträng för din Azure Communication Services-resurs. Du hittar dina Azure Communication Services-anslutningssträng med hjälp av anvisningarna här.
  • CALLBACK_URI_HOST: När du har initierat DevTunnel-värden uppdaterar du det här fältet med den URI:n.
  • TARGET_PHONE_NUMBER: uppdatera fältet med det telefonnummer som du vill att programmet ska ringa upp. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • ACS_PHONE_NUMBER: uppdatera det här fältet med det Azure Communication Services-telefonnummer som du har köpt. Det här telefonnumret bör använda formatet E164-telefonnummer (t.ex. +18881234567)
  • COGNITIVE_SERVICES_ENDPOINT: uppdatera fältet med din Azure AI-tjänstslutpunkt.
  • TARGET_TEAMS_USER_ID: (Valfritt) uppdateringsfält med det Microsoft Teams-användar-ID som du vill lägga till i anropet. Se Använda Graph API för att hämta Teams användar-ID.
# Your ACS resource connection string 
ACS_CONNECTION_STRING = "<ACS_CONNECTION_STRING>" 

# Your ACS resource phone number will act as source number to start outbound call 
ACS_PHONE_NUMBER = "<ACS_PHONE_NUMBER>" 

# Target phone number you want to receive the call. 
TARGET_PHONE_NUMBER = "<TARGET_PHONE_NUMBER>" 

# Callback events URI to handle callback events. 
CALLBACK_URI_HOST = "<CALLBACK_URI_HOST_WITH_PROTOCOL>" 
CALLBACK_EVENTS_URI = CALLBACK_URI_HOST + "/api/callbacks" 

#Your Cognitive service endpoint 
COGNITIVE_SERVICES_ENDPOINT = "<COGNITIVE_SERVICES_ENDPOINT>" 

#(OPTIONAL) Your target Microsoft Teams user Id ex. "ab01bc12-d457-4995-a27b-c405ecfe4870"
TARGET_TEAMS_USER_ID = "<TARGET_TEAMS_USER_ID>"

Ringa ett utgående samtal

Om du vill ringa det utgående samtalet från Azure Communication Services anger du först det telefonnummer som du vill ta emot samtalet. För att göra det enkelt kan du uppdatera target_phone_number med ett telefonnummer i formatet E164-telefonnummer (t.ex. +18881234567)

Ring ett utgående samtal med hjälp av target_phone_number du har angett:

target_participant = PhoneNumberIdentifier(TARGET_PHONE_NUMBER) 
source_caller = PhoneNumberIdentifier(ACS_PHONE_NUMBER) 
call_invite = CallInvite(target=target_participant, source_caller_id_number=source_caller) 
call_connection_properties = call_automation_client.create_call(call_invite, CALLBACK_EVENTS_URI, 
cognitive_services_endpoint=COGNITIVE_SERVICES_ENDPOINT) 
    app.logger.info("Created call with connection id: %s",
call_connection_properties.call_connection_id) 
return redirect("/")

(Valfritt) Lägga till en Microsoft Teams-användare i anropet

Du kan lägga till en Microsoft Teams-användare i anropet add_participant med hjälp av metoden med ett MicrosoftTeamsUserIdentifier och Teams-användarens ID. Du måste först slutföra det nödvändiga steget auktorisering för din Azure Communication Services-resurs för att aktivera anrop till Microsoft Teams-användare. Du kan också skicka in en source_display_name för att styra texten som visas i popup-meddelandet för Teams-användaren.

call_connection_client.add_participant(target_participant = CallInvite(
    target = MicrosoftTeamsUserIdentifier(user_id=TARGET_TEAMS_USER_ID),
    source_display_name = "Jack (Contoso Tech Support)"))

Börja spela in ett samtal

Call Automation-tjänsten gör det också möjligt att starta inspelning och lagra inspelningar av röst- och videosamtal. Du kan läsa mer om de olika funktionerna i API:erna för samtalsinspelning här.

recording_properties = call_automation_client.start_recording(ServerCallLocator(event.data['serverCallId']))
recording_id = recording_properties.recording_id

Svara på samtalshändelser

Tidigare i vårt program registrerade CALLBACK_URI_HOST vi till Call Automation Service. URI anger slutpunkten som tjänsten använder för att meddela oss om anropande händelser som inträffar. Vi kan sedan iterera genom händelserna och identifiera specifika händelser som vårt program vill förstå. I koden nedan svarar vi på CallConnected händelsen.

@app.route('/api/callbacks', methods=['POST'])
def callback_events_handler():
    for event_dict in request.json:
        event = CloudEvent.from_dict(event_dict)
        if event.type == "Microsoft.Communication.CallConnected":
            # Handle Call Connected Event
            ...
            return Response(status=200)

Spela upp välkomstmeddelande och identifiera

TextSourceMed hjälp av kan du ge tjänsten den text som du vill ska syntetiseras och användas för ditt välkomstmeddelande. Azure Communication Services Call Automation-tjänsten spelar upp det här meddelandet vid CallConnected händelsen.

Sedan skickar vi texten till CallMediaRecognizeChoiceOptions och anropar StartRecognizingAsyncsedan . På så sätt kan ditt program identifiera det alternativ som anroparen väljer.


get_media_recognize_choice_options( 
    call_connection_client=call_connection_client, 
    text_to_play=MainMenu,  
    target_participant=target_participant, 
    choices=get_choices(),context="") 

def get_media_recognize_choice_options(call_connection_client: CallConnectionClient, text_to_play: str, target_participant:str, choices: any, context: str): 
    play_source =  TextSource (text= text_to_play, voice_name= SpeechToTextVoice) 
    call_connection_client.start_recognizing_media( 
        input_type=RecognizeInputType.CHOICES, 

        target_participant=target_participant,
        choices=choices, 
        play_prompt=play_source, 
        interrupt_prompt=False, 
        initial_silence_timeout=10, 
        operation_context=context 
    ) 

def get_choices(): 
    choices = [ 
        RecognitionChoice(label = ConfirmChoiceLabel, phrases= ["Confirm", "First", "One"], tone = DtmfTone.ONE), 
        RecognitionChoice(label = CancelChoiceLabel, phrases= ["Cancel", "Second", "Two"], tone = DtmfTone.TWO) 
    ] 
return choices

Hantera alternativhändelser

Azure Communication Services Call Automation utlöser api/callbacks den webhook som vi har konfigurerat och meddelar oss om RecognizeCompleted händelsen. Händelsen ger oss möjlighet att svara på mottagna indata och utlösa en åtgärd. Programmet spelar sedan upp ett meddelande till anroparen baserat på de specifika indata som tagits emot.

elif event.type == "Microsoft.Communication.RecognizeCompleted":
	app.logger.info("Recognize completed: data=%s", event.data)
if event.data['recognitionType'] == "choices":
	labelDetected = event.data['choiceResult']['label'];
phraseDetected = event.data['choiceResult']['recognizedPhrase'];
app.logger.info("Recognition completed, labelDetected=%s, phraseDetected=%s, context=%s", labelDetected, phraseDetected, event.data.get('operationContext'))
if labelDetected == ConfirmChoiceLabel:
	textToPlay = ConfirmedText
else:
	textToPlay = CancelText
handle_play(call_connection_client = call_connection_client, text_to_play = textToPlay)
def handle_play(call_connection_client: CallConnectionClient, text_to_play: str):
	play_source = TextSource(text = text_to_play, voice_name = SpeechToTextVoice)
call_connection_client.play_media_to_all(play_source)

Lägg på samtalet

Slutligen, när vi identifierar ett villkor som är meningsfullt för oss att avsluta samtalet, kan vi använda hang_up() metoden för att lägga på samtalet. Slutligen kan vi också stoppa anropsinspelningen på ett säkert sätt.

call_automation_client.stop_recording(recording_id)
call_connection_client.hang_up(is_for_everyone=True)

Kör koden

Om du vill köra programmet med VS Code öppnar du ett terminalfönster och kör följande kommando

python main.py