Snabbstart: Lägga till röstsamtal i din app

I den här snabbstarten lär du dig att starta ett anrop med hjälp av Azure Communication Services Anropa SDK för Windows.

Exempelkod

Du kan hämta exempelappen från GitHub.

Förutsättningar

För att kunna slutföra den här självstudien behöver du följande:

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
• Installera Visual Studio 2019 med arbetsbelastningen Universal Windows Platform Development.
• En distribuerad Communication Services resurs. Skapa en Communication Services resurs.
• En användaråtkomsttoken för din Azure-kommunikationstjänst.

Inrätta

Skapa projektet

I Visual Studio du ett nytt projekt med mallen Tom app (Universal Windows) för att konfigurera en UWP-app (Universal Windows Platform).

Installera paketet

Högerklicka på projektet och gå till Manage Nuget Packages för att installera Azure.Communication.Calling .

Begär åtkomst

Gå till Package.appxmanifest och klicka på Capabilities . Kontrollera Internet (Client & Server) för att få inkommande och utgående åtkomst till Internet. Kontrollera Microphone att du har åtkomst till mikrofonens ljudflöde.

Konfigurera appramverket

Vi måste konfigurera en grundläggande layout för att koppla vår logik. För att kunna göra ett utgående anrop behöver vi ett TextBox för att ange användar-ID för anroparen. Vi behöver också en Start Call knapp och en Hang Up knapp. Öppna för MainPage.xaml projektet och lägg till StackPanel noden i Page :

<Page
    x:Class="CallingQuickstart.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:CallingQuickstart"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <StackPanel>
        <TextBox Text="Who would you like to call?" TextWrapping="Wrap" x:Name="CalleeTextBox" Margin="10,10,10,10"></TextBox>
        <Button Content="Start Call" Click="CallButton_ClickAsync" x:Name="CallButton" Margin="10,10,10,10"></Button>
        <Button Content="Hang Up" Click="HangupButton_Click" x:Name="HangupButton" Margin="10,10,10,10"></Button>
    </StackPanel>
</Page>

Öppna och MainPage.xaml.cs ersätt innehållet med följande implementering:

using System;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

using Azure.Communication;
using Azure.Communication.Calling;

namespace CallingQuickstart
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
            this.InitCallAgent();
        }
        
        private async void InitCallAgent()
        {
            // Create Call Client and initialize Call Agent
        }
        
        private async void CallButton_ClickAsync(object sender, RoutedEventArgs e)
        {
            // Start call
        }

        private async void HangupButton_Click(object sender, RoutedEventArgs e)
        {
            // End the current call
        }

        CallClient call_client_;
        CallAgent call_agent_;
        Call call_;
    }
}

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Anropa SDK:

Name	Beskrivning
CallClient	CallClient är den huvudsakliga startpunkten för anropande SDK.
CallAgent	CallAgent används för att starta och hantera anrop.
CommunicationTokenCredential	CommunicationTokenCredential används som token-autentiseringsuppgifter för att instansiera CallAgent.
CommunicationUserIdentifier	CommunicationUserIdentifier används för att representera identiteten för användaren, vilket kan vara något av följande: CommunicationUserIdentifier/PhoneNumberIdentifier/CallingApplication.

Autentisera klienten

Initiera en instans CallAgent med en token för användaråtkomst som gör att vi kan göra och ta emot anrop.

I följande kod ersätter du med <USER_ACCESS_TOKEN> en token för användaråtkomst. Läs dokumentationen om användaråtkomsttoken om du inte redan har en tillgänglig token.

Lägg till följande kod i InitCallAgent funktionen .

CommunicationTokenCredential token_credential = new CommunicationTokenCredential("<USER_ACCESS_TOKEN>");
call_client_ = new CallClient();

CallAgentOptions callAgentOptions = new CallAgentOptions()
{
    DisplayName = "<YOUR_DISPLAY_NAME>"
};
call_agent_ = await call_client_.CreateCallAgent(token_credential, callAgentOptions);

Starta ett anrop

Lägg till implementeringen i CallButton_ClickAsync för att starta ett anrop med som vi call_agent skapade.

