Hantera anrop

Installera SDK:n

npm install Använd kommandot för att installera Azure Communication Services Common och Calling SDK för JavaScript:

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

Initiera nödvändiga objekt

En CallClient instans krävs för de flesta anropsåtgärder. När du skapar en ny CallClient instans kan du konfigurera den med anpassade alternativ som en Logger instans.

Med instansen CallClient kan du skapa en CallAgent instans genom att anropa createCallAgent. Den här metoden returnerar asynkront ett CallAgent instansobjekt.

Metoden createCallAgent använder CommunicationTokenCredential som argument. Den accepterar en användaråtkomsttoken.

Du kan använda getDeviceManager metoden på instansen CallClient för att få åtkomst deviceManagertill .

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

Så här hanterar du SDK-anslutning till Microsoft-infrastruktur på bästa sätt

Instansen Call Agent hjälper dig att hantera anrop (för att ansluta eller starta samtal). För att kunna arbeta måste din anropande SDK ansluta till Microsofts infrastruktur för att få meddelanden om inkommande samtal och samordna annan samtalsinformation. Du Call Agent har två möjliga tillstånd:

Ansluten – Ett Call Agent connectionStatue-värde Connected innebär att klient-SDK:t är anslutet och kan ta emot meddelanden från Microsofts infrastruktur.

Frånkopplad – Ett Call Agent connectionStatue-värde för Disconnected tillstånd det finns ett problem som hindrar SDK:n från att ansluta korrekt. Call Agent ska återskapas.

• invalidToken: Om en token har upphört att gälla eller om en ogiltig Call Agent instans kopplas från med det här felet.
• connectionIssue: Om det finns ett problem med att klienten ansluter till Microsoft-infrastrukturen, efter att många återförsök Call Agent har exponerat connectionIssue felet.

Du kan kontrollera om din lokala Call Agent är ansluten till Microsofts infrastruktur genom att granska det aktuella värdet för connectionState egenskapen. Under ett aktivt anrop kan du lyssna på connectionStateChanged händelsen för att avgöra om Call Agent det ändras från Anslutet till frånkopplat tillstånd.

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

Ringa ett samtal

Om du vill skapa och starta ett anrop använder du ett av API:erna på callAgent och anger en användare som du har skapat via Communication Services identitets-SDK.

Skapande och start av samtal är synkrona. Med instansen call kan du prenumerera på samtalshändelser.

Placera ett 1:n-anrop till en användare eller PSTN

Om du vill anropa en annan Communication Services-användare använder startCall du metoden på callAgent och skickar mottagarens som du skapade med administrationsbiblioteketCommunicationUserIdentifier för Kommunikationstjänster.

För ett "1:1"-anrop till en användare använder du följande kod:

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

Om du vill ringa till ett offentligt kopplat telefonnät (PSTN) använder du startCall metoden på callAgent och skickar mottagarens PhoneNumberIdentifier. Din Communication Services-resurs måste konfigureras för att tillåta PSTN-samtal.

När du anropar ett PSTN-nummer anger du ditt alternativa nummerpresentation. Ett alternativt nummerpresentation är ett telefonnummer (baserat på E.164-standarden) som identifierar anroparen i ett PSTN-samtal. Det är det telefonnummer som samtalsmottagaren ser för ett inkommande samtal.

För ett 1:1-anrop till ett PSTN-nummer använder du följande kod:

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

Använd följande kod för ett 1:n-anrop till en användare och ett PSTN-nummer:

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

Ansluta till ett rumssamtal

Om du vill ansluta till ett room anrop kan du instansiera ett kontextobjekt med roomId egenskapen som room identifierare. Om du vill ansluta till anropet join använder du metoden och skickar kontextinstansen.

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

En room ger programutvecklare bättre kontroll över vem som kan ansluta till ett samtal, när de träffas och hur de samarbetar. Om du vill veta mer om roomskan du läsa den konceptuella dokumentationen eller följa snabbstartsguiden.

Ansluta till ett gruppsamtal

Om du vill starta ett nytt gruppanrop eller ansluta till ett pågående gruppanrop använder du join metoden och skickar ett objekt med en groupId egenskap. Värdet groupId måste vara ett GUID.

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

Ta emot inkommande samtal

Instansen callAgent genererar en incomingCall händelse när den inloggade identiteten tar emot ett inkommande samtal. Om du vill lyssna på den här händelsen prenumererar du med något av följande alternativ:

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

Händelsen incomingCall innehåller en incomingCall instans som du kan acceptera eller avvisa.

