Rychlý Start: Přidání hlasového volání do aplikace

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:

• Účet Azure s aktivním předplatným. Vytvořte si účet zdarma.
• Nainstalujte Visual Studio 2019 s úlohou Vývoje univerzální Windows platformy.
• Nasazený Communication Services prostředek. Vytvořte prostředek Communication Services .
• Přístupový token uživatele pro službu Azure Communication Service.

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

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.

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í.

V tomto rychlém startu se dozvíte, jak spustit volání pomocí komunikačních služeb Azure, které volají sadu SDK pro JavaScript.

Ukázka kódu

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

Požadavky

• Účet Azure s aktivním předplatným. Vytvořte si účet zdarma.
• Node.js Aktivní LTS a verze LTS údržby (Doporučené 8.11.1 a 10.14.1).
• Aktivní prostředek služby Communication Services. Vytvořte prostředek služby Communications.
• Přístupový token uživatele pro vytvoření instance klienta volání. Naučte se vytvářet a spravovat tokeny přístupu uživatelů.

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í.

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

Vytvořte soubor v kořenovém adresáři vašeho projektu s názvem client.js , který bude obsahovat aplikační logiku pro tento rychlý Start. Přidejte následující kód pro import volajícího klienta a získejte odkazy na prvky modelu DOM, abychom mohli připojit naši 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í zpracovávají některé hlavní funkce volání sady SDK služby Azure Communications:

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

Ověření klienta

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

Přidejte následující kód pro 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!");
    }
})

Spustit volání

Přidejte obslužnou rutinu události pro zahájení volání při callButton kliknutí na tlačítko:

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řidat naslouchací proces události pro ukončení aktuálního volání při kliknutí na hangUpButton tlačítko:

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

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

forEveryoneVlastnost ukončí volání všech účastníků volání.

Spuštění kódu

Použijte webpack-dev-server k sestavení a spuštění vaší aplikace. Spusťte následující příkaz pro vytvoření balíčku aplikace Host na místní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í:

Odchozí volání VOIP můžete vytvořit zadáním platného uživatelského tokenu přístupu a ID uživatele v odpovídajících textových polích a kliknutím na tlačítko Spustit volání .

Volání se 8:echo123 připojí ke robotu s odezvou. to je skvělé pro začátek a ověření, jestli vaše zvuková zařízení fungují. Předejte {id: '8:echo123'} rozhraní API CallAgent. startCall () a zavolejte echobot. Pokud chcete zavolat uživatele komunikace ACS, předejte {communicationUserId: 'ACS_USER_ID'} CallAgent.startCall() rozhraní API.

V tomto rychlém startu se dozvíte, jak spustit volání pomocí komunikačních služeb Azure, které volají sadu SDK pro Android.

Příklad kódu

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

Požadavky

• Účet Azure s aktivním předplatným. Vytvořte si účet zdarma.
• Android Studiopro vytváření aplikací pro Android.
• Nasazený prostředek komunikačních služeb. Vytvořte prostředek služby Communications.
• Přístupový token uživatele pro komunikační službu Azure

Nastavení

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

V Android Studio vyberte spustit nový projekt Android Studio.

v části Telefon a Tablet vyberte šablonu projektu "prázdná aktivita".

Vyberte minimální sadu SDK rozhraní API 26: Android 8,0 (Oreo) nebo vyšší.

Instalace balíčku

Vyhledejte na úrovni projektu Build. Gradle a ujistěte se, že jste přidali mavenCentral() do seznamu úložišť v části buildscript a. allprojects

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

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

Pak v sestavení na úrovni modulu přidejte následující řádky do částí závislosti a Androidu.

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á pro volání, musí být nejprve deklarována v manifestu aplikace ( app/src/main/AndroidManifest.xml ). Obsah souboru nahraďte následujícím:

    <?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 vyžadovány dva vstupy: textový vstup pro ID volaného a tlačítko pro vložení volání. Ty lze přidat prostřednictvím návrháře nebo úpravou XML rozložení. Vytvoří tlačítko s ID call_button a textovým zadáním callee_id . Přejděte na ( app/src/main/res/layout/activity_main.xml ) a nahraďte obsah souboru následujícím:

<?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í generování a vazeb hlavní aktivity aktivity

Pomocí rozložení vytvořené vazby je možné přidat a také základní generování uživatelského rozhraní aktivity. Aktivita bude zpracovávat požadavky na běhová oprávnění, vytvoření agenta volání a umístění volání při stisknutí tlačítka. Každá z nich bude zahrnuta do vlastní části. onCreateMetoda bude přepsána k vyvolání getAllPermissions a createAgent také k přidání vazeb pro tlačítko volání. K tomu dojde pouze jednou při vytvoření aktivity. Další informace o nástroji onCreate najdete v příručce pro pochopení ž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
    }
}

Požádat o oprávnění za běhu

Pro Android 6,0 a vyšší (úroveň rozhraní API 23) a targetSdkVersion 23 nebo vyšší se oprávnění udělují za běhu, a ne po instalaci aplikace. Aby to bylo možné podporovat, getAllPermissions lze implementovat volání ActivityCompat.checkSelfPermission a ActivityCompat.requestPermissions pro každé požadované 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);
    }
}