StartCallOptions startCallOptions = new StartCallOptions();
ICommunicationIdentifier[] callees = new ICommunicationIdentifier[1]
{
    new CommunicationUserIdentifier(CalleeTextBox.Text)
};
call_ = await call_agent_.StartCallAsync(callees, startCallOptions);

Avsluta ett anrop

Avsluta det aktuella anropet Hang Up när du klickar på knappen.

await call_.HangUpAsync(new HangUpOptions());

Kör koden

Du kan skapa och köra koden på Visual Studio. Observera att för lösningsplattformar stöder vi ARM64 x64 och x86 .

Du kan göra ett utgående anrop genom att ange ett användar-ID i textfältet och klicka på Start Call knappen. När du anropar ansluts du till en ekorobot. Det här är perfekt för att komma igång 8:echo123 och verifiera att dina ljudenheter fungerar.

I den här snabbstarten lär du dig hur du startar ett anrop med hjälp av Azure Communication Services Anropa SDK för JavaScript.

Exempelkod

Du kan ladda ned exempelappen från Github.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
• Node.js Versionerna Active LTS och Maintenance LTS (8.11.1 och 10.14.1 rekommenderas).
• En aktiv Communication Services resurs. Skapa en Communication Services resurs.
• En användaråtkomsttoken för att instansiera anropsklienten. Lär dig hur du skapar och hanterar token för användaråtkomst.

Inrätta

Skapa ett nytt Node.js-program

Öppna terminalen eller kommandofönstret och skapa en ny katalog för appen och navigera till den.

mkdir calling-quickstart && cd calling-quickstart

Kör npm init -y för attpackage.jsen fil med standardinställningar.

npm init -y

Installera paketet

Använd kommandot npm install för att installera Azure Communication Services Anropa SDK för JavaScript.

npm install @azure/communication-common --save
npm install @azure/communication-calling@1.1.0 --save

Följande versioner av webpack rekommenderas för den här snabbstarten:

"webpack": "^4.42.0",
"webpack-cli": "^3.3.11",
"webpack-dev-server": "^3.10.3"

Alternativet --save visar biblioteket som ett beroende i dittpackage.js på filen.

Konfigurera appramverket

Den här snabbstarten använder webpack för att paketera programtillgångarna. Kör följande kommando för att installera npm-paketen webpack, webpack-cli och webpack-dev-server och visa dem som utvecklingsberoenden i dinpackage.jspå:

npm install webpack@4.42.0 webpack-cli@3.3.11 webpack-dev-server@3.10.3 --save-dev

Skapa en index.html-fil i rotkatalogen för projektet. Vi använder den här filen för att konfigurera en grundläggande layout som gör att användaren kan ringa ett anrop.

Här är koden:

<!DOCTYPE html>
<html>
  <head>
    <title>Communication Client - Calling Sample</title>
  </head>
  <body>
    <h4>Azure Communication Services</h4>
    <h1>Calling Quickstart</h1>
    <input 
      id="token-input"
      type="text"
      placeholder="User access token"
      style="margin-bottom:1em; width: 200px;"
    />
    </div>
    <button id="token-submit" type="button">
        Submit
    </button>
    <input 
      id="callee-id-input"
      type="text"
      placeholder="Who would you like to call?"
      style="margin-bottom:1em; width: 200px; display: block;"
    />
    <div>
      <button id="call-button" type="button" disabled="true">
        Start Call
      </button>
      &nbsp;
      <button id="hang-up-button" type="button" disabled="true">
        Hang Up
      </button>
    </div>
    <script src="./bundle.js"></script>
  </body>
</html>

Skapa en fil i rotkatalogen i projektet med namnet client.js ska innehålla programlogiken för den här snabbstarten. Lägg till följande kod för att importera den anropande klienten och hämta referenser till DOM-elementen så att vi kan koppla vår affärslogik.

import { CallClient, CallAgent } from "@azure/communication-calling";
import { AzureCommunicationTokenCredential } from '@azure/communication-common';

let call;
let callAgent;
let tokenCredential = "";
const userToken = document.getElementById("token-input");
const calleeInput = document.getElementById("callee-id-input");
const submitToken = document.getElementById("token-submit");
const callButton = document.getElementById("call-button");
const hangUpButton = document.getElementById("hang-up-button");

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Anropa SDK:

