Quickstart: Spraakoproep toevoegen aan uw app

In deze quickstart leert u hoe u een aanroep start met behulp van de Azure Communication Services Calling SDK voor Windows.

Voorbeeldcode

U kunt de voorbeeld-app downloaden via GitHub.

Vereisten

Voor het voltooien van deze zelfstudie moet aan de volgende vereisten worden voldaan:

• Een Azure-account met een actief abonnement. Gratis een account maken
• Installeer Visual Studio 2019 met de workload Universal Windows Platform-ontwikkeling.
• Een geïmplementeerde Communication Services-resource. Een Communication Services maken.
• Een Token voor gebruikerstoegang voor uw Azure Communication Service.

Instellen

Het project maken

Maak Visual Studio een nieuw project met de sjabloon Lege app (Universal Windows) om een UWP-app (Universal Windows Platform) met één pagina in te stellen.

Het pakket installeren

Klik met de rechtermuisknop op uw project en ga naar Manage Nuget Packages om te Azure.Communication.Calling installeren.

Toegang aanvragen

Ga naar Package.appxmanifest en klik op Capabilities . Controleer Internet (Client & Server) of u binnenkomende en uitgaande toegang tot internet hebt. Controleer Microphone of u toegang hebt tot de audiofeed van de microfoon.

Het app-framework instellen

We moeten een basisindeling configureren om onze logica te koppelen. Om een uitgaande oproep te plaatsen, hebben we een nodig om de gebruikers-id van de aanroeper TextBox op te geven. We hebben ook een Start Call knop en een knop Hang Up nodig. Open de MainPage.xaml van uw project en voeg het StackPanel knooppunt toe aan uw 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>

Open de MainPage.xaml.cs en vervang de inhoud door de volgende implementatie:

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_;
    }
}

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Calling SDK:

Naam	Beschrijving
CallClient	De CallClient is het belangrijkste toegangspunt voor de aanroepende SDK.
CallAgent	De CallAgent wordt gebruikt om oproepen te starten en te beheren.
CommunicationTokenCredential	CommunicationTokenCredential wordt gebruikt als tokenreferentie om de CallAgent te instanteren.
CommunicationUserIdentifier	De CommunicationUserIdentifier wordt gebruikt voor de identiteit van de gebruiker. Dit kan een van de volgende zijn: CommunicationUserIdentifier/PhoneNumberIdentifier/CallingApplication.

De client verifiëren

Initialiseer een CallAgent-instantie met een token voor gebruikerstoegang waarmee we oproepen kunnen maken en ontvangen.

Vervang in de volgende code <USER_ACCESS_TOKEN> door een Token voor gebruikerstoegang. Raadpleeg de documentatie inzake Token voor gebruikerstoegang als u nog geen token hebt.

Voeg de volgende code toe aan de InitCallAgent functie .

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

Een oproep starten

Voeg de implementatie toe aan de CallButton_ClickAsync om een aanroep te starten met de call_agent die we hebben gemaakt.

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

Een oproep beëindigen

De huidige aanroep beëindigen wanneer Hang Up op de knop wordt geklikt.

await call_.HangUpAsync(new HangUpOptions());

De code uitvoeren

U kunt de code bouwen en uitvoeren op Visual Studio. Houd er rekening mee dat voor oplossingsplatforms , ARM64 en x64 worden x86 ondersteund.

U kunt een uitgaande oproep maken door een gebruikers-id op te geven in het tekstveld en op de knop te Start Call klikken. Door 8:echo123 te bellen, wordt u verbonden met een echo-bot. Dit is handig om aan de slag te gaan en te controleren of uw audio-apparaten werken.

In deze quickstart leert u hoe u een aanroep start met behulp van de Azure Communication Services Calling SDK voor JavaScript.

Voorbeeldcode

U kunt de voorbeeld-app downloaden van Github.

Vereisten

• Een Azure-account met een actief abonnement. Gratis een account maken
• Node.js, Active LTS en Maintenance LTS-versies (8.11.1 en 10.14.1 aanbevolen).
• Een actieve Communication Services-resource. Een Communication Services maken.
• Een token voor gebruikerstoegang voor het instantiëren van de client voor oproepen. Meer informatie over tokens voor gebruikerstoegang maken en beheren.

Instellen

Een nieuwe Node.js-toepassing maken

Open uw terminal of opdrachtvenster, maak een nieuwe map voor uw app en navigeer daar naartoe.

mkdir calling-quickstart && cd calling-quickstart

