Správa hovorů

Tento článek popisuje, jak spravovat volání pomocí sady SDK pro volání služeb Azure Communication Services. Témata zahrnují, jak provádět hovory, spravovat účastníky a spravovat nastavení.

Požadavky

• Účet Azure s aktivním předplatným. Vytvoření účtu zdarma
• Nasazený prostředek služeb komunikace. Vytvořte prostředek Komunikační služby.
• A User Access Token, aby bylo možné aktivovat klienta pro volání. Další informace o tom, jak získat User Access Token.
• Volitelné: Dokončete zahájení přidávání volání do aplikace.

Technická podpora

Následující tabulky definují podporu oddělených místností ve službě Azure Communication Services.

Identity a typy volání

Následující tabulka uvádí podporu funkcí pro konkrétní typ volání a identitu.

Identity	Schůzka v Microsoft Teams	Místnost	1:1 hovor	Skupinový hovor	1:1 interoperabilní hovor v Teams	Skupinový hovor pro interoperabilitu v aplikaci Teams
Uživatel komunikačních služeb	✔️	✔️	✔️	✔️	✔️	✔️
Uživatel Microsoftu 365	✔️				✔️	✔️

Operace

Následující tabulka ukazuje podporu jednotlivých rozhraní API v sadě SDK volání související s jednotlivými typy identit.

Operace	Uživatel komunikačních služeb	Uživatel Microsoftu 365
Zahájení volání pro uživatele komunikačních služeb	✔️
Zahájení hovoru s uživatelem Microsoftu 365	✔️	✔️
Zahájení hovoru na telefonní číslo	✔️	✔️
Připojte se k místnosti	✔️
Připojte se ke schůzce Teams	✔️	✔️
Připojte se k hovoru na základě ID skupiny	✔️
Přijetí nebo odmítnutí příchozího hovoru	✔️	✔️
Blokování a obnovení hovoru	✔️	✔️
Získejte účastníky	✔️	✔️
Přidání uživatele komunikačních služeb	✔️
Odebrání uživatele služby Communication Services	✔️	✔️
Přidání nebo odebrání uživatele Microsoftu 365	✔️	✔️
Přidání nebo odebrání telefonního čísla	✔️	✔️
Vypnutí nebo zapnutí zvuku vzdáleného účastníka	✔️ [1]	✔️ [1]
Zavěsit	✔️	✔️
Ukončení hovoru pro všechny	✔️ [2]	✔️

[1] Rozhraní API je podporováno pouze ve skupinových hovorech, místnostech a schůzkách Teams. [2] V místnostech není rozhraní API podporováno.

SDK

Následující tabulky ukazují podporu funkcí v jednotlivých sadách SDK služby Azure Communication Services.

Stav podpory	Webová stránka	Webové uživatelské rozhraní	Ios	Uživatelské rozhraní iOS	Android	Uživatelské rozhraní Androidu	Windows
Je podporováno.	✔️	✔️	✔️	✔️	✔️	✔️	✔️

Nainstalujte sadu SDK .

Pomocí npm install příkazu nainstalujte Azure Communication Services Common and Calling SDK pro JavaScript:

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

Inicializace požadovaných objektů

Pro většinu volacích operací se vyžaduje instance. Když vytvoříte novou CallClient instanci, můžete ji nakonfigurovat s vlastními možnostmi, jako je Logger instance.

Pomocí instance CallClient můžete vytvořit instanci CallAgent voláním createCallAgent. Tato metoda asynchronně vrátí CallAgent objekt instance.

Metoda createCallAgent používá CommunicationTokenCredential jako argument. Přijímá přístupový token uživatele.

Metodu getDeviceManager můžete použít na instanci CallClient pro přístup k deviceManager.

const { CallClient } = require('@azure/communication-calling');
const { AzureCommunicationTokenCredential} = require('@azure/communication-common');
const { AzureLogger, setLogLevel } = require("@azure/logger");

// Set the logger's log level
setLogLevel('verbose');

// Redirect log output to console, file, buffer, REST API, or whatever location you want
AzureLogger.log = (...args) => {
    console.log(...args); // Redirect log output to console
};

const userToken = '<USER_TOKEN>';
callClient = new CallClient(options);
const tokenCredential = new AzureCommunicationTokenCredential(userToken);
const callAgent = await callClient.createCallAgent(tokenCredential, {displayName: 'optional Azure Communication Services user name'});
const deviceManager = await callClient.getDeviceManager()

Správa připojení sady SDK k infrastruktuře Microsoftu

Tato Call Agent instance vám pomůže spravovat hovory (pro připojení nebo zahájení hovorů). Aby bylo možné pracovat s vaší sadou SDK volání, musí se připojit k infrastruktuře Microsoftu, aby bylo možné dostávat oznámení o příchozích hovorech a koordinovat další podrobnosti volání. Vaše Call Agent má dva možné stavy:

Připojeno – Call Agent Hodnota connectionStatue znamená, Connected že klientská sada SDK je připojená a dokáže přijímat oznámení z infrastruktury Microsoftu.

Odpojeno – Hodnota ukazatele připojení Call Agent indikuje, že existuje problém, který brání sadě SDK ve správném připojení. Call Agent by mělo být znovu vytvořeno.

• invalidToken: Pokud vypršela platnost tokenu nebo je neplatná Call Agent instance, odpojí se s touto chybou.
• connectionIssue: Pokud dojde k problému s klientem, který se připojuje k infrastruktuře Microsoftu, po mnoha opakovaných pokusech Call Agent zveřejní chybu connectionIssue.

Zkontrolujte, jestli je vaše místní Call Agent infrastruktura připojená k infrastruktuře Microsoftu, a to kontrolou aktuální hodnoty connectionState vlastnosti. Během aktivního volání můžete naslouchat události connectionStateChanged a zjistit, zda se Call Agent změní ze stavu Připojeno do Odpojeno.

const connectionState = callAgentInstance.connectionState;
console.log(connectionState); // it may return either of 'Connected' | 'Disconnected'

const connectionStateCallback = (args) => {
    console.log(args); // it will return an object with oldState and newState, each of having a value of either of 'Connected' | 'Disconnected'
    // it will also return reason, either of 'invalidToken' | 'connectionIssue'
}
callAgentInstance.on('connectionStateChanged', connectionStateCallback);

Zavolat

K vytvoření a spuštění volání použijte jedno z rozhraní API callAgent a poskytněte uživatele, kterého jste vytvořili prostřednictvím Identity SDK komunikačních služeb.

Vytváření a spouštění volání je synchronní. Instance call umožňuje přihlásit se k odběru událostí volání.

Zahajte hovor 1:n s uživatelem nebo do veřejné telefonní sítě.

Pokud chcete volat jiného uživatele komunikačních služeb, použijte metodu startCall na callAgent a předejte příjemcovo CommunicationUserIdentifier, které jste vytvořili pomocí administrativní knihovny komunikačních služeb.

Pro volání uživatele 1:1 použijte následující kód:

const userCallee = { communicationUserId: '<ACS_USER_ID>' }
const oneToOneCall = callAgent.startCall([userCallee]);

Chcete-li zavolat do veřejné telefonní sítě (PSTN), použijte metodu startCall na callAgent a zadejte příjemcovo PhoneNumberIdentifier. Prostředek komunikační služby musí být nakonfigurovaný tak, aby umožňoval volání do veřejné telefonní sítě.

Při volání čísla veřejné telefonní sítě zadejte své alternativní ID volajícího. Alternativní ID volajícího je telefonní číslo (na základě standardu E.164), které identifikuje volajícího ve volání do veřejné telefonní sítě. Je to telefonní číslo, které příjemce hovoru uvidí pro příchozí hovor.

Poznámka:

Podívejte se na podrobnosti o nabídce volání do veřejné telefonní sítě. Pokud chcete získat přístup k programu pro náhled, přihlaste se do programu pro rané uživatele.

Pro volání do veřejné telefonní sítě 1:1 použijte následující kód:

const pstnCallee = { phoneNumber: '<ACS_USER_ID>' }
const alternateCallerId = {phoneNumber: '<ALTERNATE_CALLER_ID>'};
const oneToOneCall = callAgent.startCall([pstnCallee], { alternateCallerId });

Pro volání 1:n k uživateli a na číslo veřejné telefonní sítě použijte následující kód:

const userCallee = { communicationUserId: '<ACS_USER_ID>' }
const pstnCallee = { phoneNumber: '<PHONE_NUMBER>'};
const alternateCallerId = {phoneNumber: '<ALTERNATE_CALLER_ID>'};
const groupCall = callAgent.startCall([userCallee, pstnCallee], { alternateCallerId });

Připojit se k hovoru v místnosti

Chcete-li se připojit k volání room, můžete vytvořit instanci kontextového objektu s vlastností roomId jako identifikátor room. Pro připojení k hovoru použijte metodu join a předejte instanci kontextu.

const context = { roomId: '<RoomId>' }
const call = callAgent.join(context);

Nabízí room vývojářům aplikací lepší kontrolu nad tím, kdo se může připojit k hovoru, když se setká a jak spolupracují. Další informace o místnostech najdete v tématu Rozhraní API místností pro strukturované schůzky a připojení se k hovoru v místnosti.

Připojení ke skupinovému hovoru

Poznámka:

Parametr groupId je systémová metadata používaná Microsoftem pro operace potřebné ke spuštění systému. Do hodnoty nezahrnujte osobní údaje groupId . Microsoft s tímto parametrem nezachází jako s osobními údaji a jeho obsah může být viditelný zaměstnancům Microsoftu nebo uložen dlouhodobě.

Parametr groupId vyžaduje, aby data byla ve formátu GUID. Doporučujeme používat náhodně generované identifikátory GUID, které nejsou ve vašich systémech považovány za osobní údaje.

Chcete-li zahájit nové skupinové volání nebo se připojit k probíhajícímu skupinovému volání, použijte join metodu a předejte objekt s groupId vlastností. Hodnota groupId musí být identifikátor GUID.

const context = { groupId: '<GUID>'};
const call = callAgent.join(context);

Přijetí příchozího hovoru

Instance callAgent vygeneruje incomingCall událost, když přihlášená identita přijme příchozí hovor. Pokud chcete naslouchat této události, přihlaste se k odběru pomocí jedné z těchto možností:

const incomingCallHandler = async (args: { incomingCall: IncomingCall }) => {
    const incomingCall = args.incomingCall;

    // Get incoming call ID
    var incomingCallId = incomingCall.id

    // Get information about this Call. This API is provided as a preview for developers
    // and may change based on feedback that we receive. Do not use this API in a production environment.
    // To use this api please use 'beta' release of Azure Communication Services Calling Web SDK
    var callInfo = incomingCall.info;

    // Get information about caller
    var callerInfo = incomingCall.callerInfo

    // Accept the call
    var call = await incomingCall.accept();

    // Reject the call
    incomingCall.reject();

    // Subscribe to callEnded event and get the call end reason
     incomingCall.on('callEnded', args => {
        console.log(args.callEndReason);
    });

    // callEndReason is also a property of IncomingCall
    var callEndReason = incomingCall.callEndReason;
};
callAgentInstance.on('incomingCall', incomingCallHandler);

Událost incomingCall zahrnuje incomingCall položku, kterou můžete přijmout nebo odmítnout.

Sada SDK cameraStartFailed: true pro volání ve službě Azure Communication vyvolá diagnostiku volání, pokud není kamera dostupná při spuštění, přijetí nebo připojování hovoru s povoleným videem. V tomto případě hovor začíná vypnutým videem. Kamera nemusí být dostupná, protože ji používá jiný proces nebo je v operačním systému zakázaná.

Blokování a obnovení hovoru

Poznámka:

V každém okamžiku musí existovat pouze jeden (1) aktivní hovor ve stavu Connected s aktivními médii. Všechna ostatní volání musí být blokována uživatelem nebo programově aplikací. Tento scénář je běžný ve scénářích, jako jsou kontaktní centra, kde uživatel může potřebovat zpracovat více odchozích a příchozích volání. V tomto případě by se měla blokovat všechna neaktivní volání a uživatel by měl komunikovat s ostatními jenom v aktivním hovoru.

Pokud chcete hovor podržet nebo obnovit, použijte asynchronní rozhraní API: hold a resume

Hovor přidržíte tak, že:

await call.hold();

Při hold vyřešení operace je stav volání nastaven na LocalHold hodnotu. V hovoru 1:1 je také pozastaven druhý účastník a stav volání z pohledu tohoto účastníka je nastaven na RemoteHold. Později může druhý účastník přidržet svůj hovor, což by vedlo ke změně stavu na LocalHold.

Ve skupinovém hovoru nebo schůzce – hold je místní operace, která nepřerušuje hovor pro ostatní účastníky.

Pokud chcete hovor obnovit, musí ho obnovit všichni uživatelé, kteří zahájili blokování.

Postup obnovení hovoru z blokování:

await call.resume();

resume Při vyřešení operace se stav volání znovu nastaví na Connected.

Ztlumit a zrušit ztlumení hovoru

Pokud chcete ztlumit nebo obnovit zvuk místního koncového bodu, použijte asynchronní rozhraní API: mute a unmute.

//mute local device (microphone / sent audio)
await call.mute();

//unmute local device (microphone / sent audio)
await call.unmute();

Ztlumit a zrušit ztlumení zvuku

Ztlumení příchozího zvuku nastaví hlasitost hovoru na 0. Pokud chcete ztlumit nebo zrušit ztlumení příchozího zvuku, použijte asynchronní operace muteIncomingAudio a unmuteIncomingAudio.

//mute local device (speaker)
await call.muteIncomingAudio();

//unmute local device (speaker)
await call.unmuteIncomingAudio();

Když je příchozí zvuk ztlumený, klientská sada SDK účastníka stále přijímá zvuk hovoru (zvuk vzdáleného účastníka). Zvuk hovoru není slyšet ve reproduktoru a účastník není schopen poslouchat, dokud není zavoláno call.unmuteIncomingAudio(). Můžeme ale použít filtr pro hlasový hovor a přehrát filtrovaný zvuk.

Správa vzdálených účastníků

Všichni vzdálení účastníci jsou součástí objektu RemoteParticipant a jsou k dispozici prostřednictvím remoteParticipants kolekce v instanci volání. Objekt remoteParticipants je přístupný z Call instance.

Zobrazení seznamu účastníků hovoru

Kolekce remoteParticipants vrátí seznam vzdálených účastníků volání:

call.remoteParticipants; // [remoteParticipant, remoteParticipant....]

Přidání účastníka do hovoru

Pokud chcete do hovoru přidat účastníka (buď uživatele, nebo telefonní číslo), použijte addParticipant operaci. Zadejte jeden z typů Identifier . Vrátí synchronně instanci remoteParticipant. Když se účastník úspěšně přidá do hovoru, vyvolá událost remoteParticipantsUpdated z hovoru.

const userIdentifier = { communicationUserId: '<ACS_USER_ID>' };
const pstnIdentifier = { phoneNumber: '<PHONE_NUMBER>' }
const remoteParticipant = call.addParticipant(userIdentifier);
const alternateCallerId = {  phoneNumber: '<ALTERNATE_CALLER_ID>' };
const remoteParticipant = call.addParticipant(pstnIdentifier, { alternateCallerId });

Odstraňte účastníka z hovoru

Pokud chcete účastníka (uživatele nebo telefonní číslo) odebrat z hovoru, můžete zavolat removeParticipant. Musíte vybrat jeden z těchto Identifier typů. Tato metoda se dokončí asynchronně po odebrání účastníka z hovoru. Účastník je také odebrán ze remoteParticipants sbírky.

const userIdentifier = { communicationUserId: '<ACS_USER_ID>' };
const pstnIdentifier = { phoneNumber: '<PHONE_NUMBER>' }
await call.removeParticipant(userIdentifier);
await call.removeParticipant(pstnIdentifier);

Přístup k vlastnostem vzdáleného účastníka

Vzdálení účastníci mají sadu přidružených vlastností a kolekcí:

• CommunicationIdentifier: Získejte identifikátor vzdáleného účastníka. Identita je jedním z těchto CommunicationIdentifier typů.

  const identifier = remoteParticipant.identifier;
  

• Může to být jeden z následujících CommunicationIdentifier typů:

  • { communicationUserId: '<ACS_USER_ID'> }: Objekt představující uživatele Azure Communication Services.
  • { phoneNumber: '<E.164>' }: Objekt představující telefonní číslo ve formátu E.164.
  • { microsoftTeamsUserId: '<TEAMS_USER_ID>', isAnonymous?: boolean; cloud?: "public" | "dod" | "gcch" }: Objekt představující uživatele Teams.
  • { id: string }: objekt představující identifikátor, který neodpovídá žádnému z ostatních typů identifikátorů

• state: Získejte stav vzdáleného účastníka.

  const state = remoteParticipant.state;
  

• Stav může být následující:

  • Idle:Počáteční stav.
  • Connecting: Stav přechodu, když se účastník připojuje k hovoru.
  • Ringing: Účastník volá.
  • Connected: Účastník je připojen k hovoru.
  • Hold: Účastník čeká.
  • EarlyMedia: Oznámení, které se přehraje před tím, než se účastník připojí k hovoru.
  • InLobby: Označuje, že vzdálený účastník je v předsálí.
  • Disconnected:Koncový stav. Účastník se od hovoru odpojí. Pokud vzdálený účastník ztratí připojení k síti, jeho stav se změní po dvou minutách na Disconnected.

• callEndReason: Pokud chcete zjistit, proč účastník opustil hovor, zkontrolujte callEndReason vlastnost:

  const callEndReason = remoteParticipant.callEndReason;
  const callEndReasonCode = callEndReason.code // (number) code associated with the reason
  const callEndReasonSubCode = callEndReason.subCode // (number) subCode associated with the reason
  

  Poznámka:

  Tato vlastnost je nastavena pouze při přidávání vzdáleného účastníka prostřednictvím call.addParticipant() API a vzdálený účastník například odmítne.

  Ve scénáři, kdy UživatelB vyloučí UživatelC, z pohledu UživatelA se nezobrazuje tento příznak jako nastavený pro UživatelC. Jinými slovy, UserA vůbec nevidí, že by vlastnost callEndReason uživatele UserC byla nastavena.

• isMuted stav: Pokud chcete zjistit, jestli je vzdálený účastník ztlumený, zkontrolujte isMuted vlastnost. Vrátí Boolean.

  const isMuted = remoteParticipant.isMuted;
  

• isSpeaking stav: Pokud chcete zjistit, jestli vzdálený účastník mluví, zkontrolujte isSpeaking vlastnost. Vrátí Boolean.

  const isSpeaking = remoteParticipant.isSpeaking;
  

• videoStreams: Chcete-li zkontrolovat všechny streamy videa, které daný účastník odesílá v tomto hovoru, zkontrolujte kolekci videoStreams . Obsahuje RemoteVideoStream objekty.

  const videoStreams = remoteParticipant.videoStreams; // [RemoteVideoStream, ...]
  

• displayName: Chcete-li získat zobrazovaný název tohoto vzdáleného účastníka, prozkoumejte vlastnost displayName, která vrací řetězec.

  const displayName = remoteParticipant.displayName;
  

• endpointDetails: Získejte podrobnosti o všech koncových bodech pro tohoto vzdáleného účastníka.

  const endpointDetails: EndpointDetails[] = remoteParticipant.endpointDetails;
  

  Poznámka:

  Vzdálený účastník se může připojit na hovor z mnoha možných koncových bodů a každý koncový bod má svůj vlastní jedinečný participantId. participantId se liší od surového ID identifikátoru RemoteParticipant.

Ztlumení ostatních účastníků

Poznámka:

Použijte webovou sadu SDK pro volání služeb Azure Communication Services verze 1.26.1 nebo vyšší.

Pokud chcete ztlumit všechny ostatní účastníky nebo ztlumit konkrétního účastníka, který je připojený k hovoru, můžete použít asynchronní API muteAllRemoteParticipants na hovor a mute na vzdáleného účastníka. Událost mutedByOthers z volání se vyvolá, když je místní účastník ztlumený jinými uživateli.

Důležité

Tato funkce služeb Azure Communication Services je aktuálně ve verzi Preview. Funkce ve verzi Preview jsou veřejně dostupné a můžou je používat všichni noví a stávající zákazníci Microsoftu.

API a sady SDK ve verzi Preview jsou poskytovány bez smlouvy o úrovni služeb. Doporučujeme je nepoužívat pro produkční úlohy. Některé funkce nemusí být podporované nebo můžou být omezené.

Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Ztlumení koncového bodu veřejné telefonní sítě pomocí volající sady WebJS SDK je aktuálně ve verzi Public Preview a je k dispozici v buildu 1.34.1 1.34.1 a novějších verzích.

Poznámka:

Ztlumení ostatních hovorů ve verzi 1:1 se nepodporuje.

//mute all participants except yourself
await call.muteAllRemoteParticipants();

//mute a specific participant
await call.remoteParticipants[0].mute();

Kontrola vlastností volání

Získejte jedinečné ID (řetězec) pro volání:

const callId: string = call.id;

Získejte ID místního účastníka:

const participantId: string = call.info.participantId;

Poznámka:

Identita služby Azure Communication Services může používat sadu SDK pro webové volání v mnoha koncových bodech a každý koncový bod má svůj vlastní jedinečný participantId. participantId liší se od nezpracovaného ID identity služby Azure Communication Services.

Pokud se připojíte ke schůzce Teams, načtěte ID vlákna:

const threadId: string | undefined = call.info.threadId;

Získejte informace o hovoru:

const callInfo = call.info;

Seznamte se s dalšími účastníky hovoru zkoumáním kolekce remoteParticipants v instanci call:

const remoteParticipants = call.remoteParticipants;

Identifikujte volajícího příchozího hovoru:

const callerIdentity = call.callerInfo.identifier;

identifier je jedním z CommunicationIdentifier typů.

Získání stavu volání:

const callState = call.state;

Vrátí řetězec představující aktuální stav volání:

• None: Počáteční stav volání.
• Connecting: Počáteční stav přechodu při uskutečnění nebo přijetí hovoru.
• Ringing: U odchozího hovoru označuje, že hovor zvoní u vzdálených účastníků. Je to Incoming na jejich straně.
• EarlyMedia: Označuje stav, kdy se před připojením hovoru přehraje oznámení.
• Connected: Označuje, že je hovor připojen.
• LocalHold: Označuje, že místní účastník dal hovor na držení. Mezi místním koncovým bodem a vzdálenými účastníky neprotékají žádná média.
• RemoteHold: Označuje, že vzdálený účastník dal hovor na čekání. Mezi místním koncovým bodem a vzdálenými účastníky neprotékají žádná média.
• InLobby: Označuje, že uživatel je v předsálí.
• Disconnecting: Přechodový stav, než se volání dostane do stavu Disconnected.
• Disconnected: Konečný stav hovoru. Pokud dojde ke ztrátě síťového připojení, stav se změní na Disconnected po dvou minutách.

Zjistěte, proč volání skončilo, zkontrolováním vlastnosti callEndReason, která ukazuje:

const callEndReason = call.callEndReason;
const callEndReasonMessage = callEndReason.message // (string) user friendly message
const callEndReasonCode = callEndReason.code // (number) code associated with the reason
const callEndReasonSubCode = callEndReason.subCode // (number) subCode associated with the reason

Zjistěte, jestli je aktuální hovor příchozí nebo odchozí prohlédnutím parametru direction. Vrátí CallDirection.

const isIncoming = call.direction == 'Incoming';
const isOutgoing = call.direction == 'Outgoing';

Zkontrolujte aktivní přenosy videa a aktivní přenosy sdílení obrazovky v kolekci localVideoStreams. Operace localVideoStreams vrací LocalVideoStream objekty typu Video, ScreenSharingnebo RawMedia.

const localVideoStreams = call.localVideoStreams;

Zkontrolujte, jestli je aktuální mikrofon ztlumený. Vrátí Boolean.

const muted = call.isMuted;

Zkontrolujte, jestli je ztlumený aktuální příchozí zvuk. Vrátí Boolean.

const incomingAudioMuted = call.isIncomingAudioMuted;

Zkontrolujte, jestli je zapnuté video. Vrátí Boolean.

const isLocalVideoStarted = call.isLocalVideoStarted;

Zkontrolujte, jestli je zapnuté sdílení obrazovky. Vrátí Boolean.

const isScreenSharingOn = call.isScreenSharingOn;

Zavěsit

Existují dva způsoby, jak ukončit hovor.

• Počáteční volající může hovor opustit a ostatní účastníci zůstanou v hovoru.
• Když počáteční volající odejde, hovor se ukončí pro všechny účastníky.

Pokud chcete hovor opustit, použijte:

call.hangUp();

Ukončete hovor pro všechny účastníky tím, že poskytnete HangUpOptions.

Poznámka:

Tato operace není dostupná v pokojích.

call.hangUp( forEveryone: true);

Nainstalujte sadu SDK .

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

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

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

Potom do souboru na úrovni build.gradle modulu přidejte do oddílu dependencies následující řádky:

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

Inicializace požadovaných objektů

Aby bylo možné vytvořit instanci CallAgent, musíte zavolat metodu createCallAgent na instanci CallClient. Toto volání asynchronně vrátí CallAgent objekt instance.

Metoda createCallAgent přijímá CommunicationUserCredential jako argument, který zapouzdřuje přístupový token.

Pokud chcete získat přístup DeviceManager, musíte nejprve vytvořit callAgent instanci. Pak můžete použít metodu CallClient.getDeviceManager získat DeviceManager.

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential).get();
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();

Pokud chcete nastavit zobrazovaný název volajícího, použijte tuto alternativní metodu:

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisplayName("Alice Bob");
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential, callAgentOptions).get();

Zavolat

Pokud chcete vytvořit a zahájit hovor, musíte volat metodu CallAgent.startCall() a poskytnout Identifier příjemce nebo adresáty.

Pokud se chcete připojit ke skupinovému volání, musíte volat metodu CallAgent.join() a zadat groupId. ID skupin musí být ve formátu GUID nebo UUID.

Vytváření a spouštění volání je synchronní. Instance volání umožňuje přihlásit se k odběru všech událostí volání.

Proveďte 1:1 hovor s uživatelem

Pokud chcete volat jinému uživateli komunikační služby, zavolejte metodu callcallAgent a předejte objekt s communicationUserId klíčem.

StartCallOptions startCallOptions = new StartCallOptions();
Context appContext = this.getApplicationContext();
CommunicationUserIdentifier acsUserId = new CommunicationUserIdentifier(<USER_ID>);
CommunicationUserIdentifier participants[] = new CommunicationUserIdentifier[]{ acsUserId };
call oneToOneCall = callAgent.startCall(appContext, participants, startCallOptions);

Zahajte 1:n hovor s uživateli a pevným telefonním připojením

Poznámka:

Podívejte se na podrobnosti o nabídce volání do veřejné telefonní sítě. Pokud chcete získat přístup k programu pro náhled, přihlaste se do programu pro rané uživatele.

Pokud chcete uskutečnit hovor 1:n k uživateli a na číslo veřejné telefonní sítě (PSTN), musíte zadat telefonní číslo příjemce či příjemců.

Prostředek komunikační služby musí být nakonfigurovaný tak, aby povoloval volání do veřejné telefonní sítě:

CommunicationUserIdentifier acsUser1 = new CommunicationUserIdentifier(<USER_ID>);
PhoneNumberIdentifier acsUser2 = new PhoneNumberIdentifier("<PHONE_NUMBER>");
CommunicationIdentifier participants[] = new CommunicationIdentifier[]{ acsUser1, acsUser2 };
StartCallOptions startCallOptions = new StartCallOptions();
Context appContext = this.getApplicationContext();
Call groupCall = callAgent.startCall(participants, startCallOptions);

Přijmout hovor

Chcete-li přijmout volání, zavolejte accept metodu na objekt volání.

Context appContext = this.getApplicationContext();
IncomingCall incomingCall = retrieveIncomingCall();
Call call = incomingCall.accept(context).get();

Přijetí hovoru s videokamerou na:

Context appContext = this.getApplicationContext();
IncomingCall incomingCall = retrieveIncomingCall();
AcceptCallOptions acceptCallOptions = new AcceptCallOptions();
VideoDeviceInfo desiredCamera = callClient.getDeviceManager().get().getCameraList().get(0);
acceptCallOptions.setVideoOptions(new VideoOptions(new LocalVideoStream(desiredCamera, appContext)));
Call call = incomingCall.accept(context, acceptCallOptions).get();

Získejte příchozí hovor tím, že se přihlásíte k odběru události onIncomingCall na objektu callAgent.

// Assuming "callAgent" is an instance property obtained by calling the 'createCallAgent' method on CallClient instance 
public Call retrieveIncomingCall() {
    IncomingCall incomingCall;
    callAgent.addOnIncomingCallListener(new IncomingCallListener() {
        void onIncomingCall(IncomingCall inboundCall) {
            // Look for incoming call
            incomingCall = inboundCall;
        }
    });
    return incomingCall;
}

Připojit se k hovoru v místnosti

Pomocí CallAgent a RoomCallLocator se připojte k hovoru v místnosti zadáním roomId. Metoda CallAgent.join vrátí Call objekt:

val roomCallLocator = RoomCallLocator(roomId)
call = callAgent.join(applicationContext, roomCallLocator, joinCallOptions)

Nabízí room vývojářům aplikací lepší kontrolu nad tím, kdo se může připojit k hovoru, když se setká a jak spolupracují. Další informace o místnostech najdete v tématu Rozhraní API místností pro strukturované schůzky a připojení se k hovoru v místnosti.

Připojení ke skupinovému hovoru

Pokud chcete zahájit nové skupinové volání nebo se připojit k probíhajícímu skupinovému volání, musíte volat metodu join a předat objekt s groupId vlastností. Hodnota musí být ve formátu GUID.

Context appContext = this.getApplicationContext();
GroupCallLocator groupCallLocator = new GroupCallLocator("<GUID>");
JoinCallOptions joinCallOptions = new JoinCallOptions();

call = callAgent.join(context, groupCallLocator, joinCallOptions);

Vlastnosti volání

Získejte jedinečné ID pro tento hovor:

String callId = call.getId();

Chcete-li se dozvědět více o ostatních účastnících hovoru, podívejte se na kolekci remoteParticipant v instanci call.

List<RemoteParticipant> remoteParticipants = call.getRemoteParticipants();

Identita volajícího, pokud je hovor příchozí:

CommunicationIdentifier callerId = call.getCallerInfo().getIdentifier();

Získejte stav hovoru:

CallState callState = call.getState();

Vrátí řetězec představující aktuální stav volání:

• NONE – počáteční stav volání
• EARLY_MEDIA - označuje stav, ve kterém se přehrává oznámení před připojením hovoru.
• CONNECTING – stav počátečního přechodu po umístění nebo přijetí volání
• RINGING - pro odchozí hovor - označuje, že hovor vyzvání pro vzdálené účastníky
• CONNECTED - hovor připojený
• LOCAL_HOLD - hovor byl pozastaven místním účastníkem a nedochází k toku médií mezi místním koncovým bodem a vzdálenými účastníky
• REMOTE_HOLD - hovor pozastavený vzdáleným účastníkem, bez toku médií mezi místním koncovým bodem a vzdálenými účastníky
• DISCONNECTING – přechodový stav před voláním do Disconnected stavu
• DISCONNECTED - konečný stav volání
• IN_LOBBY - v předsálí pro interoperabilitu schůzek v Teams

Pokud chcete zjistit, proč hovor skončil, zkontrolujte callEndReason vlastnost. Obsahuje kód nebo podkód:

CallEndReason callEndReason = call.getCallEndReason();
int code = callEndReason.getCode();
int subCode = callEndReason.getSubCode();

Pokud chcete zjistit, jestli je aktuální hovor příchozí nebo odchozí hovor, zkontrolujte callDirection vlastnost:

CallDirection callDirection = call.getCallDirection(); 
// callDirection == CallDirection.INCOMING for incoming call
// callDirection == CallDirection.OUTGOING for outgoing call

Pokud chcete zjistit, jestli je aktuální mikrofon ztlumený, zkontrolujte muted vlastnost:

boolean muted = call.isMuted();

Pokud chcete zkontrolovat aktivní streamy videa, zkontrolujte kolekci localVideoStreams :

List<LocalVideoStream> localVideoStreams = call.getLocalVideoStreams();

Vypnutí a zapnutí zvuku

Pokud chcete ztlumit nebo zrušit ztlumení místního koncového bodu, můžete použít asynchronní rozhraní API: mute a unmute

Context appContext = this.getApplicationContext();
call.mute(appContext).get();
call.unmute(appContext).get();

Změna hlasitosti hovoru

Když jsou účastníci v hovoru, měla by hardwarová tlačítka na telefonu umožnit uživateli změnit hlasitost hovoru.

Použijte metodu setVolumeControlStream s typem proudu AudioManager.STREAM_VOICE_CALL na Aktivitu, kde probíhá volání.

Tato metoda umožňuje hardwarovým klíčům hlasitosti změnit hlasitost hovoru, označenou ikonou telefonu nebo něco podobného na posuvníku hlasitosti. Zabraňuje také změnám hlasitosti jinými zvukovými profily, jako jsou alarmy, mediální hlasitost nebo hlasitost celého systému. Další informace naleznete v tématu Zpracování změn ve zvukovém výstupu | Vývojáři pro Android.

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    setVolumeControlStream(AudioManager.STREAM_VOICE_CALL);
}

Správa vzdálených účastníků

Všichni vzdálení účastníci mají typ RemoteParticipant a jsou k dispozici prostřednictvím remoteParticipants kolekce v instanci volání.

Seznam účastníků hovoru

Kolekce remoteParticipants vrátí seznam vzdálených účastníků v daném hovoru:

List<RemoteParticipant> remoteParticipants = call.getRemoteParticipants(); // [remoteParticipant, remoteParticipant....]

Přidání účastníka do hovoru

Pokud chcete přidat účastníka do hovoru (buď uživatele, nebo telefonní číslo), můžete vytočit operaci addParticipant.

Tato operace synchronně vrací instanci vzdáleného účastníka.

const acsUser = new CommunicationUserIdentifier("<acs user id>");
const acsPhone = new PhoneNumberIdentifier("<phone number>");
RemoteParticipant remoteParticipant1 = call.addParticipant(acsUser);
AddPhoneNumberOptions addPhoneNumberOptions = new AddPhoneNumberOptions(new PhoneNumberIdentifier("<alternate phone number>"));
RemoteParticipant remoteParticipant2 = call.addParticipant(acsPhone, addPhoneNumberOptions);

Odebrat účastníka z hovoru

Pokud chcete účastníka odebrat z hovoru (buď uživatele, nebo telefonní číslo), můžete zavolat operaci removeParticipant.

Tato operace se vyřeší asynchronně, tedy nezávisle na okamžiku odebrání účastníka z hovoru.

Účastník je také odebrán z kolekce remoteParticipants.

RemoteParticipant acsUserRemoteParticipant = call.getParticipants().get(0);
RemoteParticipant acsPhoneRemoteParticipant = call.getParticipants().get(1);
call.removeParticipant(acsUserRemoteParticipant).get();
call.removeParticipant(acsPhoneRemoteParticipant).get();

Vlastnosti vzdáleného účastníka

Každý daný vzdálený účastník má sadu přidružených vlastností a kolekcí:

• Získejte identifikátor tohoto vzdáleného účastníka.

Identita je jedním z těchto Identifier typů.

CommunicationIdentifier participantIdentifier = remoteParticipant.getIdentifier();

• Získejte stav tohoto vzdáleného účastníka.

  ParticipantState state = remoteParticipant.getState();
  

Stav může být některý z následujících:

• IDLE -počáteční stav

• EARLY_MEDIA - oznámení se přehrávala před tím, než se účastník připojí k hovoru.

• RINGING - Účastníkovi zvoní hovor

• CONNECTING - přechodový stav, když se účastník připojuje k hovoru

• CONNECTED - účastník je připojen k hovoru

• HOLD - účastník je přidržený

• IN_LOBBY - účastník čeká v předsálí, aby byl přijat. Aktuálně se používá jenom ve scénáři spolupráce v Teams.

• DISCONNECTED - konečný stav – účastník je odpojen od hovoru

• Pokud chcete zjistit, proč účastník opustil hovor, zkontrolujte callEndReason vlastnost:

  CallEndReason callEndReason = remoteParticipant.getCallEndReason();
  

• Pokud chcete zkontrolovat, jestli je tento vzdálený účastník ztlumený nebo ne, zkontrolujte isMuted vlastnost:

  boolean isParticipantMuted = remoteParticipant.isMuted();
  

• Pokud chcete zkontrolovat, jestli tento vzdálený účastník mluví nebo ne, zkontrolujte isSpeaking vlastnost:

  boolean isParticipantSpeaking = remoteParticipant.isSpeaking();
  

• Pokud chcete zkontrolovat všechny streamy videa, které daný účastník odesílá v tomto hovoru, zkontrolujte kolekci videoStreams :

  List<RemoteVideoStream> videoStreams = remoteParticipant.getVideoStreams(); // [RemoteVideoStream, RemoteVideoStream, ...]
  

Ztlumení ostatních účastníků

Poznámka:

Použijte sadu SDK pro volání Azure Communication Services pro Android ve verzi 2.11.0 nebo vyšší.

Když je účastník PSTN ztlumený, dostane oznámení, že je ztlumený a že může stisknutím kombinace kláves (například *6) zrušit ztlumení. Když stisknou *6, nebudou ztlumené.

Pokud chcete ztlumit všechny ostatní účastníky volání, použijte muteAllRemoteParticipants operaci rozhraní API.

call.muteAllRemoteParticipants();

Pokud chcete ztlumit konkrétního vzdáleného účastníka, použijte mute operaci rozhraní API u daného vzdáleného účastníka.

remoteParticipant.mute();

Pokud chcete místnímu účastníkovi oznámit, že je ztlumen ostatními uživateli, přihlaste se k odběru události onMutedByOthers.

Používání služeb v popředí

Pokud chcete spustit úlohu viditelnou uživatelem i v případě, že je vaše aplikace na pozadí, můžete použít službu Foreground Services.

Pomocí služeb Foreground můžete například uživatelům poskytnout viditelné oznámení, když má vaše aplikace aktivní volání. Tímto způsobem, i když uživatel přejde na domovskou obrazovku nebo odebere aplikaci z poslední obrazovky, bude hovor dál aktivní.

Pokud během hovoru nepoužíváte službu na popředí, přechod na domovskou obrazovku může hovor udržet aktivní, ale odebrání aplikace ze seznamu posledních aplikací může hovor zastavit, pokud operační systém Android ukončí proces vaší aplikace.

Službu Foreground byste měli spustit, když uživatel spustí hovor nebo se k němu připojí, například:

call = callAgent.startCall(context, participants, options);
startService(yourForegroundServiceIntent);

Měli byste také zastavit Foreground službu, když zavěsíte hovor nebo je stav hovoru "Odpojeno", například:

call.hangUp(new HangUpOptions()).get();
stopService(yourForegroundServiceIntent);

Podrobnosti o službě Popředí

Mějte na paměti, že scénáře, jako je zastavení již spuštěné služby Foreground, když se aplikace odebere ze seznamu posledních uživatelů, odebere oznámení viditelné uživatelem. V takovém případě může operační systém Android udržovat proces aplikace naživu po určitou dobu navíc, což znamená, že volání může zůstat aktivní během tohoto období.

Pokud vaše aplikace zastavuje službu Foreground v metodě služby onTaskRemoved , například vaše aplikace může spustit nebo zastavit zvuk a video podle vašeho životního cyklu aktivity. Například zastavení zvuku a videa při zničení aktivity pomocí přepsání metody onDestroy.

Nastavení systému

Podle těchto kroků nastavte systém.

Vytvoření projektu Xcode

V Xcode vytvořte nový projekt pro iOS a vyberte šablonu aplikace s jedním zobrazením . Tento článek používá architekturu SwiftUI, takže byste měli nastavit jazyk na Swift a nastavit rozhraní na SwiftUI.

V tomto článku nebudete vytvářet testy. Zrušte zaškrtnutí políčka Zahrnout testy .

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

1. Vytvořte pro aplikaci soubor Podfile, například v tomto příkladu:

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

2. Spusťte pod install.

3. Otevřete .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í aplikace pomocí NSMicrophoneUsageDescription. Nastavte přidruženou hodnotu na řetězec, který je součástí dialogového okna, který systém používá k vyžádání přístupu od uživatele.

Klikněte pravým tlačítkem myši na položku Info.plist stromu projektu a pak vyberte Open As>Source Code. Do oddílu nejvyšší úrovně <dict> přidejte následující řádky a pak soubor uložte.

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

Nastavení architektury aplikace

Otevřete soubor projektu ContentView.swift . import Přidejte deklaraci do horní části souboru pro import AzureCommunicationCalling knihovny. Navíc importujte AVFoundation. Potřebujete ho pro žádosti o zvuková oprávnění v kódu.

import AzureCommunicationCalling
import AVFoundation

Inicializovat CallAgent

Chcete-li vytvořit CallAgent instanci z CallClient, musíte použít metodu callClient.createCallAgent , která asynchronně vrátí CallAgent objekt po inicializaci.

Pokud chcete vytvořit klienta volání, předejte CommunicationTokenCredential objekt:

import AzureCommunication

let tokenString = "token_string"
var userCredential: CommunicationTokenCredential?
do {
    let options = CommunicationTokenRefreshOptions(initialToken: token, refreshProactively: true, tokenRefresher: self.fetchTokenSync)
    userCredential = try CommunicationTokenCredential(withOptions: options)
} catch {
    updates("Couldn't created Credential object", false)
    initializationDispatchGroup!.leave()
    return
}

// tokenProvider needs to be implemented by Contoso, which fetches a new token
public func fetchTokenSync(then onCompletion: TokenRefreshOnCompletion) {
    let newToken = self.tokenProvider!.fetchNewToken()
    onCompletion(newToken, nil)
}

Objekt CommunicationTokenCredential, který jste vytvořili, předejte do CallClient a nastavte zobrazovaný název:

self.callClient = CallClient()
let callAgentOptions = CallAgentOptions()
options.displayName = " iOS Azure Communication Services User"

self.callClient!.createCallAgent(userCredential: userCredential!,
    options: callAgentOptions) { (callAgent, error) in
        if error == nil {
            print("Create agent succeeded")
            self.callAgent = callAgent
        } else {
            print("Create agent failed")
        }
})

Poznámka:

Když aplikace implementuje delegáty událostí, musí obsahovat silný odkaz na objekty, které vyžadují odběry událostí. Například při volání metody call.addParticipant a vrátí objekt RemoteParticipant. Aplikace pak nastaví delegáta tak, aby naslouchal RemoteParticipantDelegate a aplikace musí obsahovat silný odkaz na RemoteParticipant objekt. V opačném případě, pokud je tento objekt shromážděn, delegát vyvolá závažnou výjimku při volání SDK se pokusí vyvolat objekt.

Zadání odchozího hovoru

Pokud chcete vytvořit a spustit volání, musíte volat jedno z rozhraní API CallAgent a poskytnout identitu komunikační služby uživatele, kterého jste zřídili pomocí sady SDK pro správu komunikačních služeb.

Vytváření a spouštění volání je synchronní. Obdržíte instanci volání, která umožňuje přihlásit se k odběru všech událostí volání.

Zahajte hovor 1:1 s uživatelem nebo hovor 1:n s uživateli a veřejnou telefonní sítí.

let callees = [CommunicationUser(identifier: 'UserId')]
self.callAgent?.startCall(participants: callees, options: StartCallOptions()) { (call, error) in
     if error == nil {
         print("Successfully started outgoing call")
         self.call = call
     } else {
         print("Failed to start outgoing call")
     }
}

Zahajte 1:n hovor s uživateli a pevným telefonním připojením

Poznámka:

Podívejte se na podrobnosti o nabídce volání do veřejné telefonní sítě. Pokud chcete získat přístup k programu pro náhled, přihlaste se do programu pro rané uživatele.

Aby bylo možné uskutečnit hovor ve formátu 1:n k uživateli a veřejné telefonní síti (PSTN), je nutné zadat telefonní číslo získané prostřednictvím komunikačních služeb.

let pstnCallee = PhoneNumberIdentifier(phoneNumber: '+1999999999')
let callee = CommunicationUserIdentifier('UserId')
self.callAgent?.startCall(participants: [pstnCallee, callee], options: StartCallOptions()) { (groupCall, error) in
     if error == nil {
         print("Successfully started outgoing call to multiple participants")
         self.call = groupCall
     } else {
         print("Failed to start outgoing call to multiple participants")
     }
}

Připojit se k hovoru v místnosti

Chcete-li se připojit k hovoru room, zadejte vlastnost roomId jako room identifikátor. Chcete-li se připojit k volání, použijte metodu join a předejte roomCallLocator.

func joinRoomCall() {
    if self.callAgent == nil {
        print("CallAgent not initialized")
        return
    }
    
    if (self.roomId.isEmpty) {
        print("Room ID not set")
        return
    }
    
    // Join a call with a Room ID
    let options = JoinCallOptions()
    let audioOptions = AudioOptions()
    audioOptions.muted = self.muted
    
    options.audioOptions = audioOptions
    
    let roomCallLocator = RoomCallLocator(roomId: roomId)
    self.callAgent!.join(with: roomCallLocator, joinCallOptions: options) { (call, error) in
        self.setCallAndObserver(call: call, error: error)
    }
}

Nabízí room vývojářům aplikací lepší kontrolu nad tím, kdo se může připojit k hovoru, když se setká a jak spolupracují. Další informace o místnostech najdete v tématu Rozhraní API místností pro strukturované schůzky a připojení se k hovoru v místnosti.

Připojení ke skupinovému hovoru

Pokud se chcete připojit k hovoru, musíte volat jedno z rozhraní API na .CallAgent

let groupCallLocator = GroupCallLocator(groupId: UUID(uuidString: "uuid_string")!)
self.callAgent?.join(with: groupCallLocator, joinCallOptions: JoinCallOptions()) { (call, error) in
    if error == nil {
        print("Successfully joined group call")
        self.call = call
    } else {
        print("Failed to join group call")
    }
}

Přihlášení k odběru příchozího hovoru

Přihlaste se k události příchozího hovoru.

final class IncomingCallHandler: NSObject, CallAgentDelegate, IncomingCallDelegate
{
    // Event raised when there is an incoming call
    public func callAgent(_ callAgent: CallAgent, didReceiveIncomingCall incomingcall: IncomingCall) {
        self.incomingCall = incomingcall
        // Subscribe to get OnCallEnded event
        self.incomingCall?.delegate = self
    }

    // Event raised when incoming call was not answered
    public func incomingCall(_ incomingCall: IncomingCall, didEnd args: PropertyChangedEventArgs) {
        print("Incoming call was not answered")
        self.incomingCall = nil
    }
}

Přijetí příchozího hovoru

Chcete-li přijmout volání, zavolejte accept metodu objektu IncomingCall .

self.incomingCall!.accept(options: AcceptCallOptions()) { (call, error) in
   if (error == nil) {
       print("Successfully accepted incoming call")
       self.call = call
   } else {
       print("Failed to accept incoming call")
   }
}

let firstCamera: VideoDeviceInfo? = self.deviceManager!.cameras.first
localVideoStreams = [LocalVideoStream]()
localVideoStreams!.append(LocalVideoStream(camera: firstCamera!))
let acceptCallOptions = AcceptCallOptions()
acceptCallOptions.videoOptions = VideoOptions(localVideoStreams: localVideoStreams!)
if let incomingCall = self.incomingCall {
    incomingCall.accept(options: acceptCallOptions) { (call, error) in
        if error == nil {
            print("Incoming call accepted")
        } else {
            print("Failed to accept incoming call")
        }
    }
} else {
  print("No incoming call found to accept")
}

Proveďte operace během hovoru

Během hovoru můžete provádět operace pro správu nastavení souvisejících s videem a zvukem.

Vypnutí a zapnutí zvuku

Pokud chcete ztlumit nebo zrušit ztlumení místního koncového bodu, můžete použít asynchronní rozhraní API mute a unmute.

call!.mute { (error) in
    if error == nil {
        print("Successfully muted")
    } else {
        print("Failed to mute")
    }
}

Pomocí následujícího kódu můžete asynchronně zrušit ztlumení místního koncového bodu.

call!.unmute { (error) in
    if error == nil {
        print("Successfully un-muted")
    } else {
        print("Failed to unmute")
    }
}

Správa vzdálených účastníků

Typ RemoteParticipant představuje všechny vzdálené účastníky. Jsou dostupné prostřednictvím remoteParticipants kolekce v instanci volání.

Seznam účastníků hovoru

call.remoteParticipants

Přidání účastníka do hovoru

Pokud chcete přidat účastníka do hovoru buď jako uživatele, nebo prostřednictvím telefonního čísla, použijte operaci addParticipant. Tato operace synchronně vrací instanci vzdáleného účastníka.

let remoteParticipantAdded: RemoteParticipant = call.add(participant: CommunicationUserIdentifier(identifier: "userId"))

Odstraňte účastníka z hovoru

Chcete-li účastníka odebrat z hovoru jako uživatel nebo podle telefonního čísla, zavolejte operaci removeParticipant. Tato operace se řeší asynchronně.

call!.remove(participant: remoteParticipantAdded) { (error) in
    if (error == nil) {
        print("Successfully removed participant")
    } else {
        print("Failed to remove participant")
    }
}

Získejte vlastnosti vzdáleného účastníka

// [RemoteParticipantDelegate] delegate - an object you provide to receive events from this RemoteParticipant instance
var remoteParticipantDelegate = remoteParticipant.delegate

// [CommunicationIdentifier] identity - same as the one used to provision a token for another user
var identity = remoteParticipant.identifier

// ParticipantStateIdle = 0, ParticipantStateEarlyMedia = 1, ParticipantStateConnecting = 2, ParticipantStateConnected = 3, ParticipantStateOnHold = 4, ParticipantStateInLobby = 5, ParticipantStateDisconnected = 6
var state = remoteParticipant.state

// [Error] callEndReason - reason why participant left the call, contains code/subcode/message
var callEndReason = remoteParticipant.callEndReason

// [Bool] isMuted - indicating if participant is muted
var isMuted = remoteParticipant.isMuted

// [Bool] isSpeaking - indicating if participant is currently speaking
var isSpeaking = remoteParticipant.isSpeaking

// RemoteVideoStream[] - collection of video streams this participants has
var videoStreams = remoteParticipant.videoStreams // [RemoteVideoStream, RemoteVideoStream, ...]

Ztlumení ostatních účastníků

Poznámka:

Použijte iOS SDK pro volání ve službě Azure Communication Services verze 2.13.0 nebo vyšší.

Když je účastník PSTN ztlumený, dostane oznámení, že je ztlumený a že může stisknutím kombinace kláves (například *6) zrušit ztlumení. Když stisknou *6, budou odtlumeni.

Pokud chcete ztlumit všechny ostatní účastníky hovoru, použijte muteAllRemoteParticipants operaci hovoru.

call!.muteAllRemoteParticipants { (error) in
    if error == nil {
        print("Successfully muted all remote participants.")
    } else {
        print("Failed to mute remote participants.")
    }
}

Pokud chcete ztlumit konkrétního vzdáleného účastníka, použijte mute operaci u daného vzdáleného účastníka.

remoteParticipant.mute { (error) in
    if error == nil {
        print("Successfully muted participant.")
    } else {
        print("Failed to mute participant.")
    }
}

Pokud chcete místnímu účastníkovi oznámit, že je ztlumen ostatními uživateli, přihlaste se k odběru události onMutedByOthers.

Nastavení systému

Podle těchto kroků nastavte systém.

Vytvoření projektu sady Visual Studio

Pro aplikaci Univerzální platformy Windows vytvořte ve Visual Studio 2022 nový projekt Prázdná aplikace (Universal Windows). Po zadání názvu projektu si můžete vybrat libovolnou sadu Windows SDK později než 10.0.17763.0.

V případě aplikace WinUI 3 vytvořte nový projekt pomocí šablony Prázdná aplikace zabalená (WinUI 3 v desktopové verzi) pro nastavení jednostráňové aplikace WinUI 3. Vyžaduje se sada Windows App SDK verze 1.3 nebo novější.

Instalace balíčku a závislostí pomocí Správce balíčků NuGet

Rozhraní API a knihovny sady SDK Volání jsou veřejně dostupné prostřednictvím balíčku NuGet.

Pro nalezení, stažení a instalaci balíčku NuGet Calling SDK:

1. Otevřete Správce balíčků NuGet výběrem Nástroje>Správce balíčků NuGet>Spravovat balíčky NuGet pro řešení.
2. Vyberte Procházet a do vyhledávacího pole zadejte Azure.Communication.Calling.WindowsClient .
3. Ujistěte se, že je zaškrtnuté políčko Zahrnout předběžné verze .
4. Vyberte balíček Azure.Communication.Calling.WindowsClient a pak vyberte Azure.Communication.Calling.WindowsClient1.4.0-beta.1 nebo novější verzi.
5. Zaškrtněte políčko odpovídající projektu Azure Communication Services v pravém podokně.
6. Vyberte volbu Instalovat.

Implementace ukázkové aplikace v sadě Visual Studio

Tato část popisuje, jak vyvíjet aplikaci pro správu hovorů v prostředí Visual Studio.

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

