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

Hantera SDK-anslutning till Microsoft-infrastruktur

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. 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 connectionStatus-värde för Disconnected tillstånd säger att det finns ett problem som hindrar SDK:n från att ansluta korrekt. Call Agent bör återskapas.

• invalidToken: Om en token har upphört att gälla eller är ogiltig kopplas Call Agent-instansen bort med det här felet.
• connectionIssue: Om det finns ett problem med att klienten ansluter till Microsoft-infrastrukturen, efter många återförsök exponerar Call AgentconnectionIssue-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 du startCall-metoden på callAgent och skickar mottagarens CommunicationUserIdentifier, som du har skapade med Communication Services-administrationsbiblioteket.

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

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 uppringar-ID. Ett alternativt uppringnings-ID är ett telefonnummer (baserat på E.164-standarden) som visar vem som ringer 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. För att ansluta till samtalet använder du join-metoden genom att skicka 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. Mer information om rum finns i Rums-API för strukturerade möten och Delta i ett rumssamtal.

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 genererar en cameraStartFailed: true 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 videon avstängd. Kameran kanske inte är tillgänglig eftersom den används av en annan process eller är inaktiverad i operativsystemet.

Pausa och återuppta anrop

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

För att lägga samtalet i vänteläge:

await call.hold();

När hold åtgärden löses är anropstillståndet inställt på LocalHold. I ett 1:1-samtal sätts även den andra deltagaren på håll, och samtalets tillstånd från den andra 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 stoppar inte samtalet för andra deltagare.

För att återuppta samtalet måste alla användare som satt samtalet på paus återuppta det.

Återuppta samtalet från väntläge:

await call.resume();

När åtgärden resume löses anges anropstillståndet igen till Connected.

Stäng av och sätt på ljudet för ett samtal

För att stänga av eller slå på ljudet för den lokala slutpunkten, använd de asynkrona API:erna mute och 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 för inkommande ljud, använder du de asynkrona åtgärderna muteIncomingAudio och 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 högtalaren och deltagaren kan inte lyssna förrän det anropas call.unmuteIncomingAudio() . Vi kan dock använda ett filter på samtalsljud och spela upp det filtrerade ljudet.

Hantera fjärrdeltagare

Alla fjärrdeltagare ingår i RemoteParticipant objektet och är tillgängliga via remoteParticipants samlingen på en samtalsinstans. Objektet remoteParticipants är tillgängligt 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 använder du åtgärden addParticipant . Ange en av typerna Identifier . Den returnerar synkront instansen remoteParticipant . När en deltagare har lagts till i samtalet genereras Anrop-händelsen remoteParticipantsUpdated.

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 ringa removeParticipant. Du måste godkänna en av Identifier-typerna. 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
  

  Kommentar

  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: För att inspektera alla videoströmmar som en viss deltagare skickar i det här samtalet, kontrollera videoStreams-samlingen. Den innehåller RemoteVideoStream objekt.

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

• displayName: Om du vill hämta visningsnamnet för den här fjärrdeltagaren, inspektera displayName-egenskapen; den returnerar en sträng.

  const displayName = remoteParticipant.displayName;
  

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

  const endpointDetails: EndpointDetails[] = remoteParticipant.endpointDetails;
  

  Kommentar

  En fjärrdeltagare kan vara i anropet från många möjliga slutpunkter och varje slutpunkt har sin egen unika participantId. participantId skiljer sig från identifierarens RemoteParticipant 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 stängs av av andra.

Att stänga av ljudet på en PSTN-endpunkt med hjälp av WebJS-anrops-SDK är för närvarande i allmänt tillgängligt läge och finns i version 1.34.1 1.34.1 och senare versioner.

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

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 inspektera remoteParticipants samlingen på instansen call.

const remoteParticipants = call.remoteParticipants;

Identifiera anroparen för ett inkommande samtal:

const callerIdentity = call.callerInfo.identifier;

identifier är en av typerna CommunicationIdentifier .

Hämta statusen 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 anropsstatus.
• 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: Visar att en lokal deltagare har satt samtalet i vänteläge. 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. Åtgärden 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;

Lägga på

Det finns två sätt att lägga på samtalet.

• Den första uppringaren kan lämna samtalet och de andra deltagarna är kvar i samtalet.
• När den första anroparen lämnar avslutas samtalet för alla deltagare.

Om du vill lämna samtalet använder du:

call.hangUp();

Avsluta samtalet för alla deltagare genom att ange HangUpOptions.

call.hangUp( forEveryone: true);

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

Om du vill skapa och starta ett anrop måste du anropa CallAgent.startCall() metoden och ange Identifier mottagarens eller mottagarnas.

Om du vill ansluta till ett gruppanrop 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 samtal till en annan Communication Services-användare, anropar du call-metoden på callAgent och skickar ett objekt med nyckeln 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);

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

För att kunna ringa ett 1:n-samtal till en användare och ett pstn-nummer (public switched phone network) måste du ange mottagarens eller mottagarnas telefonnummer.

Din Communication Services-resurs måste konfigureras för att aktivera 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

För att acceptera ett samtal, anropa accept-metoden på ett samtalsobjekt.

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

Hämta det inkommande samtalet 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. Mer information om rum finns i Rums-API för strukturerade möten och Delta i ett rumssamtal.

Ansluta till ett gruppsamtal

Om du vill starta ett nytt gruppanrop eller ansluta till ett pågående gruppanrop måste du anropa join metoden 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();

För att lära dig mer om andra deltagare i samtalet, inspektera samlingen remoteParticipant 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 ringts eller godkänts
• RINGING - för ett utgående samtal - anger att samtalet ringer för fjärrdeltagare
• CONNECTED – samtal anslutet
• LOCAL_HOLD - samtal som lagts i vänteläge av lokal deltagare utan att media flödar mellan den lokala enheten och de fjärranslutna deltagarna
• REMOTE_HOLD - samtal som spärrats av en fjärrdeltagare utan media som flödar mellan den lokala slutpunkten och fjärrdeltagarna
• DISCONNECTING – övergångstillstånd innan anropet går till Disconnected tillståndet
• DISCONNECTED - Slutligt samtalstillstånd
• IN_LOBBY – i lobbyn vid ett Teams-mötesinteroperabilitet

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

Medan deltagarna är i ett samtal bör maskinvaruvolymnycklarna på telefonen göra det möjligt för användaren att ändra samtalsvolymen.

Använd metoden setVolumeControlStream med strömtypen AudioManager.STREAM_VOICE_CALL på aktiviteten där anropet sker.

Med den här metoden kan maskinvaruvolymnycklarna ändra volymen för samtalet, som anges av en telefonikon eller något liknande i volymreglaget. Det förhindrar också volymändringar av andra ljudprofiler, till exempel larm, media eller systemomfattande volymer. 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 har typen RemoteParticipant 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 åtgärden addParticipant .

Den här åtgärden 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 åtgärden removeParticipant .

Den här åtgärden löser sig 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 associerade egenskaper och samlingar:

• Hämta identifieraren för den här fjärrdeltagaren.

Identitet är en av typerna Identifier :

CommunicationIdentifier participantIdentifier = remoteParticipant.getIdentifier();

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

  ParticipantState state = remoteParticipant.getState();
  

Tillståndet kan vara något av:

• IDLE - initialt tillstånd

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

• RINGING - deltagarsamtalet ringer

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

• CONNECTED - deltagaren är ansluten till samtalet

• HOLD - deltagaren väntar

• IN_LOBBY - deltagare väntar i lobbyn för att bli antagen. Används för närvarande endast i Teams interop-scenario

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

• 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

När en PSTN-deltagare stängs av får de ett meddelande om att de är avstängda och att de kan trycka på en tangentkombination (till exempel *6) för att slå på ljudet. När de trycker på *6 tystas de upp.

Om du vill stänga av ljudet för alla andra deltagare i ett anrop använder du API-åtgärden muteAllRemoteParticipants .

call.muteAllRemoteParticipants();

Om du vill stänga av en specifik fjärrdeltagare använder du mute API-åtgärden på en viss fjärrdeltagare.

remoteParticipant.mute();

För att meddela den lokala deltagaren att de är avstängda 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 Förgrundstjänster.

Använd till exempel Foreground Services för att ge användarna ett synligt meddelande 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 en användare startar eller ansluter ett anrop, till exempel:

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

Du bör också stoppa förgrundstjänsten när du avslutar samtalet eller samtalets status är Frånkopplad, till exempel:

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

Detaljer om förgrundstjänsten

Tänk på att scenarier som att stoppa en Foreground Service som redan körs när appen tas bort från listan över senaste appar tar bort det användarsynliga meddelandet. I det här fallet kan Android-operativsystemet hålla programprocessen vid liv under en viss extra tidsperiod, vilket innebär att anropet kan förbli aktivt under den här perioden.

Om programmet stoppar förgrundstjänsten på tjänstmetoden onTaskRemoved kan ditt program till exempel starta eller stoppa ljud och video enligt din aktivitetslivscykel. Till exempel att stoppa ljud och video när din aktivitet förstörs med metoden onDestroy åsidosatt.

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 informationslista med hjälp av NSMicrophoneUsageDescription. 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 ett 1:n-samtal till en användare och ett offentligt kopplat telefonnät (PSTN) måste du ange ett telefonnummer som köpts med Kommunikationstjänster.

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