Name	Beskrivning
CallClient	CallClient är den huvudsakliga startpunkten för den anropande SDK:n.
CallAgent	CallAgent används för att starta och hantera anrop.
AzureCommunicationTokenCredential	Klassen AzureCommunicationTokenCredential implementerar communicationTokenCredential-gränssnittet som används för att instansiera CallAgent.

Autentisera klienten

Du måste ange en giltig token för användaråtkomst för din resurs i textfältet och klicka på Skicka. Läs dokumentationen om användaråtkomsttoken om du inte redan har en tillgänglig token. Med CallClient hjälp av initierar du CallAgent en -instans med CommunicationTokenCredential en som gör att vi kan göra och ta emot anrop.

Lägg till följande kod i client.js:

submitToken.addEventListener("click", async () => {
  const callClient = new CallClient(); 
  const userTokenCredential = userToken.value;
    try {
      tokenCredential = new AzureCommunicationTokenCredential(userTokenCredential);
      callAgent = await callClient.createCallAgent(tokenCredential);
      callButton.disabled = false;
      submitToken.disabled = true;
    } catch(error) {
      window.alert("Please submit a valid token!");
    }
})

Starta ett anrop

Lägg till en händelsehanterare för att initiera ett anrop callButton när du klickar på :

callButton.addEventListener("click", () => {
    // start a call
    const userToCall = calleeInput.value;
    // To call an ACS communication user, use {communicationUserId: 'ACS_USER_ID'}.
    // To call echobot, use {id: '8:echo123'}.
    call = callAgent.startCall(
        [{ communicationUserId: userToCall }],
        {}
    );
    // toggle button states
    hangUpButton.disabled = false;
    callButton.disabled = true;
});

Avsluta ett anrop

Lägg till en händelselyssnare för att avsluta det aktuella hangUpButton anropet när du klickar på :

hangUpButton.addEventListener("click", () => {
  // end the current call
  call.hangUp({ forEveryone: true });

  // toggle button states
  hangUpButton.disabled = true;
  callButton.disabled = false;
  submitToken.disabled = false;
});

Egenskapen forEveryone avslutar anropet för alla samtalsdeltagare.

Kör koden

Använd för webpack-dev-server att skapa och köra din app. Kör följande kommando för att paketa programvärden i på en lokal webbserver:

npx webpack-dev-server --entry ./client.js --output bundle.js --debug --devtool inline-source-map

Öppna din webbläsare och gå till http://localhost:8080/. Du bör se följande:

Du kan göra ett utgående VOIP-anrop genom att ange en giltig användaråtkomsttoken och användar-ID i motsvarande textfält och klicka på knappen Starta anrop.

När du anropar ansluts du till en ekorobot. Det här är perfekt för att komma igång 8:echo123 och verifiera att dina ljudenheter fungerar. Skicka {id: '8:echo123'} till API:et CallAgent.startCall() för att anropa echobot. Om du vill anropa en ACS-kommunikationsanvändare skickar {communicationUserId: 'ACS_USER_ID'} du till CallAgent.startCall() API:et.

I den här snabbstarten lär du dig att starta ett anrop med hjälp av Azure Communication Services Anropa SDK för Android.

Exempelkod

Du kan hämta exempelappen från GitHub.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
• Android Studioför att skapa ditt Android-program.
• En distribuerad Communication Services resurs. Skapa en Communication Services resurs.
• En användaråtkomsttoken för din Azure-kommunikationstjänst.

Inrätta

Skapa en Android-app med en tom aktivitet

Från Android Studio väljer du Starta ett nytt Android Studio projekt.

Välj projektmallen "Tom aktivitet" under "Telefon och surfplatta".

Välj Minsta SDK för "API 26: Android 8.0 (Oreo)" eller högre.

Installera paketet

Leta upp din build.gradle på projektnivå och se till att mavenCentral() lägga till i listan över lagringsplatsen under buildscript och allprojects

buildscript {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

allprojects {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

Sedan lägger du till följande rader i avsnitten dependencies och android i build.gradle på modulnivå

android {
    ...
    packagingOptions {
        pickFirst  'META-INF/*'
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

dependencies {
    ...
    implementation 'com.azure.android:azure-communication-calling:1.0.0-beta.8'
    ...
}

Lägga till behörigheter till programmanifestet

För att kunna begära behörigheter som krävs för att göra ett anrop måste de först deklareras i applikationsmanifestet ( app/src/main/AndroidManifest.xml ). Ersätt innehållet i filen med följande:

    <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.contoso.acsquickstart">

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <!--Our Calling SDK depends on the Apache HTTP SDK.
When targeting Android SDK 28+, this library needs to be explicitly referenced.
See https://developer.android.com/about/versions/pie/android-9.0-changes-28#apache-p-->
        <uses-library android:name="org.apache.http.legacy" android:required="false"/>
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>
    

Konfigurera appens layout

Två indata behövs: en textinmatning för mottagarens ID och en knapp för att ringa anropet. Dessa kan läggas till via designern eller genom att redigera xml-layouten. Skapa en knapp med ID:t call_button och textinmatningen callee_id . Gå till app/src/main/res/layout/activity_main.xml ( ) och ersätt innehållet i filen med följande:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/call_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="16dp"
        android:text="Call"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent" />

    <EditText
        android:id="@+id/callee_id"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="Callee Id"
        android:inputType="textPersonName"
        app:layout_constraintBottom_toTopOf="@+id/call_button"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

Skapa huvudaktivitetens scaffolding och bindningar

När layouten har skapats kan bindningarna läggas till samt den grundläggande scaffold-grenen för aktiviteten. Aktiviteten hanterar begärande körningsbehörigheter, skapar anropsagenten och placerar anropet när knappen trycks ned. Var och en tas upp i sitt eget avsnitt. Metoden onCreate åsidosätts för att anropa och getAllPermissions samt lägga till createAgent bindningar för anropsknappen. Detta inträffar bara en gång när aktiviteten skapas. Mer information om onCreate finns i guiden Förstå aktivitetslivscykeln.

Gå till MainActivity.java och ersätt innehållet med följande kod:

package com.contoso.acsquickstart;

import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import android.media.AudioManager;
import android.Manifest;
import android.content.pm.PackageManager;

import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

import com.azure.android.communication.common.CommunicationUserIdentifier;
import com.azure.android.communication.common.CommunicationTokenCredential;
import com.azure.android.communication.calling.CallAgent;
import com.azure.android.communication.calling.CallClient;
import com.azure.android.communication.calling.StartCallOptions;


import java.util.ArrayList;

public class MainActivity extends AppCompatActivity {
    
    private CallAgent callAgent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        getAllPermissions();
        createAgent();
        
        // Bind call button to call `startCall`
        Button callButton = findViewById(R.id.call_button);
        callButton.setOnClickListener(l -> startCall());
        
        setVolumeControlStream(AudioManager.STREAM_VOICE_CALL);
    }

    /**
     * Request each required permission if the app doesn't already have it.
     */
    private void getAllPermissions() {
        // See section on requesting permissions
    }

    /**
      * Create the call agent for placing calls
      */
    private void createAgent() {
        // See section on creating the call agent
    }

    /**
     * Place a call to the callee id provided in `callee_id` text input.
     */
    private void startCall() {
        // See section on starting the call
    }
}

Begära behörigheter vid körning

För Android 6.0 och senare (API-nivå 23) och 23 eller högre beviljas behörigheter vid körning i stället för targetSdkVersion när appen installeras. För att stödja detta kan getAllPermissions implementeras för att anropa ActivityCompat.checkSelfPermission och för varje nödvändig ActivityCompat.requestPermissions behörighet.

/**
 * Request each required permission if the app doesn't already have it.
 */
private void getAllPermissions() {
    String[] requiredPermissions = new String[]{Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_PHONE_STATE};
    ArrayList<String> permissionsToAskFor = new ArrayList<>();
    for (String permission : requiredPermissions) {
        if (ActivityCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
            permissionsToAskFor.add(permission);
        }
    }
    if (!permissionsToAskFor.isEmpty()) {
        ActivityCompat.requestPermissions(this, permissionsToAskFor.toArray(new String[0]), 1);
    }
}

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Anropa SDK:

Name	Beskrivning
CallClient	CallClient är den huvudsakliga startpunkten för anropande SDK.
CallAgent	CallAgent används för att starta och hantera anrop.
CommunicationTokenCredential	CommunicationTokenCredential används som token-autentiseringsuppgifter för att instansiera CallAgent.
CommunicationIdentifier	CommunicationIdentifier används som en annan typ av deltagare som kan ingå i ett anrop.

Skapa en agent från användaråtkomsttoken

Med en användartoken kan en autentiserad anropsagent instansieras. I allmänhet genereras denna token från en tjänst med autentisering som är specifik för programmet. Mer information om användaråtkomsttoken finns i guiden För användaråtkomsttoken.

För snabbstarten ersätter du <User_Access_Token> med en användaråtkomsttoken som genererats för din Azure Communication Service-resurs.

/**
 * Create the call agent for placing calls
 */
private void createAgent() {
    String userToken = "<User_Access_Token>";

    try {
        CommunicationTokenCredential credential = new CommunicationTokenCredential(userToken);
        callAgent = new CallClient().createCallAgent(getApplicationContext(), credential).get();
    } catch (Exception ex) {
        Toast.makeText(getApplicationContext(), "Failed to create call agent.", Toast.LENGTH_SHORT).show();
    }
}

Starta ett anrop med hjälp av anropsagenten

Anropet kan göras via samtalsagenten och kräver bara att du tillhandahåller en lista över callee-ID:er och anropsalternativen. För snabbstarten används standardalternativen för anrop utan video och ett enda nummerpresentation från textinmatningen.

/**
 * Place a call to the callee id provided in `callee_id` text input.
 */
private void startCall() {
    EditText calleeIdView = findViewById(R.id.callee_id);
    String calleeId = calleeIdView.getText().toString();
    
    StartCallOptions options = new StartCallOptions();

    callAgent.startCall(
        getApplicationContext(),
        new CommunicationUserIdentifier[] {new CommunicationUserIdentifier(calleeId)},
        options);
}

Starta appen och anropa ekoroboten

Appen kan nu startas med knappen "Kör app" i verktygsfältet (Skift + F10). Kontrollera att du kan göra anrop genom att anropa 8:echo123 . Ett förinspelat meddelande spelas upp och upprepar sedan meddelandet till dig igen.

I den här snabbstarten lär du dig att starta ett anrop med hjälp av Azure Communication Services anropa SDK för iOS.

Exempelkod

Du kan hämta exempelappen från GitHub.

Förutsättningar

För att kunna slutföra den här självstudien behöver du följande:

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
• En Mac som kör Xcode, tillsammans med ett giltigt utvecklarcertifikat som är installerat i din nyckelring.
• En distribuerad Communication Services resurs. Skapa en Communication Services resurs.
• En användaråtkomsttoken för din Azure-kommunikationstjänst.

Inrätta

Skapa Xcode-projektet

I Xcode skapar du ett nytt iOS-projekt och väljer mallen App med enkel vy. I den här självstudien används SwiftUI-ramverket, så du bör ange Språket till Swift och Användargränssnitt till SwiftUI. Du kommer inte att skapa tester under den här snabbstarten. Avmarkera Inkludera tester om du vill.

Installera paketet och beroenden med CocoaPods

1. Om du vill skapa en podfile för ditt program öppnar du terminalen och går till projektmappen och kör:

   pod init

2. Lägg till följande kod i podfilen och spara (se till att "target" matchar namnet på ditt projekt):

   platform :ios, '13.0'
   use_frameworks!
   
   target 'AzureCommunicationCallingSample' do
     pod 'AzureCommunicationCalling', '~> 1.0.0'
   end
   

3. Kör pod install.

4. Öppna med .xcworkspace Xcode.

Begär åtkomst till mikrofonen

För att få åtkomst till enhetens mikrofon måste du uppdatera appens informationsegenskapslista med NSMicrophoneUsageDescription en . Du anger det associerade värdet till string en som ska ingå i dialogrutan som systemet använder för att begära åtkomst från användaren.

Högerklicka på posten Info.plist i projektträdet och välj Öppna som > källkod. Lägg till följande rader i avsnittet <dict> på den översta nivån och spara sedan filen.

<key>NSMicrophoneUsageDescription</key>
<string>Need microphone access for VOIP calling.</string>

Konfigurera appramverket

Öppna projektets ContentView.swift-fil och lägg till import en deklaration överst i filen för att importera AzureCommunicationCalling library . Importera dessutom , AVFoundation vi behöver detta för ljudbehörighetsbegäran i koden.

import AzureCommunicationCalling
import AVFoundation

Ersätt implementeringen av ContentView struct-structen med några enkla UI-kontroller som gör att en användare kan initiera och avsluta ett anrop. Vi kopplar affärslogik till dessa kontroller i den här snabbstarten.

struct ContentView: View {
    @State var callee: String = ""
    @State var callClient: CallClient?
    @State var callAgent: CallAgent?
    @State var call: Call?

    var body: some View {
        NavigationView {
            Form {
                Section {
                    TextField("Who would you like to call?", text: $callee)
                    Button(action: startCall) {
                        Text("Start Call")
                    }.disabled(callAgent == nil)
                    Button(action: endCall) {
                        Text("End Call")
                    }.disabled(call == nil)
                }
            }
            .navigationBarTitle("Calling Quickstart")
        }.onAppear {
            // Initialize call agent
        }
    }

    func startCall() {
        // Ask permissions
        AVAudioSession.sharedInstance().requestRecordPermission { (granted) in
            if granted {
                // Add start call logic
            }
        }
    }

    func endCall() {
        // Add end call logic
    }
}

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Anropa SDK:

Name	Beskrivning
CallClient	CallClient är den huvudsakliga startpunkten för anropande SDK.
CallAgent	CallAgent används för att starta och hantera anrop.
CommunicationTokenCredential	CommunicationTokenCredential används som token-autentiseringsuppgifter för att instansiera CallAgent.
CommunicationUserIdentifier	CommunicationUserIdentifier används för att representera identiteten för användaren, vilket kan vara något av följande: CommunicationUserIdentifier/PhoneNumberIdentifier/CallingApplication.

Autentisera klienten

Initiera en instans CallAgent med en token för användaråtkomst som gör att vi kan göra och ta emot anrop.

I följande kod måste du ersätta med en <USER ACCESS TOKEN> giltig användaråtkomsttoken för din resurs. Läs dokumentationen om användaråtkomsttoken om du inte redan har en tillgänglig token.

Lägg till följande kod i onAppear återanropet i ContentView.swift:

var userCredential: CommunicationTokenCredential?
do {
    userCredential = try CommunicationTokenCredential(token: "<USER ACCESS TOKEN>")
} catch {
    print("ERROR: It was not possible to create user credential.")
    return
}

self.callClient = CallClient()

// Creates the call agent
self.callClient?.createCallAgent(userCredential: userCredential!) { (agent, error) in
    if error != nil {
        print("ERROR: It was not possible to create a call agent.")
        return
    }
    else {
        self.callAgent = agent
        print("Call agent successfully created.")
    }
}

Starta ett anrop

Metoden startCall anges som den åtgärd som ska utföras när du trycker på knappen Starta anrop. Uppdatera implementeringen för att starta ett anrop med ASACallAgent :

func startCall()
{
    // Ask permissions
    AVAudioSession.sharedInstance().requestRecordPermission { (granted) in
        if granted {
            // start call logic
            let callees:[CommunicationIdentifier] = [CommunicationUserIdentifier(self.callee)]
            self.callAgent?.startCall(participants: callees, options: StartCallOptions()) { (call, error) in
                if (error == nil) {
                    self.call = call
                } else {
                    print("Failed to get call object")
                }
            }
        }
    }
}

Du kan också använda egenskaperna i för att ange de första alternativen för anropet (d.v.s. det tillåter att anropet startas med mikrofonen StartCallOptions avstängd).

Avsluta ett anrop

Implementera metoden endCall för att avsluta det aktuella anropet när du trycker på knappen Avsluta anrop.

func endCall()
{    
    self.call!.hangUp(options: HangUpOptions()) { (error) in
        if (error != nil) {
            print("ERROR: It was not possible to hangup the call.")
        }
    }
}

Kör koden

Du kan skapa och köra appen i iOS-simulatorn genom att välja Produktkörning eller med > hjälp av kortkommandot (⌘-R).

Du kan göra ett utgående VOIP-anrop genom att ange ett användar-ID i textfältet och trycka på knappen Starta anrop. När du anropar ansluts du till en ekorobot. Det här är perfekt för att komma igång 8:echo123 och verifiera att ljudenheterna fungerar.