Rychlý start: Přidání hlasového hovory do aplikace

Začínáme s Azure Communication Services pomocí sady SDK volání Communication Services k přidání hlasového a videohooku do vaší aplikace.

Důležité

Do 31. Azure Communication Services 31. července 2021 upgradujte na sadu SDK volání služby 1.1.0 (nebo novější) pro JavaScript.

Rozhraní API protokolu SDP (Plan B Session Description Protocol) je zastaralé. Communication Services Do 31. července 2021 aktualizujte své 31. července 2021 své hovory na verzi 1.1.0 (nebo novější), abyste zabránili tomu, že toto vyněcování ovlivní vaše uživatele. Další informace najdete v poznámkách k verzi volající knihovny.

Důležité

Komunikační služby Azure nepodporují nouzové volání.

Služby odchozího hlasového volání služby Azure Communication Services se nedají použít ke kontaktování tísňových služeb. Měli byste udržovat tradiční telefonní službu pro zajištění tísňového volání.

V tomto rychlém startu se dozvíte, jak zahájit volání pomocí sady SDK volání Azure Communication Services volání pro Windows.

Příklad kódu

Ukázkovou aplikaci si můžete stáhnout z GitHubu.

Požadavky

K dokončení tohoto kurzu budete potřebovat následující požadavky:

Nastavení

Vytvoření projektu

V Visual Studio pomocí šablony Prázdná aplikace (Universal Windows) vytvořte nový projekt a nastavte jedno stránkovou aplikaci pro Univerzální platformu Windows platformy (UPW).

Snímek obrazovky s oknem Project v rámci Visual Studio

Instalace balíčku

Klikněte pravým tlačítkem na projekt a přejděte na Manage Nuget Packages a nainstalujte Azure.Communication.Calling .

Vyžádání přístup

Přejděte na a Package.appxmanifest klikněte na Capabilities . Zkontrolujte, Internet (Client & Server) že chcete získat příchozí a odchozí přístup k internetu. Zkontrolujte, Microphone že chcete získat přístup ke zvukovému kanálu mikrofonu.

Snímek obrazovky s žádostí o přístup k internetu a mikrofonu Visual Studio

Nastavení architektury aplikace

Potřebujeme nakonfigurovat základní rozložení pro připojení naší logiky. K tomu, abychom mohli použít odchozí volání, potřebujeme k poskytnutí ID uživatele TextBox volaně. Potřebujeme také Start Call tlačítko a Hang Up tlačítko. Otevřete MainPage.xaml projekt a přidejte StackPanel uzel do : 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>

Otevřete a MainPage.xaml.cs nahraďte obsah následující implementací:

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

Objektový model

Následující třídy a rozhraní zvládá některé hlavní funkce sady SDK Azure Communication Services volání:

Název Popis
CallClient CallClient je hlavní vstupní bod do sady SDK pro volání.
Agent volání CallAgent slouží ke spuštění a správě volání.
CommunicationTokenCredential CommunicationTokenCredential slouží jako přihlašovací údaje tokenu k vytvoření instance CallAgent.
CommunicationUserIdentifier CommunicationUserIdentifier slouží k reprezentaci identity uživatele, která může být jednou z následujících: CommunicationUserIdentifier/PhoneNumberIdentifier/CallingApplication.

Ověření klienta

CallAgentInicializovat instanci pomocí přístupového tokenu uživatele, který nám umožní provádět a přijímat volání.

V následujícím kódu nahraďte <USER_ACCESS_TOKEN> tokenem USER Access Token. Pokud ještě token nemáte k dispozici, přečtěte si dokumentaci k přístupového tokenu uživatele.

Do funkce přidejte následující InitCallAgent kód.

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

Zahájení hovoru

Přidejte implementaci do pro CallButton_ClickAsync zahájení volání s objektem , který jsme call_agent vytvořili.

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

Ukončení volání

Ukončí aktuální volání po Hang Up kliknutí na tlačítko.

await call_.HangUpAsync(new HangUpOptions());

Spuštění kódu

Kód můžete sestavit a spustit na Visual Studio. Upozorňujeme, že pro platformy řešení podporujeme ARM64 a x64 x86 .

Odchozí volání můžete provést tak, že do textového pole poskytnete ID uživatele a kliknete na Start Call tlačítko. Volání vás propojte s echo botem. To je skvělé pro začátek a ověření, že vaše zvuková 8:echo123 zařízení fungují.

Snímek obrazovky znázorňující spuštění aplikace pro rychlý start

V tomto rychlém startu se dozvíte, jak zahájit volání pomocí sady SDK Azure Communication Services volání pro JavaScript.