För att ansluta till ett room-samtal, ange egenskapen roomId som room-identifierare. Om du vill ansluta till samtalet använder du join-metoden och passerar 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. Mer information om rum finns i Rums-API för strukturerade möten och Delta i ett rumssamtal.

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 å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 avaktivera ljuddämpning på den lokala slutpunkten asynkront.

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

Hantera fjärrdeltagare

Typen RemoteParticipant representerar alla fjärrdeltagare. De ä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 som antingen en användare eller ett telefonnummer anropar du åtgärden addParticipant . Den här åtgärden 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 som en användare eller ett telefonnummer anropar du åtgärden removeParticipant . Den här åtgärden utförs 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

När en PSTN-deltagare stängs av får de ett meddelande om att de är avstängda och att de kan trycka på en tangentkombination (till exempel *6) för att slå på ljudet. När de trycker på *6 låsas ljudet upp.

Om du vill stänga av ljudet för alla andra deltagare i ett anrop använder du muteAllRemoteParticipants åtgärden 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 viss fjärrdeltagare använder du åtgärden mute på en viss fjärrdeltagare.

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

För att meddela den lokala deltagaren att de är avstängda 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 app för plattformen Universell Windows skapar du ett nytt projekt i Visual Studio 2022, Tom applikation (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, laddar du ned och installerar Calling 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.WindowsClient1.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.

Implementera exempelappen i Visual Studio

I det här avsnittet beskrivs hur du utvecklar appen för att hantera anrop som fungerar i Visual Studio.

Begär åtkomst till mikrofonen

Appen kräver åtkomst till mikrofonen. I UWP-appar (Universal Windows Platform) måste mikrofonfunktionen deklareras i appmanifestfilen.

Så här kommer du åt mikrofonen:

1. I panelen, dubbelklicka på filen med Solution Explorer-tillägget.
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 exempelappen innehåller två knappar. En för att ringa samtalet och en annan för att hänga upp ett uppringt samtal.

Lägg till två 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, vilket gör det möjligt för Visual Studio Intellisense att 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.

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

Namn	beskrivning
CallClient	CallClient är huvudinmatningspunkten till klientbiblioteket För samtal.
CallAgent	CallAgent Används för att starta och ansluta anrop.
CommunicationCall	CommunicationCall Används för att hantera placerade eller anslutna anrop.
CommunicationTokenCredential	CommunicationTokenCredential Används som tokenautentiseringsuppgifter för att instansiera CallAgent.
CallAgentOptions	CallAgentOptions Innehåller information för att identifiera anroparen.
HangupOptions	Informerar HangupOptions om ett samtal ska avslutas till alla dess deltagare.

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.

Om du vill anropa under appinitieringen lägger du till följande kod i och hjälpfunktionen.

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> . Om du behöver hämta en token för autentiseringsuppgifter kan du läsa användaråtkomsttoken.

Skapa CallAgent och placera ett anrop

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

Lägg till följande kod efter att du har hanterat 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 8:echo123 för att prata med Azure Communication Services-ekoroboten.

Slå av och på ljud

För att stänga av eller slå på det utgående ljudet, använd de asynkrona operationerna MuteOutgoingAudioAsync och UnmuteOutgoingAudioAsync.

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

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

Stäng av ljudet för andra deltagare

När en PSTN-deltagare är avstängd måste de få ett meddelande om att de har stängts av och att de kan trycka på en tangentkombination (till exempel *6) för att slå på ljudet. När de trycker på *6 måste de avaktiveras.

Om du vill stänga av ljudet för alla andra deltagare eller stänga av ljudet för en specifik deltagare använder du de asynkrona åtgärderna MuteAllRemoteParticipantsAsync i 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();

För att meddela den lokala deltagaren att de är avstängda av andra, prenumererar du på MutedByOthers-händelsen.

Avsluta samtal

När ett anrop har ringts använder du HangupAsync -metoden för CommunicationCall objektet för att lägga på anropet.

Använd en instans av HangupOptions för att informera alla deltagare om samtalet måste avslutas.

Lägg till följande kod i HangupButton_Click:

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

Kör koden

1. Se till att Visual Studio skapar appen för x64, x86 eller ARM64.
2. Tryck på F5 för att börja köra appen.
3. När appen körs klickar du på knappen Samtal för att ringa ett anrop till den definierade mottagaren.

Första gången appen körs uppmanar systemet användaren att bevilja åtkomst till mikrofonen.