Hívások kezelése

Cikk
04/25/2024

Megtudhatja, hogyan kezelheti a hívásokat az Azure Communication Services SDKS-vel. Megtudhatja, hogyan kezdeményezhet hívásokat, kezelheti a résztvevőket és a tulajdonságokat.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Fiók ingyenes létrehozása.
Üzembe helyezett Communication Services-erőforrás. Hozzon létre egy Communication Services-erőforrást.
A User Access Token a hívásügyfél engedélyezéséhez. További információ a User Access Token
Nem kötelező: Végezze el a rövid útmutatót a hívás alkalmazáshoz való hozzáadásának első lépéseihez

Telepítse a SDK-t

npm install A parancs használatával telepítse az Azure Communication Services Common and Calling SDK for JavaScriptet:

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

Szükséges objektumok inicializálása

A CallClient legtöbb hívási művelethez szükség van egy példányra. Új CallClient példány létrehozásakor konfigurálhatja egyéni beállításokkal, például egy példánysal Logger .

CallClient A példánnyal létrehozhat egy példányt CallAgent a createCallAgent. Ez a metódus aszinkron módon egy CallAgent példányobjektumot ad vissza.

A createCallAgent metódus argumentumként használható CommunicationTokenCredential . Elfogad egy felhasználói hozzáférési jogkivonatot.

A példányon található getDeviceManager metódust használhatja a CallClient hozzáféréshez 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()

A Microsoft-infrastruktúra SDK-kapcsolatának legjobb kezelése

A Call Agent példány segít a hívások kezelésében (a hívásokhoz való csatlakozáshoz vagy a hívások indításához). A hívó SDK működéséhez csatlakoznia kell a Microsoft infrastruktúrájához, hogy értesítést kapjon a bejövő hívásokról, és koordinálja az egyéb hívásadatokat. Két Call Agent lehetséges állapota van:

Csatlakozás – A Call Agent connectionStatue érték azt Connected jelenti, hogy az ügyfél SDK csatlakoztatva van, és képes értesítéseket fogadni a Microsoft-infrastruktúrából.

Leválasztva – Az Call Agent állapotok connectionStatue értéke Disconnected olyan probléma, amely miatt az SDK nem tud megfelelően csatlakozni. Call Agent újra létre kell hozni.

invalidToken: Ha egy jogkivonat lejárt, vagy érvénytelen Call Agent , a példány ezzel a hibával megszakad.
connectionIssue: Ha probléma merül fel azzal kapcsolatban, hogy az ügyfél csatlakozik a Microsoft-infrastruktúrához, miután sok újrapróbálkozás Call Agent felfedi a connectionIssue hibát.

A tulajdonság aktuális értékének connectionState vizsgálatával ellenőrizheti, hogy a helyi Call Agent csatlakozik-e a Microsoft-infrastruktúrához. Egy aktív hívás során meghallgathatja az connectionStateChanged eseményt, hogy megállapítsaCall Agent, Csatlakozás-e a kapcsolat nélküli állapotra való váltást.

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

Hívás indítása

Hívás létrehozásához és elindításához használja az egyik API-t, callAgent és adjon meg egy felhasználót, akit a Communication Services identity SDK-n keresztül hozott létre.

A híváslétrehozás és az indítás szinkronban van. A call példány lehetővé teszi a hívási eseményekre való feliratkozást.

1:n-hívás indítása felhasználóhoz vagy PSTN-hez

Egy másik Communication Services-felhasználó meghívásához használja a metódust, és adja át a kommunikációs szolgáltatások felügyeleti kódtárával létrehozott címzetteket CommunicationUserIdentifier.callAgentstartCall

Ha egy felhasználónak 1:1-et hív, használja a következő kódot:

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

Ha nyilvános telefonhálózatra (PSTN) szeretne hívást kezdeményezni, használja a startCall metódust callAgent , és adja át a címzett hívását PhoneNumberIdentifier. A Communication Services-erőforrást úgy kell konfigurálni, hogy engedélyezze a PSTN-hívásokat.

PSTN-szám hívásakor adja meg a másodlagos hívóazonosítót. Az alternatív hívóazonosító egy telefonszám (az E.164 szabvány alapján), amely azonosítja a hívót egy PSTN-hívásban. Ez az a telefonszám, amit a hívás címzettje lát egy bejövő híváshoz.

Feljegyzés

Ellenőrizze a PSTN-hívásajánlat részleteit. Az előzetes verziójú program eléréséhez alkalmazza a korai bevezetési programra.

PsTN-szám 1:1-es hívásához használja a következő kódot:

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

Egy felhasználó 1:n-es hívásához és EGY PSTN-számhoz használja a következő kódot:

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

Csatlakozás szobahíváshoz

Híváshoz való csatlakozáshoz room létrehozhat egy környezeti objektumot azonosítóként a roomIdroom tulajdonsággal. A híváshoz való csatlakozáshoz használja a metódust join , és adja át a környezeti példányt.

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

Az room alkalmazásfejlesztők jobban szabályozhatják, hogy kik csatlakozhatnak egy híváshoz, mikor találkoznak, és hogyan működnek együtt. További információkért roomsolvassa el a fogalmi dokumentációt , vagy kövesse a rövid útmutatót.

Csatlakozás csoporthíváshoz

Feljegyzés

A groupId paraméter rendszer metaadatainak minősül, és a Microsoft használhatja a rendszer futtatásához szükséges műveletekhez. Ne adjon meg személyes adatokat az groupId értékben. A Microsoft nem kezeli ezt a paramétert személyes adatként, és tartalma látható lehet a Microsoft alkalmazottai számára, vagy hosszú távon tárolható.

A groupId paraméter megköveteli, hogy az adatok GUID formátumban legyenek. Javasoljuk, hogy véletlenszerűen generált, nem személyes adatoknak minősülő grafikus felhasználói felületeket használjon a rendszerekben.

Új csoporthívás indításához vagy folyamatban lévő csoporthíváshoz való csatlakozáshoz használja a join metódust, és adjon át egy objektumot egy groupId tulajdonsággal. Az groupId értéknek GUID-nak kell lennie.

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

Bejövő hívás fogadása

A callAgent példány eseményt incomingCall bocsát ki, amikor a bejelentkezett identitás bejövő hívást fogad. Az esemény meghallgatásához iratkozzon fel az alábbi lehetőségek egyikével:

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

Az incomingCall esemény tartalmaz egy olyan példányt incomingCall , amelyet elfogadhat vagy elutasíthat.

Az Azure Communication Calling SDK elindít egy kamerátStartFailed: true call diagnostic, ha a kamera nem érhető el a hívás indításakor, elfogadásakor vagy csatlakozáskor, ha engedélyezve van a videó. Ebben az esetben a hívás a videó kikapcsolásával kezdődik. Előfordulhat, hogy a kamera nem érhető el, mert egy másik folyamat használja, vagy mert le van tiltva az operációs rendszerben.

Hívás várakoztatása és folytatása

Feljegyzés

Egy adott időpontban csak 1 aktív hívásnak kell lennie (állapotban Connected , aktív adathordozóval). Az összes többi hívást egy felhasználónak kell szüneteltetnie, vagy alkalmazásonként programozott módon kell tartania. Ez gyakori az olyan helyzetekben, mint a kapcsolattartási központok, ahol előfordulhat, hogy egy felhasználónak több kimenő és bejövő hívást kell kezelnie, minden inaktív hívást várakoztatnia kell, a felhasználónak pedig csak aktív hívásban kell másokkal kommunikálnia.

A hívás megtartásához vagy folytatásához használhatja az hold aszinkron resume API-kat:

A hívás tartása

await call.hold();

Az hold API feloldásakor a hívás állapota a következőre LocalHoldvan állítva: . Egy 1:1-s hívásban a másik résztvevő is várakoztatva lesz, és a hívás állapota az adott résztvevő szempontjából "RemoteHold" értékre van állítva. Később előfordulhat, hogy a másik résztvevő visszatartja a hívást, ami állapotváltozást eredményezne.LocalHold Csoportos hívásban vagy értekezletben – ez hold egy helyi művelet, nem tartja meg a többi hívás résztvevőjének hívását. A hívás folytatásához a várakoztatást kezdeményező összes felhasználónak folytatnia kell azt.

A hívás újraindítása a várakoztatásból:

await call.resume();

Az API feloldásakor a resume hívás állapota ismét a következőre Connectedvan állítva: .

Hívás elnémítása és visszahangosítása

A helyi végpont elnémításához vagy visszahangosításához használhatja az mute aszinkron unmute API-kat:

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

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

Bejövő hang elnémítása és visszahangosítása

A bejövő hang elnémítása 0-ra állítja a híváskötetet. A bejövő hang elnémításához vagy visszahangosításához használhatja az muteIncomingAudio aszinkron unmuteIncomingAudio API-kat:

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

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

Ha a bejövő hang elnémul, a résztvevő ügyféloldali SDK továbbra is megkapja a hívás hangját (a távoli résztvevő hangját). A hívás hanganyaga nem hallható az előadóban, és a résztvevő nem tudja meghallgatni a "call.unmuteIncomingAudio()" hívásáig. Azonban alkalmazhatunk szűrőt a hívás hangján, és lejátszhatjuk a szűrt hangot.

Más résztvevők elnémítása

Feljegyzés

Ez az API fejlesztői előzetes verzióként szolgál, és a kapott visszajelzések alapján változhat. Az API használatához használja az Azure Communication Services hívó webes SDK 1.24.1-es vagy újabb verziójának bétaverzióját.

Az összes többi résztvevő elnémításához vagy egy adott résztvevő elnémításához használhatja az aszinkron API-kat muteAllRemoteParticipants a hívásban és mute a távoli résztvevőben. A mutedByOthers hívás eseménye akkor jön létre, ha a helyi résztvevőt mások elnémították.

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

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

Távoli résztvevők kezelése

Az objektum minden távoli résztvevője RemoteParticipant részletes, és a remoteParticipants gyűjteményen keresztül érhető el egy híváspéldányon. Ez remoteParticipants egy Call példányból érhető el.

A hívás résztvevőinek listázása

A remoteParticipants gyűjtemény egy hívás távoli résztvevőinek listáját adja vissza:

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

Résztvevő hozzáadása híváshoz

Ha résztvevőt (felhasználót vagy telefonszámot) szeretne hozzáadni egy híváshoz, használhatja az addParticipant API-t. Adja meg az egyik típust Identifier . Szinkron módon adja vissza a példányt remoteParticipant . A remoteParticipantsUpdated hívás eseménye akkor jön létre, ha egy résztvevő sikeresen hozzá van adva a híváshoz.

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

Résztvevő eltávolítása a hívásból

Ha el szeretne távolítani egy résztvevőt (felhasználót vagy telefonszámot) egy hívásból, meghívhatja removeParticipant. Át kell adnia az egyik típust Identifier . Ez a módszer aszinkron módon oldja fel a problémát, miután a résztvevőt eltávolították a hívásból. A rendszer eltávolítja a résztvevőt is a remoteParticipants gyűjteményből.

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

Távoli résztvevők tulajdonságainak elérése

A távoli résztvevőkhöz társított tulajdonságok és gyűjtemények vannak:

CommunicationIdentifier: Távoli résztvevő azonosítójának lekérése. Az identitás az CommunicationIdentifier egyik típus:

const identifier = remoteParticipant.identifier;

A következő CommunicationIdentifier típusok egyike lehet:
- { communicationUserId: '<ACS_USER_ID'> }: Az Azure Communication Services-felhasználót képviselő objektum.
- { phoneNumber: '<E.164>' }: A telefonszámot E.164 formátumban ábrázoló objektum.
- { microsoftTeamsUserId: '<TEAMS_USER_ID>', isAnonymous?: boolean; cloud?: "public" | "dod" | "gcch" }: A Teams-felhasználót képviselő objektum.
- { id: string }: az azonosítót képviselő objektum, amely nem felel meg a többi azonosítótípusnak
state: Távoli résztvevő állapotának lekérése.

const state = remoteParticipant.state;

Az állapot a következő lehet:
- Idle: Kezdeti állapot.
- Connecting: Áttűnés állapota, miközben egy résztvevő csatlakozik a híváshoz.
- Ringing: A résztvevő cseng.
- Connected: A résztvevő csatlakozik a híváshoz.
- Hold: A résztvevő várakozik.
- EarlyMedia: A híváshoz való csatlakozás előtt lejátssza a bejelentést.
- InLobby: Azt jelzi, hogy a távoli résztvevő az előszobában van.
- Disconnected: Végleges állapot. A résztvevő leválasztva van a hívásról. Ha a távoli résztvevő elveszíti a hálózati kapcsolatát, az állapota két perc múlva megváltozik Disconnected .
callEndReason: Annak megismeréséhez, hogy egy résztvevő miért hagyta el a hívást, ellenőrizze a tulajdonságot callEndReason :
```
const callEndReason = remoteParticipant.callEndReason;
const callEndReasonCode = callEndReason.code // (number) code associated with the reason
const callEndReasonSubCode = callEndReason.subCode // (number) subCode associated with the reason
```
Megjegyzés:
- Ez a tulajdonság csak akkor van beállítva, ha távoli résztvevőt ad hozzá a Call.addParticipant() API-n keresztül, és a távoli résztvevő például elutasítja.
- Abban a forgatókönyvben, amelyben a UserB elindítja a UserC-t, a UserA szempontjából a UserA nem látja ezt a jelölőt a UserC-hez. Más szóval a UserA egyáltalán nem látja a UserC callEndReason tulajdonságát.
isMuted állapot: Ha meg szeretné tudni, hogy egy távoli résztvevő el van-e némítva, ellenőrizze a tulajdonságot isMuted . A visszaadott érték Boolean.
```
const isMuted = remoteParticipant.isMuted;
```
isSpeaking állapot: Ha meg szeretné tudni, hogy egy távoli résztvevő beszél-e, ellenőrizze a tulajdonságot isSpeaking . A visszaadott érték Boolean.
```
const isSpeaking = remoteParticipant.isSpeaking;
```
videoStreams: Az adott résztvevő által a hívásban küldött összes videostream vizsgálatához ellenőrizze a gyűjteményt videoStreams . Objektumokat tartalmaz RemoteVideoStream .
```
const videoStreams = remoteParticipant.videoStreams; // [RemoteVideoStream, ...]
```
displayName: A távoli résztvevő megjelenítendő nevének lekéréséhez vizsgálja meg displayName a visszaadott sztring tulajdonságot.
```
const displayName = remoteParticipant.displayName;
```
endpointDetails: A távoli résztvevő összes végpontjának adatainak lekérése
```
    const endpointDetails: EndpointDetails[] = remoteParticipant.endpointDetails;
```
Megjegyzés: Egy távoli résztvevő több végpontról is részt vehet a hívásban, és mindegyik végpont saját egyedi participantId. participantId eltér a RemoteParticipant.identifier nyers azonosítójától.

Hívás tulajdonságainak ellenőrzése

A hívás egyedi azonosítójának (sztringjének) lekérése:

const callId: string = call.id;

A helyi résztvevő azonosítójának lekérése:

const participantId: string = call.info.participantId;

Megjegyzés: Az Azure Communication Services-identitások számos végponton használhatják a webes hívó SDK-t, és mindegyik végpont saját egyedi participantId. participantId nem ugyanaz, mint az Azure Communication Services-identitás nyers azonosítója.

Ha Teams-értekezlethez csatlakozik, kérje le a szálazonosítót:

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

Információ kérése a hívásról:

const callInfo = call.info;

A hívás többi résztvevőjéről a "hívás" példány gyűjteményének vizsgálatával remoteParticipants tájékozódhat:

const remoteParticipants = call.remoteParticipants;

Egy bejövő hívás hívójának azonosítása:

const callerIdentity = call.callerInfo.identifier;

identifier az egyik CommunicationIdentifier típus.

Hívás állapotának lekérése:

const callState = call.state;

Ez egy hívás aktuális állapotát képviselő sztringet ad vissza:

None: Kezdeti hívásállapot.
Connecting: Kezdeti átmeneti állapot a hívás indításakor vagy elfogadásakor.
Ringing: Kimenő hívás esetén azt jelzi, hogy a hívás a távoli résztvevők számára cseng. Az ő oldalukon van Incoming .
EarlyMedia: Azt az állapotot jelzi, amelyben a hívás csatlakoztatása előtt hirdetményt játszik le.
Connected: Azt jelzi, hogy a hívás csatlakoztatva van.
LocalHold: Azt jelzi, hogy a hívás helyi résztvevője visszatartja a hívást. A helyi végpont és a távoli résztvevők között nem folyik média.
RemoteHold: Azt jelzi, hogy a hívásban részt vevő távoli résztvevő visszatartja a hívást. A helyi végpont és a távoli résztvevők között nem folyik média.
InLobby: Azt jelzi, hogy a felhasználó az előszobában van.
Disconnecting: Áttűnés állapota, mielőtt a hívás állapotba Disconnected kerül.
Disconnected: Végső hívás állapota. Ha a hálózati kapcsolat megszakad, az állapot két perc múlva megváltozik Disconnected .

A tulajdonság vizsgálatával megtudhatja, hogy miért végződött egy callEndReason hívás:

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

A tulajdonság vizsgálatával direction megtudhatja, hogy az aktuális hívás bejövő vagy kimenő-e. A visszaadott érték CallDirection.

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

Ellenőrizze az aktív videóstreameket és az aktív képernyőmegosztási streameket a localVideoStreams gyűjtemény ellenőrzésével. Az localVideoStreams API a ( vagy ScreenSharingRawMedia) típusú Videoobjektumokat adja visszaLocalVideoStream.

const localVideoStreams = call.localVideoStreams;

Ellenőrizze, hogy az aktuális mikrofon el van-e némítva. A visszaadott érték Boolean.

const muted = call.isMuted;

Ellenőrizze, hogy az aktuális bejövő hang (hangszóró) el van-e némítva. A visszaadott érték Boolean.

const incomingAudioMuted = call.isIncomingAudioMuted;

Ellenőrizze, hogy be van-e kapcsolva a videó. A visszaadott érték Boolean.

const isLocalVideoStarted = call.isLocalVideoStarted;

Ellenőrizze, hogy be van-e kapcsolva a képernyőmegosztás. A visszaadott érték Boolean.

const isScreenSharingOn = call.isScreenSharingOn;

Telepítse a SDK-t

Keresse meg a projektszintű build.gradle fájlt, és adja hozzá mavenCentral() a következő alatt és allprojectsalatt található buildscript adattárak listájához:

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

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

Ezután a modulszintű build.gradle fájlban adja hozzá a következő sorokat a dependencies szakaszhoz:

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

A szükséges objektumok inicializálása

Példány létrehozásához CallAgent meg kell hívnia a createCallAgent metódust egy CallClient példányon. Ez a hívás aszinkron módon egy CallAgent példányobjektumot ad vissza.

A createCallAgent metódus argumentumként veszi fel CommunicationUserCredential a metódust, amely egy hozzáférési jogkivonatot foglal magában.

A hozzáféréshez DeviceManagerelőször létre kell hoznia egy példányt callAgent . Ezután használhatja a metódust a CallClient.getDeviceManager lekéréshez 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();

A hívó megjelenítendő nevének beállításához használja az alábbi alternatív módszert:

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

Hívás indítása

A hívás létrehozásához és elindításához meg kell hívnia a CallAgent.startCall() metódust, és meg kell adnia a Identifier hívó(ka)t. Csoporthíváshoz való csatlakozáshoz meg kell hívnia a metódust CallAgent.join() , és meg kell adnia a groupId azonosítót. A csoportazonosítóknak GUID vagy UUID formátumban kell lenniük.

A híváslétrehozás és az indítás szinkronban van. A híváspéldány lehetővé teszi, hogy feliratkozzon a hívás összes eseményére.

1:1-ás hívás kezdeményezése egy felhasználóhoz

Ha egy másik Communication Services-felhasználónak szeretne hívást kezdeményezni, hívja meg a call metódust callAgent , és adjon át egy objektumot kulccsal communicationUserId .

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

1:n hívás indítása a felhasználókkal és a PSTN-vel

Feljegyzés

Ellenőrizze a PSTN-hívásajánlat részleteit. Az előzetes verziójú program eléréséhez alkalmazza a korai bevezetési programra.

Ha 1:n-es hívást szeretne kezdeményezni egy felhasználónak és egy PSTN-számot, meg kell adnia a hívó telefonszámát. A Communication Services-erőforrást úgy kell konfigurálni, hogy engedélyezze a PSTN-hívásokat:

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

Hívás elfogadása

Hívás fogadásához hívja meg az "accept" metódust egy hívásobjektumon.

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

Hívás fogadása videokamerával:

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

A bejövő hívás az objektum eseményére callAgent való feliratkozással onIncomingCall kérhető le:

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

Csatlakozás szobahíváshoz

CallAgent A szobahíváshoz való csatlakozáshoz használjon és RoomCallLocator csatlakozzon egy roomId. A CallAgent.join metódus egy objektumot Call ad vissza:

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

Csatlakozás csoporthíváshoz

Új csoporthívás indításához vagy folyamatban lévő csoporthíváshoz való csatlakozáshoz meg kell hívnia az "illesztés" metódust, és át kell adnia egy objektumot egy groupId tulajdonsággal. Az értéknek GUID-nak kell lennie.

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

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

Hívás tulajdonságai

Kérje le a hívás egyedi azonosítóját:

String callId = call.getId();

Ha többet szeretne megtudni a hívás többi résztvevőjéről, vizsgálja meg remoteParticipant a példány gyűjteményét call :

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

A hívó identitása, ha a hívás bejövő:

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

A hívás állapotának lekérése:

CallState callState = call.getState();

Egy hívás aktuális állapotát képviselő sztringet ad vissza:

"NONE" – kezdeti hívásállapot
"EARLY_MEDIA" – azt az állapotot jelzi, amelyben a hívás csatlakoztatása előtt hirdetményt játszanak le
"CONNECTING" – kezdeti átmeneti állapot a hívás indítása vagy elfogadása után
A "CSENGETÉS" – kimenő hívás esetén – azt jelzi, hogy a hívás cseng a távoli résztvevők számára
"CONNECTED" – a hívás csatlakoztatva van
"LOCAL_HOLD" – a hívást a helyi résztvevő várakoztatja, a helyi végpont és a távoli résztvevő(k) között nem folyik média
"REMOTE_HOLD" – a hívást egy távoli résztvevő visszatartja, a helyi végpont és a távoli résztvevő(k) között nem folyik média
"DISCONNECTING" – áttűnési állapot, mielőtt a hívás "Leválasztva" állapotba kerül
"DISCONNECTED" – végső hívás állapota
"IN_LOBBY" – a Teams-értekezletek együttműködési lehetőségeinek előszobájában

Ha szeretné megtudni, hogy miért ért véget egy hívás, vizsgálja meg a tulajdonságot callEndReason . Kód/alkód:

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

Annak ellenőrzéséhez, hogy az aktuális hívás bejövő vagy kimenő hívás-e, vizsgálja meg callDirection a tulajdonságot:

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

Annak ellenőrzéséhez, hogy az aktuális mikrofon el van-e némítva, vizsgálja meg a tulajdonságot muted :

boolean muted = call.isMuted();

Az aktív videóstreamek vizsgálatához ellenőrizze a gyűjteményt localVideoStreams :

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

Elnémítás és visszahangosítás

A helyi végpont elnémításához vagy visszahangosításához használhatja az és unmute aszinkron mute API-kat:

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

Más résztvevők elnémítása

Feljegyzés

Ez az API nyilvános előzetes verzióként érhető el a fejlesztők számára, és a kapott visszajelzések alapján változhat. Az API használatához használja az Azure Communication Services 2.6.0-beta.8-s vagy újabb verzióját hívó Azure Communication Services bétaverzióját.

A hívás összes többi résztvevőjének elnémításához használja a muteAllRemoteParticipants hívás api-jának használatát.

call.muteAllRemoteParticipants();

Egy adott távoli résztvevő elnémításához használja az mute API-t egy adott távoli résztvevőn.

remoteParticipant.mute();

Ha értesíteni szeretné a helyi résztvevőt, hogy mások elnémították őket, iratkozzon fel az onMutedByOthers eseményre.

A hívás hangerejének módosítása

Hívás közben a telefonon lévő hardverkötet-kulcsok lehetővé teszik a felhasználó számára a hívás hangerejének módosítását. Ehhez használja a metódust setVolumeControlStream a hívás helye szerinti tevékenység streamtípusával AudioManager.STREAM_VOICE_CALL . Ez lehetővé teszi, hogy a hardverkötet-kulcsok módosítják a hívás hangerejét (amelyet telefonikon vagy a hangerő csúszkán hasonló jelöl), megakadályozva a hangerő más hangprofilok, például riasztások, média- vagy rendszerszintű hangerő módosítását. További információ: A hangkimenet változásainak kezelése | Android-fejlesztők.

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

Távoli résztvevők kezelése

Minden távoli résztvevő típus szerint RemoteParticipant van jelölve, és a remoteParticipants híváspéldány gyűjteményén keresztül érhető el.

Hívás résztvevőinek listázása

A remoteParticipants gyűjtemény az adott hívás távoli résztvevőinek listáját adja vissza:

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

Résztvevő hozzáadása híváshoz

Ha résztvevőt szeretne hozzáadni egy híváshoz (felhasználóhoz vagy telefonszámhoz), meghívhatja addParticipant. Ez szinkron módon adja vissza a távoli résztvevő példányát.

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

Résztvevő eltávolítása a hívásból

Ha el szeretne távolítani egy résztvevőt egy hívásból (felhasználó vagy telefonszám) meghívhatja removeParticipant. Ez a probléma aszinkron módon lesz feloldva, miután a résztvevőt eltávolították a hívásból. A résztvevőt is eltávolítjuk a gyűjteményből remoteParticipants .

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

Távoli résztvevő tulajdonságai

Bármely adott távoli résztvevő rendelkezik a következő tulajdonságokkal és gyűjteményekkel:

A távoli résztvevő azonosítójának lekérése. Az identitás az egyik "Azonosító" típus
```
CommunicationIdentifier participantIdentifier = remoteParticipant.getIdentifier();
```

A távoli résztvevő állapotának lekérése.

ParticipantState state = remoteParticipant.getState();

Az állapot lehet a

"TÉTLEN" – kezdeti állapot
"EARLY_MEDIA" – a bejelentést azelőtt játsszák le, hogy a résztvevő csatlakozik a híváshoz
"CSENGETÉS" – a résztvevő hívása cseng
"CONNECTING" – áttűnési állapot, miközben a résztvevő csatlakozik a híváshoz
"CONNECTED" – a résztvevő csatlakozik a híváshoz
"HOLD" – a résztvevő várakozik
"IN_LOBBY" - a résztvevő az előszobában várja a felvételt. Jelenleg csak a Teams interop forgatókönyvében használják
"DISCONNECTED" – végleges állapot – a résztvevő le van választva a hívásról
Ha meg szeretné tudni, hogy egy résztvevő miért hagyta el a hívást, vizsgálja meg callEndReason a tulajdonságot:
```
CallEndReason callEndReason = remoteParticipant.getCallEndReason();
```
Annak ellenőrzéséhez, hogy a távoli résztvevő el van-e némítva vagy sem, vizsgálja meg a tulajdonságot isMuted :
```
boolean isParticipantMuted = remoteParticipant.isMuted();
```
Annak ellenőrzéséhez, hogy a távoli résztvevő beszél-e vagy sem, vizsgálja meg a tulajdonságot isSpeaking :
```
boolean isParticipantSpeaking = remoteParticipant.isSpeaking();
```
Ha meg szeretné vizsgálni az adott résztvevő által a hívásban küldött összes videostreamet, ellenőrizze a gyűjteményt videoStreams :
```
List<RemoteVideoStream> videoStreams = remoteParticipant.getVideoStreams(); // [RemoteVideoStream, RemoteVideoStream, ...]
```

A Foreground Services használata

Azokban az esetekben, amikor látható felhasználói feladatot szeretne futtatni, még akkor is, ha az alkalmazás a háttérben van, használhatja a Foreground Services szolgáltatást.

A Foreground Services használatával például láthatóan értesítheti a felhasználót, ha az alkalmazás aktív hívást indít. Így még akkor is aktív lesz a hívás, ha a felhasználó a kezdőképernyőre megy, vagy eltávolítja az alkalmazást a legutóbbi képernyőről.

Ha nem használ előtérszolgáltatást hívás közben, a kezdőképernyőre navigálva aktív maradhat a hívás, de ha eltávolítja az alkalmazást a legutóbbi képernyőről, leállíthatja a hívást, ha az Android operációs rendszer leállítja az alkalmazás folyamatát.

A hívás indításakor/csatlakozáskor el kell indítania az Előtérben szolgáltatást, például:

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

Állítsa le az előtérszolgáltatást, amikor lefagy a hívás, vagy a hívás állapota megszakad, például:

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

Jegyzetek a Foreground Services használatáról

Ne feledje, hogy az olyan forgatókönyvek, mint például egy már futó előtérszolgáltatás leállítása, amikor az alkalmazás el lesz távolítva a legutóbbiak listájából, eltávolítja a felhasználó látható értesítését, és az Android operációs rendszer néhány további ideig életben tarthatja az alkalmazás folyamatát, ami azt jelenti, hogy a hívás ebben az időszakban is aktív lehet.

Ha az alkalmazás például leállítja az előtérszolgáltatást a szolgáltatás onTaskRemoved metódusán, az alkalmazás a tevékenység életciklusa szerint indíthat/állíthat le hang- és videoképeket, például hang- és videoképek leállítását, amikor a onDestroy tevékenység a metódus felülbírálásával megsemmisül.

A rendszer beállítása

Az Xcode-projekt létrehozása

Az Xcode-ban hozzon létre egy új iOS-projektet, és válassza ki az egynézetes alkalmazássablont . Ez a rövid útmutató a SwiftUI-keretrendszert használja, ezért a Nyelvet Swiftrekell állítania, az interfészt pedig SwiftUI-ra.

Ebben a rövid útmutatóban nem fog teszteket létrehozni. Nyugodtan törölje a Belefoglalási tesztek jelölőnégyzet jelölését.

Képernyőkép a projekt Xcode-on belüli létrehozására szolgáló ablakról.

A csomag és a függőségek telepítése a CocoaPods használatával

Hozzon létre egy Podfile-t az alkalmazáshoz, például:

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

Futtassa az pod install parancsot.
Megnyitás .xcworkspace Xcode használatával.

Hozzáférés kérése a mikrofonhoz

Az eszköz mikrofonjának eléréséhez frissítenie kell az alkalmazás információs tulajdonságlistáját a használatával NSMicrophoneUsageDescription. A társított értéket egy sztringre állítja, amely szerepelni fog abban a párbeszédpanelben, amellyel a rendszer hozzáférést kér a felhasználótól.

Kattintson a jobb gombbal a projektfa Info.plist bejegyzésére, majd válassza a Megnyitás forráskódként>lehetőséget. Adja hozzá a következő sorokat a legfelső szintű <dict> szakaszhoz, majd mentse a fájlt.

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

Az alkalmazás-keretrendszer beállítása

Nyissa meg a projekt ContentView.swift fájlját. Adjon hozzá egy deklarációt import a fájl tetejére a AzureCommunicationCalling tár importálásához. Ezenkívül importálja az importálást AVFoundationis. Szüksége lesz rá a kódban található hangengedély-kérelmekhez.

import AzureCommunicationCalling
import AVFoundation

A CallAgent inicializálása

Egy példány létrehozásához CallAgentCallClientolyan metódust callClient.createCallAgent kell használnia, amely aszinkron módon ad vissza egy CallAgent objektumot az inicializálás után.

Hívásügyfél létrehozásához adjon át egy objektumot CommunicationTokenCredential :

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

Adja át a CommunicationTokenCredential létrehozott objektumot CallClient, és állítsa be a megjelenítendő nevet:

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

Feljegyzés

Amikor az alkalmazás esemény-delegáltakat implementál, erős hivatkozást kell tartania azokra az objektumokra, amelyek esemény-előfizetéseket igényelnek. Ha például egy RemoteParticipant objektumot ad vissza a call.addParticipant metódus meghívásakor, és az alkalmazás beállítja a meghatalmazott figyelését RemoteParticipantDelegate, az alkalmazásnak erős hivatkozást kell tartalmaznia az RemoteParticipant objektumra. Ellenkező esetben az objektum összegyűjtése esetén a meghatalmazott végzetes kivételt fog eredményezni, amikor a hívó SDK megpróbálja meghívni az objektumot.

Kimenő hívás indítása

A hívás létrehozásához és elindításához be kell hívnia az egyik API-t CallAgent , és meg kell adnia egy felhasználó Kommunikációs szolgáltatások identitását, amelyet a Communication Services Management SDK használatával létesített.

A híváslétrehozás és az indítás szinkronban van. Egy híváspéldányt fog kapni, amely lehetővé teszi, hogy feliratkozzon a hívás összes eseményére.

1:1-ás hívás indítása egy felhasználóhoz vagy egy 1:n hívás a felhasználókkal és a PSTN-vel

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

1:n hívás indítása a felhasználókkal és a PSTN-vel

Feljegyzés

Ellenőrizze a PSTN-hívásajánlat részleteit. Az előzetes verziójú program eléréséhez alkalmazza a korai bevezetési programra.

A pstn-hívás indításához meg kell adnia egy, a Communication Services szolgáltatással beszerzett telefonszámot.

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

Csatlakozás szobahíváshoz

Híváshoz való csatlakozáshoz room adja meg a roomId tulajdonságot azonosítóként room . A híváshoz való csatlakozáshoz használja a metódust join , és adja át a 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)
    }
}

Csatlakozás csoporthíváshoz

A híváshoz az egyik API-t CallAgentbe kell hívnia.

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

Iratkozzon fel egy bejövő híváseseményre.

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

Bejövő hívás elfogadása

Hívás fogadásához hívja meg a accept metódust egy IncomingCall objektumon.

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

Hívásközépműveletek végrehajtása

A hívás során különböző műveleteket hajthat végre a video- és hangbeállítások kezeléséhez.

Elnémítás és visszahangosítás

A helyi végpont elnémításához vagy visszahangosításához használhatja az és unmute az mute aszinkron API-kat.

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

A helyi végpont aszinkron visszahangosításához használja az alábbi kódot.

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

Más résztvevők elnémítása

Feljegyzés

Ez az API nyilvános előzetes verzióként érhető el a fejlesztők számára, és a kapott visszajelzések alapján változhat. Az API használatához használja az Azure Communication Services 2.9.0-béta.1-es vagy újabb verziójának az Azure Communication Services 2.9.0-beta.1-es vagy újabb verzióját.

A hívás összes többi résztvevőjének elnémításához használja a muteAllRemoteParticipants hívás api-jának használatát.

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

Egy adott távoli résztvevő elnémításához használja az mute API-t egy adott távoli résztvevőn.

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

Ha értesíteni szeretné a helyi résztvevőt, hogy mások elnémították őket, iratkozzon fel az onMutedByOthers eseményre.

Távoli résztvevők kezelése

Minden távoli résztvevőt a RemoteParticipant típus jelöl, és a remoteParticipants híváspéldány gyűjteményén keresztül érhető el.

Hívás résztvevőinek listázása

call.remoteParticipants

Résztvevő hozzáadása híváshoz

Ha résztvevőt szeretne hozzáadni egy híváshoz (felhasználóhoz vagy telefonszámhoz), meghívhatja addParticipant. Ez a parancs szinkron módon egy távoli résztvevőpéldányt ad vissza.

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

Résztvevő eltávolítása a hívásból

Ha el szeretne távolítani egy résztvevőt egy hívásból (felhasználó vagy telefonszám), meghívhatja az removeParticipant API-t. Ez aszinkron módon oldható fel.

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

Távoli résztvevő tulajdonságainak lekérése

// [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, ...]

A rendszer beállítása

A Visual Studio-projekt létrehozása

UWP-alkalmazások esetén a Visual Studio 2022-ben hozzon létre egy új Üres alkalmazás (Univerzális Windows) projektet. Miután megadta a projekt nevét, nyugodtan válasszon bármelyik Windows SDK-t a 10.0.17763.0-s verziónál később.

WinUI 3-alkalmazások esetén hozzon létre egy új projektet az Üres alkalmazás, csomagolt (WinUI 3 in Desktop) sablonnal egy egyoldalas WinUI 3-alkalmazás beállításához. Windows-alkalmazás SDK 1.3-es vagy újabb verzió szükséges.

Telepítse a csomagot és a függőségeket a NuGet Csomagkezelő

A hívó SDK API-k és kódtárak nyilvánosan elérhetők NuGet-csomagon keresztül.

Az alábbi lépések szemléltetik a hívó SDK NuGet-csomag megkeresését, letöltését és telepítését:

Nyissa meg a NuGet-Csomagkezelő az Tools>NuGet Csomagkezelő> Manage NuGet Packages for Solution lehetőséget választva.
Válassza a Tallózás lehetőséget, majd írja be Azure.Communication.Calling.WindowsClient a keresőmezőbe.
Győződjön meg arról, hogy be van jelölve az Előzetes belefoglalás jelölőnégyzet.
Jelölje ki a Azure.Communication.Calling.WindowsClient csomagot, majd válassza az Azure.Communication.Calling.WindowsClient1.4.0-beta.1 vagy egy újabb verziót.
Jelölje be a jobb oldali lapon a Communication Services projektnek megfelelő jelölőnégyzetet.
Válassza a Telepítés gombot.

Hozzáférés kérése a mikrofonhoz

Az alkalmazás megfelelő működéséhez hozzá kell férnie a mikrofonhoz. UWP-alkalmazásokban a mikrofonképességet deklarálni kell az alkalmazás jegyzékfájljában.

Az alábbi lépések ezt szemléltetik.

Solution Explorer A panelen kattintson duplán a kiterjesztésű fájlra.appxmanifest.
Kattintson a Capabilities fülre.
Jelölje be a Microphone jelölőnégyzetet a képességek listájából.

Felhasználói felületi gombok létrehozása a hívás helyére és lefagyásához

Ez az egyszerű mintaalkalmazás két gombot tartalmaz. Az egyik a hívás leadásához, a másik pedig a lekötendő híváshoz. Az alábbi lépések szemléltetik, hogyan adhatja hozzá ezeket a gombokat az alkalmazáshoz.

Solution Explorer A panelen kattintson duplán az UWP vagy MainWindows.xaml a WinUI 3 fájlraMainPage.xaml.
A központi panelen keresse meg az XAML-kódot a felhasználói felület előnézete alatt.
Módosítsa az XAML-kódot a következő részlet szerint:

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

Az alkalmazás beállítása SDK API-k meghívásával

A hívó SDK API-k két különböző névtérben találhatók. Az alábbi lépések tájékoztatják a C#-fordítót ezekről a névterekről, amelyek lehetővé teszik a Visual Studio Intellisense számára a kódfejlesztést.

Solution Explorer A panelen kattintson az UWP MainWindows.xaml vagy a WinUI 3 fájl MainPage.xaml bal oldalán található nyílra.
Kattintson duplán a névvel ellátott MainPage.xaml.cs fájlra vagy MainWindows.xaml.cs.
Adja hozzá az alábbi parancsokat az aktuális using utasítások alján.

using Azure.Communication.Calling.WindowsClient;

Tartsa vagy MainPage.xaml.csMainWindows.xaml.cs nyissa meg. A következő lépések további kódot adnak hozzá.

Alkalmazás-interakciók engedélyezése

A korábban hozzáadott felhasználói felületi gomboknak egy elhelyezett CommunicationCallelem tetején kell működnie. Ez azt jelenti, hogy egy CommunicationCall adattagot hozzá kell adni az osztályhoz vagy MainWindow az MainPage osztályhoz. Emellett ahhoz, hogy az aszinkron művelet sikeres CallAgent legyen, egy CallAgent adattagot is hozzá kell adni ugyanahhoz az osztályhoz.

Adja hozzá a következő adattagokat a MainPage pr MainWindow osztályhoz:

CallAgent callAgent;
CommunicationCall call;

Gombkezelők létrehozása

Korábban két felhasználói felületi gombot adtak hozzá az XAML-kódhoz. Az alábbi kód hozzáadja a gombra kattintva végrehajtandó kezelőket. Az előző szakaszban szereplő adattagok után a következő kódot kell hozzáadni.

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

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

Objektummodell

Az alábbi osztályok és felületek kezelik az Azure Communication Services hívási ügyfélkódtárának néhány fő funkcióját az UWP-hez.

Név	Leírás
`CallClient`	Ez `CallClient` a hívási ügyfélkódtár fő belépési pontja.
`CallAgent`	Ez `CallAgent` a hívások indítására és csatlakoztatására szolgál.
`CommunicationCall`	A `CommunicationCall` rendszer az elhelyezett vagy csatlakoztatott hívások kezelésére szolgál.
`CommunicationTokenCredential`	A `CommunicationTokenCredential` rendszer a jogkivonat hitelesítő adataiként használja a példányosításhoz.`CallAgent`
`CallAgentOptions`	A `CallAgentOptions` hívó azonosítására szolgáló információkat tartalmaz.
`HangupOptions`	A `HangupOptions` rendszer tájékoztatja, hogy a hívást le kell-e mondani az összes résztvevőnek.

A CallAgent inicializálása