Voer npm init -y uit om een package.json-bestand te maken met de standaardinstellingen.

npm init -y

Het pakket installeren

Gebruik de npm install opdracht om de SDK Azure Communication Services JavaScript te installeren.

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

De volgende versies van webpack worden aanbevolen voor deze quickstart:

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

De optie --save geeft de bibliotheek weer als afhankelijkheid in het package.json-bestand.

Het app-framework instellen

In deze snelstart wordt webpack gebruikt om de toepassingsassets te bundelen. Voer de volgende opdracht uit om de webpack-, webpack-CLI- en webpack-dev-server npm-pakketten te installeren en deze weer te geven als ontwikkelingsafhankelijkheden in uw package.json:

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

Maak een index. html-bestand in de hoofdmap van uw project. Dit bestand wordt gebruikt voor het configureren van een basisindeling waarmee de gebruiker een oproep kan plaatsen.

Hier volgt de code:

<!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>

Maak een bestand in de hoofdmap van uw project met de naam client.js om de toepassingslogica voor deze snelstart te bevatten. Voeg de volgende code toe om de oproepclient te importeren en verwijzingen naar de DOM-elementen op te halen, zodat we onze bedrijfslogica kunnen koppelen.

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

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Calling SDK:

Naam	Beschrijving
CallClient	De CallClient is het belangrijkste toegangspunt voor de aanroepende SDK.
CallAgent	De CallAgent wordt gebruikt om oproepen te starten en te beheren.
AzureCommunicationTokenCredential	De klasse AzureCommunicationTokenCredential implementeert de CommunicationTokenCredential-interface die wordt gebruikt om de CallAgent te instanteren.

De client verifiëren

U moet een geldig token voor gebruikerstoegang voor uw resource invoeren in het tekstveld en op Verzenden klikken. Raadpleeg de documentatie inzake Token voor gebruikerstoegang als u nog geen token hebt. Met behulp van de CallClientinitialiseert u een CallAgent-instantie met een CommunicationTokenCredential waarmee we oproepen kunnen doen en ontvangen.

Voeg de volgende code toe aan 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!");
    }
})

Een oproep starten

Voeg een gebeurtenis-handler toe om een oproep te initiëren wanneer op de callButton wordt geklikt:

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

Een oproep beëindigen

Voeg een gebeurtenis-listener toe om de huidige oproep te beëindigen wanneer op de hangUpButton wordt geklikt:

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

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

De eigenschap forEveryone beëindigt de oproep voor alle deelnemers aan de oproep.

De code uitvoeren

Gebruik de webpack-dev-server om uw app te bouwen en uit te voeren. Voer de volgende opdracht uit om de toepassingshost op een lokale webserver te bundelen:

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

Open uw browser en ga naar http://localhost:8080/. U ziet nu het volgende:

U kunt een uitgaande VOIP-aanroep maken door een geldig token voor gebruikerstoegang en gebruikers-id op te geven in de bijbehorende tekstvelden en op de knop Oproep starten te klikken.

Door 8:echo123 te bellen, wordt u verbonden met een echo-bot. Dit is handig om aan de slag te gaan en te controleren of uw audio-apparaten werken. Geef {id: '8:echo123'} door aan de API CallAgent.startCall() om echobot aan te roepen. Als u een ACS-communicatiegebruiker wilt aanroepen, gaat {communicationUserId: 'ACS_USER_ID'} u naar de CallAgent.startCall() API.

In deze quickstart leert u hoe u een aanroep start met behulp van de Azure Communication Services Calling SDK voor Android.

Voorbeeldcode

U kunt de voorbeeld-app downloaden van GitHub.

Vereisten

• Een Azure-account met een actief abonnement. Gratis een account maken
• Android Studio, voor het maken van uw Android-toepassing.
• Een geïmplementeerde Communication Services-resource. Een Communication Services maken.
• Een Token voor gebruikerstoegang voor uw Azure Communication Service.

Instellen

Een Android-app maken met een lege activiteit

Selecteer Een nieuw Android Studio-project starten in Android Studio.

Selecteer de projectsjabloon Lege activiteit onder Telefoon en tablet.

Selecteer Minimale SDK van 'API 26: Android 8.0 (Oreo)' of hoger.

Het pakket installeren

Zoek de build.gradle op projectniveau op en vergeet niet mavenCentral() toe te voegen aan de lijst met opslagplaatsen onder buildscript en allprojects

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

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