Ukázka kódu

Ukázkovou aplikaci si můžete stáhnout z Githubu.

Požadavky

Nastavení

Vytvoření nové aplikace Node.js

Otevřete terminál nebo příkazové okno a vytvořte nový adresář pro vaši aplikaci a přejděte do něj.

mkdir calling-quickstart && cd calling-quickstart

Spuštěním npm init -y vytvořte souborpackage.js s výchozím nastavením.

npm init -y

Instalace balíčku

Pomocí příkazu npm install nainstalujte sadu SDK volání Azure Communication Services pro JavaScript.

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

Pro tento rychlý start se doporučují následující verze webpacku:

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

Možnost --save vypíše knihovnu jako závislost v souboru package.json.

Nastavení architektury aplikace

V tomto rychlém startu se k vytvoření sady prostředků aplikace používá webpack. Spuštěním následujícího příkazu nainstalujte balíčky npm webpack, webpack-cli a webpack-dev-server a vypište je jako vývojové závislosti ve vašem package.jsna:

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

Vytvořte soubor index.html v kořenovém adresáři projektu. Tento soubor použijeme ke konfiguraci základního rozložení, které uživateli umožní volání.

Tady je kód:

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

V kořenovém adresáři projektu vytvořte soubor s názvem client.js, který bude obsahovat logiku aplikace pro tento rychlý start. Přidejte následující kód pro import volajícího klienta a získání odkazů na elementy modelu DOM, abychom mohli připojit obchodní logiku.

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

Objektový model

Následující třídy a rozhraní zvládá některé hlavní funkce sady SDK Azure Communication Services volání:

Název Description
CallClient CallClient je hlavní vstupní bod do volající sady SDK.
Agent volání CallAgent slouží ke spuštění a správě volání.
AzureCommunicationTokenCredential Třída AzureCommunicationTokenCredential implementuje rozhraní CommunicationTokenCredential, které se používá k vytvoření instance třídy CallAgent.

Ověření klienta

Do textového pole musíte zadat platný přístupový token uživatele pro váš prostředek a kliknout na Odeslat. Pokud ještě token nemáte k dispozici, přečtěte si dokumentaci k přístupového tokenu uživatele. Pomocí CallClient inicializovat instanci s , která nám umožní provádět a CallAgent CommunicationTokenCredential přijímat volání.

Do souboru přidejte následující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!");
    }
})

Zahájení hovoru

Přidejte obslužnou rutinu události, která zahájí volání callButton po kliknutí na objekt :

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

Ukončení volání

Přidáním naslouchacího procesu událostí ukončíte aktuální volání po hangUpButton kliknutí na :

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

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

Vlastnost forEveryone ukončí volání pro všechny účastníky volání.

Spuštění kódu

K webpack-dev-server sestavení a spuštění aplikace použijte . Spuštěním následujícího příkazu zabalte hostitele aplikace na místním webovém serveru:

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

Otevřete prohlížeč a přejděte na http://localhost:8080/ . Měli byste vidět následující:

Snímek obrazovky s dokončenou javascriptovou aplikací

Odchozí volání VOIP můžete provést tak, že do odpovídajících textových polí poskytnete platný přístupový token uživatele a ID uživatele a kliknete na tlačítko Spustit volání.

Volání vás propojte s echo botem. To je skvělé pro začátek a ověření, že vaše zvuková 8:echo123 zařízení fungují. Předejte {id: '8:echo123'} do rozhraní API CallAgent.startCall() pro volání echobotu. Pokud chcete volat komunikačního uživatele služby ACS, {communicationUserId: 'ACS_USER_ID'} předejte ho rozhraní CallAgent.startCall() API.

V tomto rychlém startu se dozvíte, jak zahájit volání pomocí sady SDK volání Azure Communication Services pro Android.

Příklad kódu

Ukázkovou aplikaci si můžete stáhnout z GitHubu.

Požadavky

Nastavení

Vytvoření aplikace pro Android s prázdnou aktivitou

V Android Studio vyberte Spustit nový projekt Android Studio projektu.

Snímek obrazovky s tlačítkem Android Studio Project nový nový projekt vybraným v Android Studio

V části Telefon a Tablet vyberte šablonu projektu Prázdná aktivita.

Snímek obrazovky znázorňující vybranou možnost Prázdná aktivita na Project šablony

Vyberte Minimální sada SDK pro "API 26: Android 8.0 (Oreo)" nebo vyšší.

Snímek obrazovky znázorňující vybranou možnost Prázdná aktivita na Project šablona 2

Instalace balíčku

Vyhledejte soubor build.gradle na úrovni projektu a nezapomeňte ho přidat do seznamu úložišť v části a . mavenCentral() buildscript``allprojects

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