Aplikace vyžaduje přístup k mikrofonu. V aplikacích pro Univerzální platformu Windows (UPW) musí být funkce mikrofonu deklarována v souboru manifestu aplikace.

Přístup k mikrofonu:

1. Na panelu Solution Explorer poklikejte na soubor s příponou .appxmanifest .
2. Klikněte na Capabilities záložku.
3. Microphone V seznamu možností zaškrtněte políčko.

Vytvořit tlačítka uživatelského rozhraní pro zapnutí a zavěšení hovoru.

Tato ukázková aplikace obsahuje dvě tlačítka. Jeden pro uskutečnění hovoru a druhý pro ukončení uskutečněného hovoru.

Přidejte do aplikace dvě tlačítka.

1. Na panelu Solution Explorer poklikejte na soubor s názvem MainPage.xaml pro UWP nebo MainWindows.xaml pro WinUI 3.
2. Na centrálním panelu vyhledejte kód XAML v náhledu uživatelského rozhraní.
3. Upravte kód XAML následujícím výňatkem:

<TextBox x:Name="CalleeTextBox" PlaceholderText="Who would you like to call?" />
<StackPanel>
    <Button x:Name="CallButton" Content="Start/Join call" Click="CallButton_Click" />
    <Button x:Name="HangupButton" Content="Hang up" Click="HangupButton_Click" />
</StackPanel>

Nastavení aplikace pomocí API sady SDK pro volání

Rozhraní API SDK pro volání jsou ve dvou různých prostředích názvů.

Následující kroky informují kompilátor jazyka C# o těchto jmenných prostorech a umožňují využít IntelliSense ve Visual Studio k pomoci s vývojem kódu.

1. Na panelu Solution Explorer klikněte na šipku na levé straně souboru s názvem MainPage.xaml UPW nebo MainWindows.xaml WinUI 3.
2. Poklikejte na soubor s názvem MainPage.xaml.cs nebo MainWindows.xaml.cs.
3. Na konec aktuálních using příkazů přidejte následující příkazy.

using Azure.Communication.Calling.WindowsClient;

Nechte MainPage.xaml.cs nebo MainWindows.xaml.cs otevřené. Další kroky přidají další kód.

Povolení interakcí s aplikacemi

Tlačítka UI, která byla přidána, musí fungovat nad umístěným CommunicationCall. To znamená, že CommunicationCall datový člen by měl být přidán do MainPage třídy nebo MainWindow třídy. Aby bylo možné úspěšně vykonat asynchronní operaci vytvářející CallAgent, měl by být do stejné třídy přidán také datový člen CallAgent.

Do třídy pr MainPage přidejte následující datové členyMainWindow:

CallAgent callAgent;
CommunicationCall call;

Vytvořte obsluhy tlačítek

Dříve byly do kódu XAML přidány dvě tlačítka uživatelského rozhraní. Následující kód přidá obslužné rutiny, které se mají spustit, když uživatel tlačítko vybere. Následující kód by se měl přidat za datové členy z předchozí části.

private async void CallButton_Click(object sender, RoutedEventArgs e)
{
    // Start call
}

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

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí klientské knihovny volání služeb Azure Communication Services pro UPW.

Název	Popis
CallClient	CallClient je hlavní vstupní bod do klientské knihovny pro volání.
CallAgent	Slouží CallAgent ke spuštění a připojení k hovorům.
CommunicationCall	CommunicationCall se používá ke správě přijatých nebo spojených hovorů.
CommunicationTokenCredential	CommunicationTokenCredential slouží jako přihlašovací údaje tokenu pro vytvoření instance CallAgent.
CallAgentOptions	Obsahuje CallAgentOptions informace pro identifikaci volajícího.
HangupOptions	HangupOptions informuje, jestli má být hovor ukončen všem účastníkům.

Inicializujte agenta pro volání

Chcete-li vytvořit CallAgent instanci z CallClient, musíte použít CallClient.CreateCallAgentAsync metodu, která asynchronně vrátí CallAgent objekt po inicializaci.

Chcete-li vytvořit CallAgent, musíte předat CallTokenCredential objekt a CallAgentOptions objekt. Mějte na paměti, že CallTokenCredential vyvolá chybu, pokud je předán poškozený token.

Pokud chcete volat během inicializace aplikace, přidejte do pomocné funkce následující kód.

var callClient = new CallClient();
this.deviceManager = await callClient.GetDeviceManagerAsync();

var tokenCredential = new CallTokenCredential("<AUTHENTICATION_TOKEN>");
var callAgentOptions = new CallAgentOptions()
{
    DisplayName = "<DISPLAY_NAME>"
};

this.callAgent = await callClient.CreateCallAgentAsync(tokenCredential, callAgentOptions);

Změňte <AUTHENTICATION_TOKEN> za platný token přihlašovacích údajů pro váš prostředek. Pokud potřebujete vytvořit zdroj tokenu přihlašovacích údajů, podívejte se na přístupový token uživatele.

Vytvoření callagentu a umístění hovoru

Objekty k vytvoření CallAgent jsou teď připravené. Nastal čas asynchronně vytvořit CallAgent a zahájit hovor.

Po zpracování výjimky z předchozího kroku přidejte následující kód.

var startCallOptions = new StartCallOptions();
var callees = new [] { new UserCallIdentifier(CalleeTextBox.Text.Trim()) };

this.call = await this.callAgent.StartCallAsync(callees, startCallOptions);
this.call.OnStateChanged += Call_OnStateChangedAsync;

Použijte 8:echo123, abyste mohli komunikovat s echobotem služby Azure Communication Services.

Vypnutí a zapnutí zvuku

Pokud chcete ztlumit nebo zrušit ztlumení odchozího zvuku, použijte asynchronní operace označené MuteOutgoingAudioAsync a UnmuteOutgoingAudioAsync:

// mute outgoing audio
await this.call.MuteOutgoingAudioAsync();

// unmute outgoing audio
await this.call.UnmuteOutgoingAudioAsync();

Ztlumení ostatních účastníků

Poznámka:

Použijte sadu SDK pro volání služby Azure Communication Services verze 1.9.0 nebo vyšší.

Když je účastník veřejné telefonní sítě ztlumený, musí obdržet oznámení, že je ztlumený a že může stisknout kombinaci kláves (například *6) a zrušit ztlumení. Když stisknou *6, musí být ztlumené.

Pokud chcete ztlumit všechny ostatní účastníky nebo ztlumit konkrétního účastníka, použijte asynchronní operace MuteAllRemoteParticipantsAsync hovoru a MuteAsync vzdáleného účastníka:

// mute all participants except yourself
await this.call.MuteAllRemoteParticipantsAsync();

// mute specific participant in the call
await this.call.RemoteParticipants.FirstOrDefault().MuteAsync();

Pokud chcete místnímu účastníkovi oznámit, že je ztlumen ostatními uživateli, přihlaste se k odběru události MutedByOthers.

Ukončení hovoru

Jakmile je hovor uskutečněn, použijte HangupAsync metodu objektu CommunicationCall k ukončení hovoru.

Pomocí instance HangupOptions informovat všechny účastníky, pokud je nutné hovor ukončit.

Do tohoto kódu přidejte následující kód HangupButton_Click:

this.call.OnStateChanged -= Call_OnStateChangedAsync;
await this.call.HangUpAsync(new HangUpOptions() { ForEveryone = false });

Spuštění kódu

1. Ujistěte se, že Visual Studio sestaví aplikaci pro x64, x86 nebo ARM64.
2. Stisknutím klávesy F5 spusťte aplikaci.
3. Jakmile je aplikace spuštěná, kliknutím na tlačítko Hovor umístěte hovor definovanému příjemci.

Při prvním spuštění aplikace systém vyzve uživatele, aby udělil přístup k mikrofonu.

Další kroky

• Informace o správě videa
• Naučte se zaznamenávat hovory.
• Naučte se přepisovat hovory.