Azure Communication Calling SDK höjer en kameraStartFailed: sann samtalsdiagnostik om kameran inte är tillgänglig när du startar, accepterar eller ansluter ett samtal med video aktiverat. I det här fallet börjar samtalet med video av. Kameran kanske inte är tillgänglig eftersom den används av en annan process eller för att den är inaktiverad i operativsystemet.

Pausa och återuppta anrop

Om du vill behålla eller återuppta anropet kan du använda de hold asynkrona resume API:erna:

Så här håller du samtalet

await call.hold();

När hold API:et matchar är anropstillståndet inställt på LocalHold. I ett 1:1-samtal spärras även den andra deltagaren, och tillståndet för samtalet från deltagarens perspektiv är inställt på "RemoteHold". Senare kan den andra deltagaren lägga sitt anrop på is, vilket skulle resultera i en tillståndsändring till LocalHold. I ett gruppsamtal eller möte – hold är en lokal åtgärd, den håller inte samtalet för andra samtalsdeltagare. Om du vill återuppta anropet måste alla användare som initierade undantaget återuppta det.

Så här återupptar du anropet från undantag:

await call.resume();

När API:et resume matchar anges anropstillståndet igen till Connected.

Stäng av och slå på ljudet för ett anrop

Om du vill stänga av eller slå på den lokala slutpunkten kan du använda de mute asynkrona API:erna:unmute

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

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

Stäng av och slå på inkommande ljud

Ljudavstängning av inkommande ljud ställer in samtalsvolymen på 0. Om du vill stänga av eller slå på ljudet från inkommande ljud kan du använda de muteIncomingAudio asynkrona API:erna:unmuteIncomingAudio

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

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

När inkommande ljud är avstängt tar deltagarens klient-SDK fortfarande emot samtalsljudet (fjärrdeltagarens ljud). Samtalsljudet hörs inte i talaren och deltagaren kan inte lyssna förrän "call.unmuteIncomingAudio()" anropas. Vi kan dock använda filter på samtalsljud och spela upp det filtrerade ljudet.

Hantera fjärrdeltagare

Alla fjärrdeltagare beskrivs i RemoteParticipant objektet och är tillgängliga via remoteParticipants samlingen på en samtalsinstans. remoteParticipants Är tillgänglig från en Call instans.

Visa en lista över deltagarna i ett samtal

Samlingen remoteParticipants returnerar en lista över fjärranslutna deltagare i ett anrop:

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

Lägga till en deltagare i ett anrop

Om du vill lägga till en deltagare (antingen en användare eller ett telefonnummer) i ett samtal kan du använda API:et addParticipant . Ange en av typerna Identifier . Den returnerar synkront instansen remoteParticipant . Händelsen remoteParticipantsUpdated från anropet aktiveras när en deltagare har lagts till i anropet.

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

Ta bort en deltagare från ett anrop

Om du vill ta bort en deltagare (antingen en användare eller ett telefonnummer) från ett samtal kan du anropa removeParticipant. Du måste skicka en av typerna Identifier . Den här metoden löser asynkront när deltagaren har tagits bort från anropet. Deltagaren tas också bort från remoteParticipants samlingen.

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

Åtkomst till egenskaper för fjärrdeltagare

Fjärrdeltagare har en uppsättning associerade egenskaper och samlingar:

• CommunicationIdentifier: Hämta identifieraren för en fjärrdeltagare. Identitet är en av typerna CommunicationIdentifier :

const identifier = remoteParticipant.identifier;

• Det kan vara en av följande CommunicationIdentifier typer:

  • { communicationUserId: '<ACS_USER_ID'> }: Objekt som representerar Azure Communication Services-användaren.
  • { phoneNumber: '<E.164>' }: Objekt som representerar telefonnumret i E.164-format.
  • { microsoftTeamsUserId: '<TEAMS_USER_ID>', isAnonymous?: boolean; cloud?: "public" | "dod" | "gcch" }: Objekt som representerar Teams-användaren.
  • { id: string }: objekt som representerar identifierare som inte passar någon av de andra identifierartyperna

• state: Hämta tillståndet för en fjärrdeltagare.

const state = remoteParticipant.state;

• Tillståndet kan vara:

  • Idle: Ursprungligt tillstånd.
  • Connecting: Övergångstillstånd när en deltagare ansluter till anropet.
  • Ringing: Deltagaren ringer.
  • Connected: Deltagaren är ansluten till samtalet.
  • Hold: Deltagaren är spärrad.
  • EarlyMedia: Meddelande som spelas upp innan en deltagare ansluter till anropet.
  • InLobby: Anger att fjärrdeltagaren är i lobbyn.
  • Disconnected: Slutligt tillstånd. Deltagaren är frånkopplad från anropet. Om fjärrdeltagaren förlorar sin nätverksanslutning ändras deras tillstånd till Disconnected efter två minuter.