Pak do souboru build.gradle na úrovni modulu přidejte následující řádky do oddílů dependencies a 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'
    ...
}

Přidání oprávnění k manifestu aplikace

Aby bylo možné požádat o oprávnění požadovaná k volání, musí být nejprve deklarována v manifestu aplikace ( app/src/main/AndroidManifest.xml ). Obsah souboru nahraďte následujícím kódem:

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

Nastavení rozložení aplikace

Jsou potřeba dva vstupy: textový vstup pro ID volaně a tlačítko pro umístění volání. Můžete je přidat prostřednictvím návrháře nebo úpravou xml rozložení. Vytvořte tlačítko s ID call_button a textovým vstupem callee_id . Přejděte na ( app/src/main/res/layout/activity_main.xml ) a nahraďte obsah souboru následujícím kódem:

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

Vytvoření hlavního generování uživatelského rozhraní a vazeb aktivit

S vytvořeným rozložením je možné přidat vazby a také základní generování aktivit. Aktivita bude zpracovávat vyžádání oprávnění modulu runtime, vytvoření agenta volání a umístění volání při stisknutí tlačítka. Každý z nich bude pokrytý ve své vlastní části. Metoda se přepíše tak, aby se volala, a také přidá onCreate getAllPermissions vazby pro tlačítko createAgent volání. K tomu dojde pouze jednou při vytvoření aktivity. Další informace o najdete v onCreate příručce Principy životního cyklu aktivit.

Přejděte na MainActivity.java a nahraďte obsah následujícím kódem:

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

Vyžádání oprávnění za běhu

Pro Android 6.0 a vyšší (úroveň rozhraní API 23) a 23 nebo vyšší se oprávnění přidělí za běhu místo instalace targetSdkVersion aplikace. Aby to bylo možné podporovat, getAllPermissions je možné implementovat volání a pro každé požadované ActivityCompat.checkSelfPermission ActivityCompat.requestPermissions oprávnění.

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

Poznámka

Při navrhování aplikace zvažte, kdy je třeba o tato oprávnění požádat. Oprávnění by se měla vyžádat podle potřeby, nikoli předem. Další informace najdete v průvodci oprávněními Androidu.

Objektový model

Následující třídy a rozhraní zvládá některé hlavní funkce sady SDK Azure Communication Services volání:

Název Description
CallClient CallClient je hlavní vstupní bod do sady SDK pro volání.
Agent volání CallAgent slouží ke spuštění a správě volání.
CommunicationTokenCredential CommunicationTokenCredential slouží jako přihlašovací údaje tokenu k vytvoření instance CallAgent.
Identifikátor komunikace Parametr CommunicationIdentifier se používá jako jiný typ účastníka, který by mohl být součástí volání.

Vytvoření agenta z přístupového tokenu uživatele

Pomocí tokenu uživatele je možné vytvořit instanci ověřeného agenta volání. Tento token se obvykle vygeneruje ze služby s ověřováním specifickým pro aplikaci. Další informace o přístupových tokenech uživatelů najdete v příručce Přístupové tokeny uživatelů.

Pro rychlý start nahraďte <User_Access_Token> tokenem přístupu uživatele vygenerovaný pro váš prostředek služby Azure Communication Service.


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

Zahájení hovoru pomocí agenta volání

Volání lze provést prostřednictvím agenta volání a vyžaduje pouze poskytnutí seznamu volaně ID a možností volání. Pro rychlý start se použije výchozí možnosti volání bez videa a jedno ID volaného z textového vstupu.

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

Spusťte aplikaci a zavolejte echo bota.

Aplikaci teď můžete spustit pomocí tlačítka Spustit aplikaci na panelu nástrojů (Shift+F10). Ověřte, že můžete volání umístit voláním 8:echo123 . Přehraje se předem zaznamenaná zpráva a pak se zpráva zopakuje.

Snímek obrazovky zobrazující dokončenou aplikaci

V tomto rychlém startu se dozvíte, jak zahájit volání pomocí sady SDK Azure Communication Services volání pro iOS.

Příklad kódu

Ukázkovou aplikaci si můžete stáhnout z GitHubu.

Požadavky

K dokončení tohoto kurzu budete potřebovat následující požadavky:

Nastavení

Vytvoření projektu Xcode

V Xcode vytvořte nový projekt pro iOS a vyberte šablonu Aplikace s jedním zobrazením. V tomto kurzu se používá rozhraní SwiftUI,takže byste měli jazyk nastavit na Swift a Uživatelské rozhraní na SwiftUI. Během tohoto rychlého startu nevytváříte testy. Můžete zrušit zaškrtnutí políčka Zahrnout testy.