Voeg vervolgens in de build.gradle op moduleniveau de volgende regels toe aan de secties Afhankelijkheden en Android

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'
    ...
}

Machtigingen toevoegen aan het toepassingsmanifest

Als u machtigingen wilt aanvragen die nodig zijn om een aanroep te doen, moeten deze eerst worden gedeclareerd in het toepassingsmanifest (app/src/main/AndroidManifest.xml). Vervang de inhoud van het bestand door het volgende:

    <?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>
    

De indeling van de app instellen

Er moeten twee items worden toegevoegd: een tekstvak voor de id van de persoon die wordt gebeld en een knop om te bellen. U kunt deze onderdelen toevoegen via het ontwerpprogramma of door het XML-bestand van de indeling te bewerken. Maak een knop met een id van call_button en een tekstinvoer van callee_id. Ga naar (app/src/main/res/layout/activity_main.xml) en vervang de inhoud van het bestand door het volgende:

<?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>

De hoofdopbouw en -bindingen van de activiteit maken

Nu de indeling is gemaakt, kunnen de bindingen en de basisopzet van de activiteit worden toegevoegd. De activiteit verwerkt machtigingen voor de runtime van aanvragen. Hiermee wordt de aanroepagent gemaakt en wordt de aanroep gemaakt zodra de gebruiker op de knop drukt. Elk onderdeel wordt in een aparte sectie behandeld. De onCreate-methode wordt overschreven om getAllPermissions en createAgent in te trekken en om de bindingen voor de aanroepknop toe te voegen. Dit wordt slechts eenmalig uitgevoerd wanneer de activiteit wordt gemaakt. Raadpleeg de handleiding Informatie over de levenscyclus van activiteiten voor meer informatie over onCreate.

Ga naar MainActivity.java en vervang de inhoud door de volgende code:

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
    }
}

Machtigingen tijdens runtime aanvragen

Voor Android 6.0 en hoger (API-niveau 23) en targetSdkVersion 23 of hoger worden machtigingen toegekend tijdens de runtime in plaats van tijdens de installatie van de app. Om dit te ondersteunen kan getAllPermissions worden geïmplementeerd om ActivityCompat.checkSelfPermission en ActivityCompat.requestPermissions aan te roepen voor elke vereiste machtiging.

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

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Calling SDK:

Naam	Beschrijving
CallClient	De CallClient is het belangrijkste toegangspunt voor de aanroepende SDK.
CallAgent	De CallAgent wordt gebruikt om oproepen te starten en te beheren.
CommunicationTokenCredential	CommunicationTokenCredential wordt gebruikt als tokenreferentie om de CallAgent te instanteren.
CommunicationIdentifier	De CommunicationIdentifier wordt gebruikt als een ander type deelnemer dat deel zou kunnen uitmaken van een aanroep.

Een agent maken op basis van het toegangstoken voor gebruikers

Met een gebruiker-token kan een geverifieerde aanroepagent worden gemaakt. Over het algemeen wordt dit token gegenereerd op basis van een service met een specifieke verificatie voor de toepassing. Raadpleeg de handleiding over tokens voor gebruikerstoegang voor meer informatie over dit onderwerp.

Voor de quickstart vervangt u <User_Access_Token> door een gebruikerstoegangstoken dat voor uw Azure Communication Service-resource is gegenereerd.

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

Een aanroep starten met behulp van de aanroepagent

U kunt bellen via de agent voor oproepen. Hiervoor moet u alleen een lijst met id's van personen die worden gebeld en de opties voor bellen opgeven. Voor de quickstart worden de standaardopties voor oproepen zonder video en één id van een persoon die wordt gebeld uit de tekstinvoer gebruikt.

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

De app starten en de Echo-bot aanroepen

De app kan nu worden gestart met behulp van de knop App uitvoeren op de werkbalk (Shift + F10). Roep 8:echo123 aan om te controleren of u aanroepen kunt plaatsen. Er wordt een vooraf opgenomen bericht afgespeeld en vervolgens wordt uw bericht aan u herhaald.

In deze quickstart leert u hoe u een aanroep start met behulp van de Azure Communication Services Calling SDK voor iOS.

Voorbeeldcode

U kunt de voorbeeld-app downloaden van GitHub.

Vereisten

Voor het voltooien van deze zelfstudie moet aan de volgende vereisten worden voldaan:

• Een Azure-account met een actief abonnement. Gratis een account maken
• Een Mac waarop Xcode wordt uitgevoerd, evenals een geldig ontwikkelaarscertificaat dat is geïnstalleerd in uw Sleutelhanger.
• Een gebruikte Communication Services-resource. Een Communication Services maken.
• Een Token voor gebruikerstoegang voor uw Azure Communication Service.

Instellen

Het Xcode-project maken

Maak in Xcode een nieuw iOS-project en selecteer de sjabloon Single View-app (Toepassing met één weergave). In deze zelfstudie wordt gebruikgemaakt van het SwiftUI-framework. U moet dus de taal instellen op Swift en de gebruikersinterface op SwiftUI. Tijdens deze quickstart maakt u geen tests. U kunt Tests opnemen uitschakelen.

Installeer het pakket en de afhankelijkheden met CocoaPods

1. Als u een Podfile voor uw toepassing wilt maken, opent u de terminal en navigeert u naar de projectmap en voer u het volgende uit:

   pod init

2. Voeg de volgende code toe aan de Podfile en sla deze op (zorg ervoor dat 'doel' overeenkomt met de naam van uw project):

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

3. Voer pod install uit.

4. Open de .xcworkspace met Xcode.

Toegang tot de microfoon aanvragen

Als u toegang wilt krijgen tot de microfoon van het apparaat, moet u de eigenschappenlijst van de app bijwerken met een NSMicrophoneUsageDescription. U stelt de bijbehorende waarde in op een string die wordt opgenomen in het dialoogvenster dat het systeem gebruikt om toegang te vragen aan de gebruiker.

Klik met de rechtermuisknop op de Info.plist-vermelding van de projectstructuur en selecteer Open As > Source Code. Voeg de volgende regels toe in de bovenste sectie <dict> en sla het bestand op.

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

Het app-framework instellen

Open het bestand ContentView.swift van het project en voeg boven aan het bestand een import-declaratie toe om de AzureCommunicationCalling libraryte importeren. Bovendien moet u AVFoundation importeren, we hebben dit nodig voor het aanvragen van audio-toestemming in de code.

import AzureCommunicationCalling
import AVFoundation

Vervang de implementatie van de ContentView-struct door enkele eenvoudige UI-besturingselementen waarmee een gebruiker een oproep kan initiëren en beëindigen. We voegen bedrijfslogica toe aan deze besturingselementen in deze snelstart.

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
    }
}

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Calling SDK:

Naam	Beschrijving
CallClient	De CallClient is het belangrijkste toegangspunt voor de aanroepende SDK.
CallAgent	De CallAgent wordt gebruikt om oproepen te starten en te beheren.
CommunicationTokenCredential	CommunicationTokenCredential wordt gebruikt als tokenreferentie om de CallAgent te instanteren.
CommunicationUserIdentifier	De CommunicationUserIdentifier wordt gebruikt om de identiteit van de gebruiker aan te geven. Dit kan een van de volgende zijn: CommunicationUserIdentifier/PhoneNumberIdentifier/CallingApplication.

De client verifiëren

Initialiseer een CallAgent-instantie met een token voor gebruikerstoegang waarmee we oproepen kunnen maken en ontvangen.

In de volgende code moet u vervangen door een geldig token voor <USER ACCESS TOKEN> gebruikerstoegang voor uw resource. Raadpleeg de documentatie inzake Token voor gebruikerstoegang als u nog geen token hebt.

Voeg de volgende code toe aan de onAppear-call back in 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.")
    }
}

Een oproep starten

De startCall methode wordt ingesteld als de actie die wordt uitgevoerd wanneer op de knop Oproep starten wordt getikt. Werk de implementatie bij om een oproep te starten met de 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")
                }
            }
        }
    }
}

U kunt ook de eigenschappen in StartCallOptions gebruiken om de initiële opties voor de oproep in te stellen (dat wil zeggen dat de oproep kan worden gestart met de microfoon gedempt).

Een oproep beëindigen

Implementeer de endCall-methode om de huidige oproep te beëindigen wanneer op de knop voor Oproep beëindigen wordt getikt.

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

De code uitvoeren

U kunt uw app maken en uitvoeren op een iOS-simulator door Product > Uitvoeren te selecteren of door de sneltoets (⌘-R) te gebruiken.

U kunt een uitgaande VOIP-oproep maken door een gebruikers-ID op te geven in het tekstveld en te tikken op de knop Oproep starten. Door 8:echo123 te bellen, wordt u verbonden met een echo-bot. Dit is handig om aan de slag te gaan en te controleren of uw audio-apparaten werken.