• callEndReason: Om du vill veta varför en deltagare lämnade samtalet kontrollerar du egenskapen 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
  

  Obs!

  • Den här egenskapen anges bara när du lägger till en fjärrdeltagare via API:et Call.addParticipant() och fjärrdeltagaren avböjer till exempel.
  • I scenariot, där UserB sparkar UserC, från UserA:s perspektiv, ser UserA inte den här flaggan för UserC. UserA ser med andra ord inte att UserC:s callEndReason-egenskap ställs in alls.

• isMuted status: Om du vill ta reda på om en fjärrdeltagare är avstängd kontrollerar du egenskapen isMuted . Den returnerar Boolean.

  const isMuted = remoteParticipant.isMuted;
  

• isSpeaking status: Om du vill ta reda på om en fjärrdeltagare talar kontrollerar du egenskapen isSpeaking . Den returnerar Boolean.

  const isSpeaking = remoteParticipant.isSpeaking;
  

• videoStreams: Kontrollera samlingen om du vill kontrollera alla videoströmmar som en viss deltagare skickar i det här anropet videoStreams . Den innehåller RemoteVideoStream objekt.

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

• displayName: Om du vill hämta visningsnamnet för den här fjärrdeltagaren kontrollerar du displayName egenskapen som returnerar strängen.

  const displayName = remoteParticipant.displayName;
  

• endpointDetails: Hämta information om alla slutpunkter för den här fjärrdeltagaren

      const endpointDetails: EndpointDetails[] = remoteParticipant.endpointDetails;
  

  Obs! En fjärrdeltagare kan vara i anropet från många slutpunkter och varje slutpunkt har sin egen unika participantId. participantId skiljer sig från RemoteParticipant.identifiers rå-ID.

Stäng av ljudet för andra deltagare

Om du vill stänga av ljudet för alla andra deltagare eller stänga av ljudet för en specifik deltagare som är ansluten till ett anrop kan du använda asynkrona API:er muteAllRemoteParticipants för anropet och mute på fjärrdeltagaren. Händelsen mutedByOthers från anropet aktiveras när den lokala deltagaren har stängts av av andra.

Obs! Scenarier för att stänga av PSTN-deltagare (telefonnummer) eller 1:1-samtalsdeltagare stöds inte.

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

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

Kontrollera anropsegenskaper

Hämta det unika ID:t (strängen) för ett anrop:

const callId: string = call.id;

Hämta det lokala deltagar-ID:t:

const participantId: string = call.info.participantId;

Obs! En Azure Communication Services-identitet kan använda SDK för webbsamtal i många slutpunkter och varje slutpunkt har sin egen unika participantId. participantId skiljer sig från det råa identitets-ID:t för Azure Communication Services.

Hämta tråd-ID:t om du ansluter till ett Teams-möte:

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

Hämta information om samtalet:

const callInfo = call.info;

Lär dig mer om andra deltagare i samtalet genom att remoteParticipants granska samlingen på "samtalsinstansen":

const remoteParticipants = call.remoteParticipants;

Identifiera anroparen för ett inkommande samtal:

const callerIdentity = call.callerInfo.identifier;

identifier är en av typerna CommunicationIdentifier .

Hämta tillståndet för ett samtal:

const callState = call.state;

Detta returnerar en sträng som representerar det aktuella tillståndet för ett anrop:

• None: Inledande anropstillstånd.
• Connecting: Inledande övergångstillstånd när ett anrop görs eller godkänns.
• Ringing: För ett utgående samtal anger att ett samtal ringer för fjärrdeltagare. Det är Incoming på deras sida.
• EarlyMedia: Anger ett tillstånd där ett meddelande spelas upp innan samtalet ansluts.
• Connected: Anger att anropet är anslutet.
• LocalHold: Anger att en lokal deltagare som samtalet spärrade samtalet. Inget media flödar mellan den lokala slutpunkten och fjärrdeltagarna.
• RemoteHold: Anger att en fjärrdeltagare som samtalet spärrade samtalet. Inget media flödar mellan den lokala slutpunkten och fjärrdeltagarna.
• InLobby: Anger att användaren är i lobbyn.
• Disconnecting: Övergångstillstånd innan anropet går till ett Disconnected tillstånd.
• Disconnected: Slutligt anropstillstånd. Om nätverksanslutningen går förlorad ändras tillståndet till Disconnected efter två minuter.

Ta reda på varför ett samtal avslutades genom att inspektera egenskapen callEndReason :

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

Lär dig om det aktuella samtalet är inkommande eller utgående genom att granska egenskapen direction . Den returnerar CallDirection.

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

Granska aktiva videoströmmar och aktiva skärmdelningsströmmar genom att kontrollera localVideoStreams samlingen. API:et localVideoStreams returnerar LocalVideoStream objekt av typen Video, ScreenSharingeller RawMedia.

const localVideoStreams = call.localVideoStreams;

Kontrollera om den aktuella mikrofonen är avstängd. Den returnerar Boolean.

const muted = call.isMuted;

Kontrollera om det aktuella inkommande ljudet (högtalaren) är avstängt. Den returnerar Boolean.

const incomingAudioMuted = call.isIncomingAudioMuted;

Kontrollera om videon är på. Den returnerar Boolean.

const isLocalVideoStarted = call.isLocalVideoStarted;

Kontrollera att skärmdelning är aktiverat. Den returnerar Boolean.

const isScreenSharingOn = call.isScreenSharingOn;

Installera SDK:n

Leta upp filen på projektnivå build.gradle och lägg till mavenCentral() i listan med lagringsplatser under buildscript och allprojects:

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

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

Lägg sedan till följande rader i modulnivåfilen build.gradle i dependencies avsnittet:

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

Initiera nödvändiga objekt

Om du vill skapa en CallAgent instans måste du anropa createCallAgent metoden på en CallClient instans. Det här anropet returnerar asynkront ett CallAgent instansobjekt.

Metoden createCallAgent tar CommunicationUserCredential som ett argument som kapslar in en åtkomsttoken.

Om du vill komma åt DeviceManagermåste du skapa en callAgent instans först. Sedan kan du använda CallClient.getDeviceManager metoden för att hämta 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();

Om du vill ange ett visningsnamn för anroparen använder du den här alternativa metoden:

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

Ringa ett samtal

För att skapa och starta ett anrop måste du anropa CallAgent.startCall() metoden och ange Identifier för de anropade. Om du vill ansluta till ett gruppsamtal måste du anropa CallAgent.join() metoden och ange groupId. Grupp-ID:t måste vara i GUID- eller UUID-format.

Skapande och start av samtal är synkrona. Med samtalsinstansen kan du prenumerera på alla händelser i samtalet.

Placera ett 1:1-anrop till en användare

Om du vill ringa ett anrop till en annan Communication Services-användare anropar call du metoden på callAgent och skickar ett objekt med communicationUserId nyckeln.

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

Placera ett 1:n-samtal med användare och PSTN

Om du vill ringa ett 1:n-samtal till en användare och ett PSTN-nummer måste du ange telefonnummer för den som ringer. Din Communication Services-resurs måste konfigureras för att tillåta PSTN-samtal:

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

Ta emot samtal

Om du vill acceptera ett anrop anropar du metoden "acceptera" för ett anropsobjekt.

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

Så här accepterar du ett samtal med videokameran på:

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

Det inkommande samtalet kan hämtas genom att onIncomingCall prenumerera på händelsen på callAgent objektet:

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

Ansluta till ett rumssamtal

CallAgent Använd och RoomCallLocator för att ansluta ett rumsanrop genom att ange en roomId. Metoden CallAgent.join returnerar ett Call objekt:

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

En room ger programutvecklare bättre kontroll över vem som kan ansluta till ett samtal, när de träffas och hur de samarbetar. Om du vill veta mer om roomskan du läsa den konceptuella dokumentationen eller följa snabbstartsguiden.

Ansluta till ett gruppsamtal

Om du vill starta ett nytt gruppanrop eller ansluta till ett pågående gruppsamtal måste du anropa metoden "join" och skicka ett objekt med en groupId egenskap. Värdet måste vara ett GUID.

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

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

Samtalsegenskaper

Hämta det unika ID:t för det här samtalet:

String callId = call.getId();

Om du vill veta mer om andra deltagare i anropet inspekterar remoteParticipant du samlingen på instansen call :

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

Identiteten för anroparen om samtalet är inkommande:

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

Hämta tillståndet för samtalet:

CallState callState = call.getState();

Den returnerar en sträng som representerar det aktuella tillståndet för ett anrop:

• "NONE" – inledande anropstillstånd
• "EARLY_MEDIA" – anger ett tillstånd där ett meddelande spelas upp innan samtalet ansluts
• "CONNECTING" – inledande övergångstillstånd när anropet har gjorts eller godkänts
• "RINGING" - för ett utgående samtal - indikerar att samtalet ringer för fjärrdeltagare
• "ANSLUTEN" – samtalet är anslutet
• "LOCAL_HOLD" – samtalet spärras av den lokala deltagaren, inget media flödar mellan den lokala slutpunkten och fjärrdeltagare
• "REMOTE_HOLD" – samtalet spärras av en fjärrdeltagare, inga medier flödar mellan den lokala slutpunkten och fjärrdeltagare
• "KOPPLA FRÅN" – övergångstillstånd innan anropet går till tillståndet "Frånkopplad"
• "FRÅNKOPPLAD" – slutligt anropstillstånd
• "IN_LOBBY" – i lobbyn för ett Teams-mötessamverkans

Om du vill veta varför ett samtal avslutades kontrollerar du callEndReason egenskapen. Den innehåller kod/underkod:

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

Om du vill se om det aktuella samtalet är ett inkommande eller utgående samtal kontrollerar du callDirection egenskapen:

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

Om du vill se om den aktuella mikrofonen är avstängd kontrollerar du egenskapen muted :

boolean muted = call.isMuted();

Om du vill granska aktiva videoströmmar kontrollerar du localVideoStreams samlingen:

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

Slå av och på ljud

Om du vill stänga av eller slå på ljudet för den lokala slutpunkten kan du använda de mute asynkrona API:erna:unmute

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

Ändra volymen för anropet

När du är i ett samtal bör maskinvaruvolymnycklarna på telefonen göra det möjligt för användaren att ändra samtalsvolymen. Detta görs med hjälp av metoden setVolumeControlStream med strömtypen AudioManager.STREAM_VOICE_CALL på aktiviteten där anropet görs. Detta gör att maskinvaruvolymnycklarna kan ändra volymen för samtalet (som anges av en telefonikon eller något liknande på volymreglaget), vilket förhindrar att volymen ändras för andra ljudprofiler, till exempel larm, media eller systemomfattande volym. Mer information finns i Hantera ändringar i ljudutdata | Android-utvecklare.

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

Hantering av fjärrdeltagare

Alla fjärrdeltagare representeras av RemoteParticipant typen och är tillgängliga via remoteParticipants samlingen på en samtalsinstans.

Visa en lista över deltagare i ett samtal

Samlingen remoteParticipants returnerar en lista över fjärranslutna deltagare i ett visst anrop:

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

Lägga till en deltagare i ett anrop

Om du vill lägga till en deltagare i ett samtal (antingen en användare eller ett telefonnummer) kan du anropa addParticipant. Detta returnerar synkront fjärrdeltagareinstansen.

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

Ta bort deltagare från ett anrop

Om du vill ta bort en deltagare från ett samtal (antingen en användare eller ett telefonnummer) kan du anropa removeParticipant. Detta löser asynkront när deltagaren har tagits bort från anropet. Deltagaren tas också bort från remoteParticipants samlingen.

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

Egenskaper för fjärrdeltagare

En viss fjärrdeltagare har en uppsättning egenskaper och samlingar som är associerade med den:

• Hämta identifieraren för den här fjärrdeltagaren. Identitet är en av typerna "Identifierare"

  CommunicationIdentifier participantIdentifier = remoteParticipant.getIdentifier();
  

• Hämta tillstånd för den här fjärrdeltagaren.

  ParticipantState state = remoteParticipant.getState();
  

Tillståndet kan vara ett av

• "INAKTIV" – inledande tillstånd

• "EARLY_MEDIA" – meddelandet spelas upp innan deltagaren är ansluten till samtalet

• "RINGNING" – deltagarsamtalet ringer

• "ANSLUTA" – övergångstillstånd när deltagaren ansluter till anropet

• "ANSLUTEN" – deltagaren är ansluten till anropet

• "HOLD" – deltagaren är pausad

• "IN_LOBBY" - deltagare väntar i lobbyn för att släppas in. Används för närvarande endast i Teams interop-scenario

• "DISCONNECTED" – slutligt tillstånd – deltagaren är frånkopplad från anropet

• Om du vill veta varför en deltagare lämnade samtalet kontrollerar du callEndReason egenskapen:

  CallEndReason callEndReason = remoteParticipant.getCallEndReason();
  

• Om du vill kontrollera om den här fjärrdeltagaren är avstängd eller inte kontrollerar du egenskapen isMuted :

  boolean isParticipantMuted = remoteParticipant.isMuted();
  