Példány CallClientlétrehozásához CallAgent olyan metódust kell használniaCallClient.CreateCallAgentAsync, amely aszinkron módon visszaad egy CallAgent objektumot az inicializálás után.

A létrehozáshoz CallAgentát kell adnia egy CallTokenCredential objektumot és egy objektumot CallAgentOptions . Ne feledje, hogy CallTokenCredential a hibásan formázott jogkivonatok átadásakor ad vissza.

Az alkalmazás inicializálásához a következő kódot kell hozzáadni, és a segédfüggvényt kell meghívni.

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

Módosítsa az <AUTHENTICATION_TOKEN> erőforráshoz tartozó érvényes hitelesítő jogkivonatot. Ha egy hitelesítő jogkivonatot forrásként kell megadni, tekintse meg a felhasználói hozzáférési jogkivonat dokumentációját.

CallAgent létrehozása és hívás indítása

A létrehozáshoz CallAgent szükséges objektumok készen állnak. Itt az ideje, hogy aszinkron módon hozzon létre és helyezzen el CallAgent egy hívást.

Az előző lépés kivételének kezelése után a következő kódot kell hozzáadni.

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;

Nyugodtan beszélhet 8:echo123 az Azure Communication Services echorobotjával.

Elnémítás és visszahangosítás

A kimenő hang elnémításához vagy visszahangosításához használhatja az és UnmuteOutgoingAudioAsync az MuteOutgoingAudioAsync aszinkron API-kat:

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

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

Más résztvevők elnémítása

Feljegyzés

Ez az API nyilvános előzetes verzióként érhető el a fejlesztők számára, és a kapott visszajelzések alapján változhat. Az API használatához használja az Azure Communication Services 1.6.0-béta.1-es vagy újabb verzióját hívó Azure Communication Services bétaverzióját.

Az összes többi résztvevő elnémításához vagy egy adott résztvevő elnémításához használhatja az aszinkron API-kat MuteAllRemoteParticipantsAsync a hívásban és MuteAsync a távoli résztvevőben:

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

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

Ha értesíteni szeretné a helyi résztvevőt, hogy mások elnémították őket, iratkozzon fel az MutedByOthers eseményre.

Hívás befejezése

A hívás indítása után az HangupAsyncCommunicationCall objektum metódusát kell használni a hívás lefagyásához.

Egy példányt HangupOptions is fel kell használni annak tájékoztatására, hogy a hívást le kell-e mondani az összes résztvevőnek.

A következő kódot kell hozzáadni a fájlba HangupButton_Click.

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

A kód futtatása

Győződjön meg arról, hogy a Visual Studio létrehozza az alkalmazást az alkalmazás x64futtatásához, x86 vagy ARM64nyomja le F5 az alkalmazást. Ezután kattintson a gombra a Call megadott hívó fél hívásához.

Ne feledje, hogy az alkalmazás első futtatásakor a rendszer kéri a felhasználót, hogy adjon hozzáférést a mikrofonhoz.

Hívások kezelése

Előfeltételek

Telepítse a SDK-t

Szükséges objektumok inicializálása

A Microsoft-infrastruktúra SDK-kapcsolatának legjobb kezelése

Hívás indítása

1:n-hívás indítása felhasználóhoz vagy PSTN-hez

Csatlakozás szobahíváshoz

Csatlakozás csoporthíváshoz

Bejövő hívás fogadása

Hívás várakoztatása és folytatása

Hívás elnémítása és visszahangosítása

Bejövő hang elnémítása és visszahangosítása

Más résztvevők elnémítása

Távoli résztvevők kezelése

A hívás résztvevőinek listázása

Résztvevő hozzáadása híváshoz

Résztvevő eltávolítása a hívásból

Távoli résztvevők tulajdonságainak elérése

Hívás tulajdonságainak ellenőrzése

Telepítse a SDK-t

A szükséges objektumok inicializálása

Hívás indítása

1:1-ás hívás kezdeményezése egy felhasználóhoz

1:n hívás indítása a felhasználókkal és a PSTN-vel

Hívás elfogadása

Csatlakozás szobahíváshoz

Csatlakozás csoporthíváshoz

Hívás tulajdonságai

Elnémítás és visszahangosítás

Más résztvevők elnémítása

A hívás hangerejének módosítása

Távoli résztvevők kezelése

Hívás résztvevőinek listázása

Résztvevő hozzáadása híváshoz

Résztvevő eltávolítása a hívásból

Távoli résztvevő tulajdonságai

A Foreground Services használata

Jegyzetek a Foreground Services használatáról

A rendszer beállítása

Az Xcode-projekt létrehozása

A csomag és a függőségek telepítése a CocoaPods használatával

Hozzáférés kérése a mikrofonhoz

Az alkalmazás-keretrendszer beállítása

A CallAgent inicializálása

Kimenő hívás indítása

1:1-ás hívás indítása egy felhasználóhoz vagy egy 1:n hívás a felhasználókkal és a PSTN-vel

1:n hívás indítása a felhasználókkal és a PSTN-vel

Csatlakozás szobahíváshoz

Csatlakozás csoporthíváshoz

Feliratkozás bejövő hívásra

Bejövő hívás elfogadása

Hívásközépműveletek végrehajtása

Elnémítás és visszahangosítás

Más résztvevők elnémítása

Távoli résztvevők kezelése

Hívás résztvevőinek listázása

Résztvevő hozzáadása híváshoz

Résztvevő eltávolítása a hívásból

Távoli résztvevő tulajdonságainak lekérése

A rendszer beállítása

A Visual Studio-projekt létrehozása

Telepítse a csomagot és a függőségeket a NuGet Csomagkezelő

Hozzáférés kérése a mikrofonhoz

Felhasználói felületi gombok létrehozása a hívás helyére és lefagyásához

Az alkalmazás beállítása SDK API-k meghívásával

Alkalmazás-interakciók engedélyezése

Gombkezelők létrehozása

Objektummodell

A CallAgent inicializálása

CallAgent létrehozása és hívás indítása

Elnémítás és visszahangosítás

Más résztvevők elnémítása

Hívás befejezése

A kód futtatása

Következő lépések

További források