Objektový model

Následující třídy a rozhraní zpracovávají některé hlavní funkce volání sady SDK služby Azure Communications:

Název	Description
CallClient	CallClient je hlavní vstupní bod pro volání sady SDK.
CallAgent	CallAgent se používá ke spouštění a správě volání.
CommunicationTokenCredential	CommunicationTokenCredential se používá jako přihlašovací údaje tokenu pro vytvoření instance CallAgent.
CommunicationIdentifier	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

S uživatelským tokenem může být vytvořena instance ověřeného agenta volání. Obecně se tento token vygeneruje ze služby s ověřováním specifickým pro aplikaci. Další informace o tokenech přístupu uživatele najdete v příručce k uživatelským tokenům .

V případě rychlého startu nahraďte <User_Access_Token> uživatelským tokenem, který jste vygenerovali 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();
    }
}

Spuštění volání pomocí agenta volání

Umístění volání lze provést prostřednictvím agenta volání a stačí pouze poskytnout seznam ID volaný a možnosti volání. Pro rychlý Start se použije výchozí možnosti volání bez videa a jedno volané ID 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 robota s odezvou.

Aplikaci teď můžete spustit pomocí tlačítka Spustit aplikaci na panelu nástrojů (Shift + F10). Ověřte, že je možné volat voláním 8:echo123 . Předem zaznamenaná zpráva se spustí a znovu se vrátí zpět na vaši zprávu.

V tomto rychlém startu se dozvíte, jak spustit volání pomocí komunikačních služeb Azure, které volají sadu SDK 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:

• Účet Azure s aktivním předplatným. Vytvořte si účet zdarma.
• Počítač Mac se systémem Xcodespolu s platným certifikátem pro vývojáře nainstalovaným do řetězce klíčů.
• Nasazený prostředek komunikačních služeb. Vytvořte prostředek služby Communications.
• Přístupový token uživatele pro komunikační službu Azure

Nastavení

Vytvoření projektu Xcode

V Xcode vytvořte nový projekt iOS a vyberte šablonu aplikace s jedním zobrazením . V tomto kurzu se používá SwiftUI Framework, takže byste měli nastavit jazyk na SWIFT a uživatelské rozhraní SwiftUI. V tomto rychlém startu nebudete vytvářet testy. Můžete si klidně zrušit kontrolu včetně testů.

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

1. Chcete-li vytvořit souboru podfile pro vaši aplikaci, otevřete terminál a přejděte do složky projektu a spusťte příkaz:

   pod init

2. Přidejte následující kód do souboru podfile a uložte (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 .xcworkspace s Xcode.

Požádat o přístup k mikrofonu

Aby bylo možné získat přístup k mikrofonu zařízení, je třeba aktualizovat seznam vlastností informací o aplikaci pomocí NSMicrophoneUsageDescription . Nastavili jste přidruženou hodnotu na string , která bude obsažena v dialogovém okně, které systém používá k vyžádání přístupu od uživatele.

Klikněte pravým tlačítkem myši na Info.plist položku stromové struktury projektu a vyberte Otevřít jako > zdrojový kód. Přidejte následující řádky do části nejvyšší úrovně <dict> a pak soubor uložte.

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

Nastavení aplikační architektury

Otevřete soubor contentView. SWIFT projektu a přidejte import do horní části souboru deklaraci, která se má importovat AzureCommunicationCalling library . Kromě toho AVFoundation budeme v kódu potřebovat pro žádost o oprávnění ke zvuku.

import AzureCommunicationCalling
import AVFoundation

Nahraďte implementaci ContentView struktury některými jednoduchými ovládacími prvky uživatelského rozhraní, které umožní uživateli iniciovat a ukončit volání. K těmto ovládacím prvkům v tomto rychlém startu budeme připojovat 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í zpracovávají některé hlavní funkce volání sady SDK služby Azure Communications:

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

Ověření klienta

Inicializujte CallAgent instanci pomocí přístupového tokenu uživatele, který nám umožní přijmout a přijímat volání.

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

Do onAppear zpětného volání v 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.")
    }
}

Spustit volání

startCallMetoda je nastavena jako akce, která bude provedena při klepnutí na tlačítko Spustit volání . Aktualizujte implementaci a spusťte volání s 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")
                }
            }
        }
    }
}

Můžete také použít vlastnosti v nástroji StartCallOptions k nastavení počátečních možností pro volání (to znamená, že umožňuje spuštění volání s neztlumeným mikrofonem).

Ukončení volání

Implementujte endCall metodu pro ukončení aktuálního volání při klepnutí na tlačítko Ukončit 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

Můžete sestavit a spustit aplikaci v simulátoru iOS tak, že vyberete možnost > spuštění produktu nebo pomocí klávesové zkratky (⌘-R).

Odchozí volání VOIP můžete vytvořit zadáním ID uživatele v textovém poli a klepnutím na tlačítko Spustit volání . Volání se 8:echo123 připojí ke robotu s odezvou. to je skvělé pro začátek a ověření, jestli vaše zvuková zařízení fungují.