• Om du vill kontrollera om den här fjärrdeltagaren talar eller inte kontrollerar du egenskapen isSpeaking :

  boolean isParticipantSpeaking = remoteParticipant.isSpeaking();
  

• Om du vill kontrollera alla videoströmmar som en viss deltagare skickar i det här anropet videoStreams kontrollerar du samlingen:

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

Stäng av ljudet för andra deltagare

Om du vill stänga av ljudet för alla andra deltagare i ett anrop använder du API:et muteAllRemoteParticipants för anropet.

call.muteAllRemoteParticipants();

Om du vill stänga av en specifik fjärrdeltagare använder du API:et mute på en viss fjärrdeltagare.

remoteParticipant.mute();

Om du vill meddela den lokala deltagaren att de har stängts av av andra prenumererar du på onMutedByOthers händelsen.

Använda förgrundstjänster

Om du vill köra en användar synlig uppgift även när programmet är i bakgrunden kan du använda Foreground Services.

Med foreground Services kan du till exempel hålla en användare synlig när programmet har ett aktivt anrop. På så sätt fortsätter anropet att vara aktivt även om användaren går till startskärmen eller tar bort programmet från den senaste skärmen.

Om du inte använder en förgrundstjänst när du är i ett anrop kan du gå till startskärmen för att hålla samtalet aktivt, men om du tar bort programmet från den senaste skärmen kan du stoppa samtalet om Android-operativsystemet avbryter programmets process.

Du bör starta förgrundstjänsten när du startar/ansluter ett anrop, till exempel:

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

Och stoppa förgrundstjänsten när du lägger på anropet eller samtalets status är Frånkopplad, till exempel:

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

Information om hur du använder Foreground Services

Tänk på att scenarier som att stoppa en förgrundstjänst som redan körs när appen tas bort från den senaste listan tar bort användarens synliga meddelande och Android-operativsystemet kan hålla programprocessen vid liv under en extra tidsperiod, vilket innebär att anropet fortfarande kan vara aktivt under den här perioden.

Om programmet till exempel stoppar förgrundstjänsten på tjänstmetoden onTaskRemoved kan programmet starta/stoppa ljud och video enligt aktivitetslivscykeln, till exempel stoppa ljud och video när aktiviteten förstörs med onDestroy metodens åsidosättning.

Konfigurera systemet

Följ de här stegen för att konfigurera systemet.

Skapa Xcode-projektet

I Xcode skapar du ett nytt iOS-projekt och väljer mallen Enkel vyapp . Den här artikeln använder SwiftUI-ramverket, så du bör ange Language till Swift och ange Gränssnitt till SwiftUI.

Du kommer inte att skapa tester i den här artikeln. Avmarkera kryssrutan Inkludera tester .

Installera paketet och beroenden med hjälp av CocoaPods

1. Skapa en Podfile för ditt program, som i det här exemplet:

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

2. Kör pod install.

3. Öppna .xcworkspace med Xcode.

Begär åtkomst till mikrofonen

För att få åtkomst till enhetens mikrofon måste du uppdatera appens egenskapslista för information med hjälp NSMicrophoneUsageDescriptionav . Ange det associerade värdet till en sträng som ingår i dialogrutan som systemet använder för att begära åtkomst från användaren.

Högerklicka på posten Info.plist i projektträdet och välj sedan Öppna som>källkod. Lägg till följande rader i avsnittet på den översta nivån <dict> och spara sedan filen.

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

Konfigurera appramverket

Öppna projektets ContentView.swift fil. Lägg till en import deklaration överst i filen för att importera AzureCommunicationCalling biblioteket. Importera dessutom AVFoundation. Du behöver den för begäranden om ljudbehörighet i koden.

import AzureCommunicationCalling
import AVFoundation

Initiera CallAgent

Om du vill skapa en CallAgent instans från CallClientmåste du använda en callClient.createCallAgent metod som asynkront returnerar ett CallAgent objekt när det har initierats.

Skicka ett CommunicationTokenCredential objekt för att skapa en anropsklient:

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

Skicka objektet CommunicationTokenCredential som du skapade till CallClientoch ange visningsnamnet:

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

Ringa ett utgående samtal

För att skapa och starta ett anrop måste du anropa ett av API:erna på CallAgent och ange kommunikationstjänsternas identitet för en användare som du har etablerat med hjälp av Communication Services Management SDK.

Skapande och start av samtal är synkrona. Du får en samtalsinstans som gör att du kan prenumerera på alla händelser i samtalet.

Ringa ett 1:1-samtal till en användare eller ett 1:n-samtal med användare och PSTN

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

Placera ett 1:n-samtal med användare och PSTN

Om du vill ringa till PSTN måste du ange ett telefonnummer som hämtats med Communication Services.

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

Ansluta till ett rumssamtal

Om du vill ansluta ett room anrop anger du roomId egenskapen som identifierare room . Om du vill ansluta anropet använder du join metoden och skickar 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)
    }
}

En room ger programutvecklare bättre kontroll över vem som kan ansluta till ett samtal, när de träffas och hur de samarbetar. Om du vill veta mer om roomskan du läsa den konceptuella dokumentationen eller följa snabbstartsguiden.

Ansluta till ett gruppsamtal

Om du vill ansluta till ett anrop måste du anropa ett av API:erna på 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")
    }
}

Prenumerera på ett inkommande samtal

Prenumerera på en inkommande samtalshändelse.

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

Acceptera ett inkommande samtal

Om du vill acceptera ett anrop anropar du metoden för accept ett IncomingCall objekt.

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

Utföra åtgärder mitt i anropet

Du kan utföra olika åtgärder under ett anrop för att hantera inställningar som rör video och ljud.

Slå av och på ljud

Om du vill stänga av eller slå på den lokala slutpunkten kan du använda de mute asynkrona API:erna och unmute .

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

Använd följande kod för att slå på ljudet för den lokala slutpunkten asynkront.

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

Hantera fjärrdeltagare

Alla fjärrdeltagare representeras av typen RemoteParticipant och är tillgängliga via remoteParticipants samlingen på en samtalsinstans.

Visa en lista över deltagare i ett samtal

call.remoteParticipants

Lägga till en deltagare i ett anrop

Om du vill lägga till en deltagare i ett samtal (antingen en användare eller ett telefonnummer) kan du anropa addParticipant. Det här kommandot returnerar synkront en fjärrdeltagareinstans.

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

Ta bort en deltagare från ett anrop

Om du vill ta bort en deltagare från ett samtal (antingen en användare eller ett telefonnummer) kan du anropa API:et removeParticipant . Detta löser asynkront.

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

Hämta egenskaper för fjärrdeltagare

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

Stäng av ljudet för andra deltagare

Om du vill stänga av ljudet för alla andra deltagare i ett anrop använder du API:et muteAllRemoteParticipants för anropet.

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

Om du vill stänga av en specifik fjärrdeltagare använder du API:et mute på en viss fjärrdeltagare.

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

Om du vill meddela den lokala deltagaren att de har stängts av av andra prenumererar du på onMutedByOthers händelsen.

Konfigurera systemet

Följ de här stegen för att konfigurera systemet.

Skapa Visual Studio-projektet

För en Universell Windows-plattform app skapar du i Visual Studio 2022 ett nytt projekt för Tom app (Universell Windows). När du har angett projektnamnet kan du välja valfri Windows SDK senare än 10.0.17763.0.

För en WinUI 3-app skapar du ett nytt projekt med mallen Tom app, Paketerad (WinUI 3 i Desktop) för att konfigurera en WinUI 3-app med en enda sida. SDK för Windows-appar version 1.3 eller senare krävs.

Installera paketet och beroendena med hjälp av NuGet Package Manager

Anropande SDK-API:er och bibliotek är offentligt tillgängliga via ett NuGet-paket.

Så här hittar du, laddar ned och installerar det anropande SDK NuGet-paketet:

1. Öppna NuGet Package Manager genom att välja Verktyg>NuGet Package Manager>Hantera NuGet-paket för lösning.
2. Välj Bläddra och ange sedan Azure.Communication.Calling.WindowsClient i sökrutan.
3. Kontrollera att kryssrutan Inkludera förhandsversion är markerad.
4. Välj paketet Azure.Communication.Calling.WindowsClient och välj sedan Azure.Communication.Calling.WindowsClient 1.4.0-beta.1 eller en nyare version.
5. Markera kryssrutan som motsvarar Azure Communication Services-projektet i den högra rutan.
6. Välj Installera.

Begär åtkomst till mikrofonen

Appen kräver åtkomst till mikrofonen för att kunna köras korrekt. I UWP-appar ska mikrofonfunktionen deklareras i appens manifestfil.

Följande steg illustrerar hur du kan uppnå detta.

1. Dubbelklicka på filen med .appxmanifest filnamnstillägget Solution Explorer i panelen.
2. Klicka på fliken Capabilities .
3. Markera kryssrutan Microphone i listan över funktioner.

Skapa användargränssnittsknappar för att placera och lägga på anropet

Den här enkla exempelappen innehåller två knappar. En för att ringa samtalet och en annan för att hänga upp ett uppringt samtal. Följande steg illustrerar hur du lägger till dessa knappar i appen.

1. Solution Explorer Dubbelklicka på filen med namnet MainPage.xaml UWP i panelen eller MainWindows.xaml för WinUI 3.
2. I den centrala panelen letar du efter XAML-koden under förhandsversionen av användargränssnittet.
3. Ändra XAML-koden med följande utdrag:

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

Konfigurera appen med anropande SDK-API:er

Api:erna för anropande SDK finns i två olika namnområden. Följande steg informerar C#-kompilatorn om dessa namnområden så att Visual Studio Intellisense kan hjälpa till med kodutveckling.

1. I panelen Solution Explorer klickar du på pilen till vänster i filen med namnet MainPage.xaml UWP eller MainWindows.xaml för WinUI 3.
2. Dubbelklicka på filen med namnet MainPage.xaml.cs eller MainWindows.xaml.cs.
3. Lägg till följande kommandon längst ned i de aktuella using instruktionerna.

using Azure.Communication.Calling.WindowsClient;

Behåll MainPage.xaml.cs eller MainWindows.xaml.cs öppna. Nästa steg lägger till mer kod i den.

Tillåt appinteraktioner

Användargränssnittsknapparna som tidigare lagts till måste fungera ovanpå en placerad CommunicationCall. Det innebär att en CommunicationCall datamedlem ska läggas till i MainPage klassen eller MainWindow . För att den asynkrona åtgärden som skapas CallAgent ska lyckas bör en CallAgent datamedlem dessutom läggas till i samma klass.

Lägg till följande datamedlemmar i MainPage pr-klassen MainWindow :

CallAgent callAgent;
CommunicationCall call;

Skapa knapphanterare

Tidigare lades två användargränssnittsknappar till i XAML-koden. Följande kod lägger till de hanterare som ska köras när en användare väljer knappen. Följande kod ska läggas till efter datamedlemmarna från föregående avsnitt.

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

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

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Calling-klientbiblioteket för UWP.

Initiera CallAgent

Om du vill skapa en CallAgent instans från CallClientmåste du använda CallClient.CreateCallAgentAsync en metod som asynkront returnerar ett CallAgent objekt när det har initierats.

Om du vill skapa CallAgentmåste du skicka ett CallTokenCredential objekt och ett CallAgentOptions objekt. Tänk på att CallTokenCredential genererar om en felaktig token skickas.

Följande kod bör läggas till i och hjälpfunktionen som ska anropas i appinitiering.

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

Ändra med en giltig token för autentiseringsuppgifter för resursen <AUTHENTICATION_TOKEN> . Se dokumentationen för användaråtkomsttoken om en token för autentiseringsuppgifter måste hämtas.

Skapa CallAgent och placera ett anrop

De objekt som behövs för att skapa en CallAgent är nu klara. Det är dags att asynkront skapa CallAgent och placera ett anrop.

Följande kod bör läggas till efter hanteringen av undantaget från föregående steg.

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;

Använd gärna 8:echo123 för att prata med Azure Communication Services-ekoroboten.

Slå av och på ljud

Om du vill stänga av eller inaktivera utgående ljud kan du använda de MuteOutgoingAudioAsync asynkrona API:erna:UnmuteOutgoingAudioAsync

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

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

Stäng av ljudet för andra deltagare

Om du vill stänga av ljudet för alla andra deltagare eller stänga av ljudet för en specifik deltagare kan du använda asynkrona API:er MuteAllRemoteParticipantsAsync för anropet och MuteAsync på fjärrdeltagaren:

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

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

Om du vill meddela den lokala deltagaren att de har stängts av av andra prenumererar du på MutedByOthers händelsen.

Avsluta samtal

När ett anrop har placerats HangupAsync ska -metoden CommunicationCall för objektet användas för att lägga på anropet.

En instans av HangupOptions bör också användas för att informera om samtalet måste avslutas till alla deltagare.

Följande kod bör läggas till i HangupButton_Click.

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

Kör koden

Se till att Visual Studio skapar appen för , x86 eller ARM64och tryck F5 sedan på för x64att börja köra appen. Därefter klickar du på Call knappen för att ringa ett anrop till den definierade anropare.

Tänk på att första gången appen körs uppmanar systemet användaren att bevilja åtkomst till mikrofonen.