Snímek obrazovky s oknem Project v rámci Xcode

Instalace balíčku a závislostí pomocí CocoaPods

  1. Pokud chcete vytvořit soubor Podfile pro vaši aplikaci, otevřete terminál, přejděte do složky projektu a spusťte:

    pod init

  2. Do souboru Podfile přidejte následující kód a uložte ho (ujistěte se, že "target" odpovídá názvu vašeho projektu):

    platform :ios, '13.0'
    use_frameworks!
    
    target 'AzureCommunicationCallingSample' do
      pod 'AzureCommunicationCalling', '~> 1.0.0'
    end
    
  3. Spusťte pod install.

  4. Otevřete soubor .xcworkspace pomocí Xcode.

Vyžádání přístupu k mikrofonu

Pokud chcete získat přístup k mikrofonu zařízení, musíte aktualizovat seznam vlastností informací vaší aplikace pomocí NSMicrophoneUsageDescription . Přidruženou hodnotu nastavíte na , která se zahrne do dialogového okna, které systém používá k vyžádání string přístupu od uživatele.

Klikněte pravým tlačítkem Info.plist na položku ve stromu projektu a vyberte Open As Source Code (Otevřít jako zdrojový > kód). Do části nejvyšší úrovně přidejte následující řádky a <dict> pak soubor uložte.

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

Nastavení architektury aplikace

Otevřete soubor ContentView.swift vašeho projektu a přidejte deklaraci na začátek souboru pro import import souboru AzureCommunicationCalling library . Kromě toho AVFoundation naimportujte , budeme ho potřebovat pro žádost o oprávnění ke zvuku v kódu.

import AzureCommunicationCalling
import AVFoundation

Nahraďte implementaci struktury některými jednoduchými ovládacími prvky uživatelského rozhraní, které umožňují uživateli ContentView zahájit a ukončit volání. V tomto rychlém startu k těmto ovládacím prvkům připojíme obchodní logiku.

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

Objektový model

Následující třídy a rozhraní zvládá některé z hlavních funkcí sady SDK Azure Communication Services volání:

Název Popis
CallClient CallClient je hlavní vstupní bod do sady SDK pro volání.
Agent volání CallAgent slouží ke spuštění a správě volání.
CommunicationTokenCredential CommunicationTokenCredential slouží jako přihlašovací údaje tokenu k vytvoření instance CallAgent.
CommunicationUserIdentifier CommunicationUserIdentifier slouží k reprezentaci identity uživatele, která může být jednou z následujících: CommunicationUserIdentifier/PhoneNumberIdentifier/CallingApplication.

Ověření klienta

CallAgentInicializovat instanci pomocí přístupového tokenu uživatele, který nám umožní provádět a přijímat volání.

V následujícím kódu budete muset nahradit platným přístupovým tokenem uživatele <USER ACCESS TOKEN> pro váš prostředek. Pokud ještě token nemáte k dispozici, přečtěte si dokumentaci k přístupového tokenu uživatele.

Do zpětného volání v onAppear ContentView.swift přidejte následující kód:

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.")
    }
}

Zahájení hovoru

Metoda startCall je nastavená jako akce, která se provede při poklepu na tlačítko Spustit volání. Aktualizujte implementaci tak, aby svolala volání pomocí 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")
                }
            }
        }
    }
}

Vlastnosti v souboru můžete použít také k nastavení počátečních možností volání (tj. umožňuje spuštění volání s StartCallOptions ztlumeným mikrofonem).

Ukončení volání

Implementujte metodu , která při poklepu na tlačítko Ukončit volání ukončí endCall aktuální volání.

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

Spuštění kódu

Aplikaci můžete sestavit a spustit na simulátoru iOS tak, že vyberete Product Run (Spuštění produktu) nebo pomocí klávesové > zkratky (⌘-R).

Konečný vzhled a vzhled aplikace pro rychlý start

Odchozí volání VOIP můžete provést tak, že do textového pole poskytnete ID uživatele a klepnete na tlačítko Spustit volání. Volání vás propojte s echo botem. To je skvělé pro začátek a ověření, že vaše zvuková 8:echo123 zařízení fungují.

Poznámka

Při prvním volání vás systém vyzve k zadání přístupu k mikrofonu. V produkční aplikaci byste měli pomocí rozhraní API zkontrolovat stav oprávnění a řádně aktualizovat chování aplikace v případě, že oprávnění AVAudioSession není uděleno.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Communication Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené. Přečtěte si další informace o vyčištění prostředků.

Další kroky

Další informace najdete v následujících článcích: