Alzare gli stati della mano

Importante

Questa funzionalità di Servizi di comunicazione di Azure è attualmente in anteprima. Le funzionalità in anteprima sono disponibili pubblicamente e possono essere usate da tutti i clienti Microsoft nuovi ed esistenti.

Questa versione di anteprima viene fornita senza contratto di servizio, pertanto se ne sconsiglia l’uso per i carichi di lavoro in ambienti di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero essere vincolate.

Per altre informazioni, vedere Condizioni per l'utilizzo supplementari per le anteprime di Microsoft Azure.

Importante

Questa funzionalità di Servizi di comunicazione di Azure è attualmente in anteprima. Le funzionalità in anteprima sono disponibili pubblicamente e possono essere usate da tutti i clienti Microsoft nuovi ed esistenti.

Questa versione di anteprima viene fornita senza contratto di servizio, pertanto se ne sconsiglia l’uso per i carichi di lavoro in ambienti di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero essere vincolate.

Per altre informazioni, vedere Condizioni per l'utilizzo supplementari per le anteprime di Microsoft Azure.

Importante

Questa funzionalità di Servizi di comunicazione di Azure è attualmente in anteprima. Le funzionalità in anteprima sono disponibili pubblicamente e possono essere usate da tutti i clienti Microsoft nuovi ed esistenti.

Questa versione di anteprima viene fornita senza contratto di servizio, pertanto se ne sconsiglia l’uso per i carichi di lavoro in ambienti di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero essere vincolate.

Per altre informazioni, vedere Condizioni per l'utilizzo supplementari per le anteprime di Microsoft Azure.

Installazione dell'SDK

Usare il comando npm install per installare SDK comuni e di chiamata di Servizi di comunicazione di Azure per JavaScript:

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

Inizializzare gli oggetti necessari

Per la maggior parte delle operazioni di chiamata è necessaria un'istanza di CallClient. Quando si crea una nuova istanza di CallClient, è possibile configurarla con opzioni personalizzate come un'istanza di Logger.

Con l'istanza di CallClient è possibile creare un'istanza di CallAgent chiamando il createCallAgent. Questo metodo restituisce in modo asincrono un oggetto istanza CallAgent.

Il metodo createCallAgent usa CommunicationTokenCredential come argomento. Accetta un token di accesso utente.

È possibile usare il metodo getDeviceManager nell'istanza di CallClient per accedere a deviceManager.

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

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

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

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

Gestire la connettività dell'SDK all'infrastruttura Microsoft

L'istanza Call Agent consente di gestire le chiamate (per partecipare o avviare le chiamate). Per lavorare con l'SDK per chiamate, è necessario connettersi all'infrastruttura Microsoft per ricevere notifiche delle chiamate in arrivo e coordinare altri dettagli delle chiamate. Call Agent ha due possibili stati:

Connesso : un Call Agent valore connectionStatue indica Connected che l'SDK client è connesso e in grado di ricevere notifiche dall'infrastruttura Microsoft.

Disconnesso - Un valore Call Agent di connectionStatus di Disconnected indica un problema che impedisce all'SDK di connettersi correttamente. Call Agent deve essere ricreato.

invalidToken: se un token è scaduto o non è valido l'istanza Call Agent si disconnette con questo errore.
connectionIssue: se si verifica un problema con il client che si connette all'infrastruttura Microsoft, dopo molti tentativi Call Agent espone l'errore connectionIssue .

È possibile verificare se l'infrastruttura locale Call Agent è connessa all'infrastruttura Microsoft controllando il valore corrente della proprietà connectionState. Durante una chiamata attiva è possibile restare in ascolto dell'evento connectionStateChanged per determinare se Call Agent cambia dallo stato Connesso a Disconnesso .

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

La funzionalità Alza mano consente ai partecipanti di una chiamata di indicare che hanno una domanda, un commento o un problema senza interrompere il relatore o altri partecipanti. È possibile usare questa funzionalità in qualsiasi tipo di chiamata, incluse le chiamate e le chiamate 1:1 con molti partecipanti, nel Servizio di comunicazione di Azure e nelle chiamate di Teams.

Prima di tutto è necessario importare le funzionalità chiamante da Calling SDK:

import { Features} from "@azure/communication-calling";

È quindi possibile ottenere l'oggetto API della funzionalità dall'istanza di chiamata:

const raiseHandFeature = call.feature(Features.RaiseHand );

Mano alzata e abbassata per il partecipante corrente

Per modificare lo stato Alza mano per il partecipante corrente, è possibile utilizzare i raiseHand() metodi e lowerHand() .

Questi metodi sono asincroni. Per verificare i risultati, usare i listener raisedHandChanged e loweredHandChanged.

const raiseHandFeature = call.feature(Features.RaiseHand );
//raise
raiseHandFeature.raiseHand();
//lower
raiseHandFeature.lowerHand();

Mani inferiori per altri partecipanti

Questa funzionalità consente agli utenti con i ruoli Organizzatore e Relatore di abbassare tutte le mani per altri partecipanti alle chiamate di Teams. Nelle chiamate di comunicazione di Azure non è possibile modificare lo stato di altri partecipanti, a meno che non si aggiungono prima i ruoli.

Per usare questa funzionalità, implementare il codice seguente:

const raiseHandFeature = call.feature(Features.RaiseHand );
//lower all hands on the call
raiseHandFeature.lowerAllHands();
//or we can provide array of CommunicationIdentifier to specify list of participants
CommunicationUserIdentifier acsUser = new CommunicationUserIdentifier(<USER_ID>);
MicrosoftTeamsUserIdentifier teamsUser = new MicrosoftTeamsUserIdentifier(<USER_ID>)
CommunicationIdentifier participants[] = new CommunicationIdentifier[]{ acsUser, teamsUser };
raiseHandFeature.lowerHands(participants);

Gestire gli stati modificati

Con l'API Raise Hand è possibile sottoscrivere gli raisedHandChanged eventi e loweredHandChanged per gestire le modifiche nello stato dei partecipanti in una chiamata. L'istanza di chiamata attiva questi eventi e fornisce informazioni sul partecipante il cui stato è cambiato.

Per sottoscrivere questi eventi, usare il codice seguente:

const raiseHandFeature = call.feature(Features.RaiseHand );

// event : {identifier: CommunicationIdentifier}
const raisedHandChangedHandler = (event) => {
    console.log(`Participant ${event.identifier} raised hand`);
};
const loweredHandChangedHandler = (event) => {
    console.log(`Participant ${event.identifier} lowered hand`);
};
raiseHandFeature.on('raisedHandEvent', raisedHandChangedHandler):
raiseHandFeature.on('loweredHandEvent', loweredHandChangedHandler):

Gli raisedHandChanged eventi e loweredHandChanged contengono un oggetto con la identifier proprietà , che rappresenta l'identificatore di comunicazione del partecipante. Nell'esempio precedente viene registrato un messaggio nella console che indica che un partecipante ha alzato la mano.

Per annullare la sottoscrizione agli eventi, usare il off metodo .

Elenco di tutti i partecipanti con stato attivo

Per ottenere informazioni su tutti i partecipanti che hanno la mano alzata durante la chiamata corrente, è possibile usare getRaisedHands. La matrice restituita viene ordinata in base al campo dell'ordine.

Ecco un esempio di come usare getRaisedHands:

const raiseHandFeature = call.feature(Features.RaiseHand );
let participantsWithRaisedHands = raiseHandFeature.getRaisedHands();

Ordine delle mani alzate

La participantsWithRaisedHands variabile contiene una matrice di oggetti partecipante, in cui ogni oggetto ha le proprietà seguenti:

identifier: identificatore di comunicazione del partecipante.
order: l'ordine in cui il partecipante ha alzato la mano.

È possibile usare queste informazioni per visualizzare un elenco di partecipanti con stato Raise Hand e il relativo ordine nella coda.

Installazione dell'SDK

Individuare il file a livello build.gradle di progetto e aggiungere mavenCentral() all'elenco dei repository in buildscript e allprojects:

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

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

Quindi, nel file a livello build.gradle di modulo aggiungere le righe seguenti alla dependencies sezione :

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

Inizializzare gli oggetti necessari

Per creare un'istanza CallAgent, è necessario chiamare il metodo createCallAgent in un'istanza CallClient. Questa chiamata restituisce in modo asincrono un oggetto istanza CallAgent.

Il createCallAgent metodo accetta CommunicationUserCredential come argomento, che incapsula un token di accesso.

Per accedere a DeviceManager, è prima necessario creare un'istanza callAgent. Quindi è possibile usare il metodo CallClient.getDeviceManager per ottenere 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();

Per impostare nome visualizzato per il chiamante, usare questo metodo alternativo:

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

La funzionalità Alza mano consente ai partecipanti di una chiamata di indicare che hanno una domanda, un commento o un problema senza interrompere il relatore o altri partecipanti. È possibile usare questa funzionalità in qualsiasi tipo di chiamata, incluse le chiamate e le chiamate 1:1 con molti partecipanti, nel Servizio di comunicazione di Azure e nelle chiamate di Teams.

Prima di tutto è necessario importare le funzionalità chiamante da Calling SDK:

import com.azure.android.communication.calling.RaiseHandFeature;

È quindi possibile ottenere l'oggetto API della funzionalità dall'istanza di chiamata:

RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND);

Mano alzata e abbassata per il partecipante corrente

Per modificare lo stato Alza mano per il partecipante corrente, è possibile utilizzare i raiseHand() metodi e lowerHand() .

Questi metodi sono asincroni. Per verificare i risultati, usare i listener RaisedHandReceived e LoweredHandReceived.

RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND);
//raise
raiseHandFeature.raiseHand();
//lower
raiseHandFeature.lowerHand();

Mani inferiori per altri partecipanti

Questa funzionalità consente agli utenti con i ruoli Organizzatore e Relatore di abbassare tutte le mani per altri partecipanti alle chiamate di Teams. Nelle chiamate di comunicazione di Azure non è possibile modificare lo stato di altri partecipanti, a meno che non si aggiungono prima i ruoli.

Per usare questa funzionalità, implementare il codice seguente:

RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND);
//lower all hands on the call
raiseHandFeature.lowerAllHands();
//or we can provide array of CommunicationIdentifier to specify list of participants
List<CommunicationIdentifier> identifiers = new ArrayList<>();
CommunicationUserIdentifier acsUser = new CommunicationUserIdentifier(<USER_ID>);
MicrosoftTeamsUserIdentifier teamsUser = new MicrosoftTeamsUserIdentifier(<USER_ID>);
identifiers.add(new CommunicationUserIdentifier("<USER_ID>"));
identifiers.add(new MicrosoftTeamsUserIdentifier("<USER_ID>"));
raiseHandFeature.lowerHands(identifiers);

Gestire gli stati modificati

Usando l'API Raise Hand, è possibile iscriversi agli eventi RaisedHandReceived e LoweredHandReceived per gestire le modifiche nello stato dei partecipanti durante una chiamata. L'istanza di chiamata attiva questi eventi e fornisce informazioni sul partecipante il cui stato è cambiato.

Per sottoscrivere questi eventi, usare il codice seguente:

RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND)

// event example : {identifier: CommunicationIdentifier, isRaised: true, order:1}
call.feature(Features.RAISE_HAND).addOnRaisedHandReceivedListener(raiseHandEvent -> {
    Log.i(TAG, String.format("Raise Hand: %s : %s", Utilities.toMRI(raiseHandEvent.getIdentifier()), raiseHandEvent.isRaised()));
});

Gli RaisedHandReceived eventi e LoweredHandReceived contengono un oggetto con la identifier proprietà , che rappresenta l'identificatore di comunicazione del partecipante. Nell'esempio precedente viene registrato un messaggio nella console che indica che un partecipante ha alzato la mano.

Per annullare la sottoscrizione agli eventi, è possibile usare il off metodo .

Elenco di tutti i partecipanti con stato attivo

Per ottenere informazioni su tutti i partecipanti che hanno la mano alzata durante la chiamata corrente, è possibile usare getRaisedHands. La matrice restituita viene ordinata in base al campo dell'ordine.

Ecco un esempio di come usare getRaisedHands:

RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND);
List<RaiseHand> participantsWithRaisedHands = raiseHandFeature.getRaisedHands();

Ordine delle mani alzate

La participantsWithRaisedHands variabile contiene una matrice di oggetti partecipante, in cui ogni oggetto ha le proprietà seguenti:

identifier: identificatore di comunicazione del partecipante.
order: l'ordine in cui il partecipante ha alzato la mano.

È possibile usare queste informazioni per visualizzare un elenco di partecipanti con stato Raise Hand e il relativo ordine nella coda.

Configurare il sistema

Seguire questa procedura per configurare il sistema.

Creare il progetto Xcode

In Xcode, creare un nuovo progetto iOS e selezionare il modello App a vista singola. Questo articolo usa il framework SwiftUI, quindi è consigliabile impostare Language su Swift e impostare Interface su SwiftUI.

In questo articolo non verranno creati test. Sentiti libero/a di deselezionare la casella di controllo Includi test.

Screenshot che mostra la finestra per la creazione di un progetto in Xcode.

Installare il pacchetto e le dipendenze usando CocoaPods

Creare un file Podfile per l'applicazione, come questo esempio:

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

Eseguire pod install.
Aprire .xcworkspace con Xcode.

Richiedere l'accesso al microfono

Per accedere al microfono del dispositivo, è necessario aggiornare l'elenco delle proprietà informazioni dell'app usando NSMicrophoneUsageDescription. Impostare il valore associato su una stringa inclusa nella finestra di dialogo usata dal sistema per richiedere l'accesso dall'utente.

Fare clic con il pulsante destro del mouse sulla voce Info.plist dell'albero del progetto e quindi scegliere Apri come>codice sorgente. Aggiungere le righe seguenti nella sezione di primo livello <dict> e quindi salvare il file.

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

Configurare il framework dell'app

Aprire il file del ContentView.swift progetto. Aggiungere una dichiarazione import all'inizio del file per importare la libreria AzureCommunicationCalling. Inoltre, importare AVFoundation: È necessario per le richieste di autorizzazione audio nel codice.

import AzureCommunicationCalling
import AVFoundation

Inizializzare CallAgent

Per creare un'istanza CallAgent da CallClient, è necessario usare un metodo callClient.createCallAgent che restituisce in modo asincrono un oggetto CallAgent dopo l'inizializzazione.

Per creare un client di chiamata, passare un oggetto CommunicationTokenCredential:

import AzureCommunication

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

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

Passare l'oggetto CommunicationTokenCredential creato in CallClient e impostare il nome visualizzato:

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

La funzionalità Alza mano consente ai partecipanti di una chiamata di indicare che hanno una domanda, un commento o un problema senza interrompere il relatore o altri partecipanti. È possibile usare questa funzionalità in qualsiasi tipo di chiamata, incluse le chiamate e le chiamate 1:1 con molti partecipanti, nel Servizio di comunicazione di Azure e nelle chiamate di Teams.

Prima di tutto è necessario importare le funzionalità chiamante da Calling SDK:

import AzureCommunicationCalling

È quindi possibile ottenere l'oggetto API della funzionalità dall'istanza di chiamata:

@State var raisehandFeature: RaiseHandCallFeature?

raiseHandFeature = self.call!.feature(Features.raiseHand)

Mano alzata e abbassata per il partecipante corrente

Per modificare lo stato Alza mano per il partecipante corrente, è possibile utilizzare i raiseHand() metodi e lowerHand() .

//publish raise hand state for local participant
raisehandFeature.raiseHand(completionHandler: { (error) in
    if let error = error {
        print ("Feature failed raise a hand %@", error as Error)
    }
})

//remove raise hand state for local participant
raisehandFeature.lowerHand(completionHandler: { (error) in
    if let error = error {
        print ("Feature failed lower hand %@", error as Error)
    }
})

Mani inferiori per altri partecipanti

Questa funzionalità consente agli utenti con i ruoli Organizzatore e Relatore di abbassare tutte le mani per altri partecipanti alle chiamate di Teams. Nelle chiamate di comunicazione di Azure non è possibile modificare lo stato di altri partecipanti, a meno che non si aggiungono prima i ruoli.

Per usare questa funzionalità, implementare il codice seguente:


// remove raise hand states for all participants on the call
raisehandFeature.lowerAllHands(completionHandler: { (error) in
    if let error = error {
        print ("Feature failed lower all hands %@", error as Error)
    }
})

// remove raise hand states for all remote participants on the call
let identifiers = (call?.remoteParticipants.map {$0.identifier})!;
raisehandFeature.lowerHands(participants: identifiers, completionHandler: { (error) in
    if let error = error {
        print ("Feature failed lower hands %@", error as Error)
    }
})

// remove raise hand state of specific user
var identifiers : [CommunicationIdentifier] = []
identifiers.append(CommunicationUserIdentifier("<USER_ID>"))
raisehandFeature.lowerHands(participants: identifiers, completionHandler: { (error) in
    if let error = error {
        print ("Feature failed lower hands %@", error as Error)
    }
})

Gestire gli stati modificati

Con l'API Raise Hand è possibile sottoscrivere gli RaisedHandReceived eventi e LoweredHandReceived per gestire le modifiche nello stato dei partecipanti in una chiamata. L'istanza di chiamata attiva questi eventi e fornisce informazioni sul partecipante il cui stato è cambiato.

Per sottoscrivere questi eventi, usare il codice seguente:

self.callObserver = CallObserver(view:self)

raisehandFeature = self.call!.feature(Features.raiseHand)
raisehandFeature!.delegate = self.callObserver

public class CallObserver : NSObject, RaiseHandCallFeatureDelegate
{
    // event example : {identifier: CommunicationIdentifier}
    public func raiseHandCallFeature(_ raiseHandCallFeature: RaiseHandCallFeature, didReceiveRaisedHand args: RaisedHandChangedEventArgs) {
        os_log("Raise hand feature updated: %s is raised hand", log:log, Utilities.toMri(args.identifier))
        raiseHandCallFeature.raisedHands.forEach { raiseHand in
            os_log("Raise hand active: %s", log:log, Utilities.toMri(raiseHand.identifier))
        }
    }
    public func raiseHandCallFeature(_ raiseHandCallFeature: RaiseHandCallFeature, didReceiveLoweredHand args: LoweredHandChangedEventArgs) {
        os_log("Raise hand feature updated: %s is lowered hand", log:log, Utilities.toMri(args.identifier))
        raiseHandCallFeature.raisedHands.forEach { raiseHand in
            os_log("Raise hand active: %s", log:log, Utilities.toMri(raiseHand.identifier))
        }
    }
}

Gli RaisedHandReceived eventi e LoweredHandReceived contengono un oggetto con la identifier proprietà , che rappresenta l'identificatore di comunicazione del partecipante. Nell'esempio precedente viene registrato un messaggio nella console che indica che un partecipante ha alzato la mano.

Per annullare la sottoscrizione agli eventi, usare il off metodo .

Elenco di tutti i partecipanti con stato attivo

Per ottenere informazioni su tutti i partecipanti che hanno la mano alzata durante la chiamata corrente, è possibile usare getRaisedHands. La matrice restituita viene ordinata in base al campo dell'ordine.

Ecco un esempio di come usare raisedHands:

raisehandFeature = self.call!.feature(Features.raiseHand)
raisehandFeature.raisedHands.forEach { raiseHand in
    os_log("Raise hand active: %s", log:log, Utilities.toMri(raiseHand.identifier))
}

Ordine delle mani alzate

La raisedHands variabile contiene una matrice di oggetti partecipante, in cui ogni oggetto ha le proprietà seguenti:

identifier: identificatore di comunicazione del partecipante.
order: l'ordine in cui il partecipante ha alzato la mano.

È possibile usare queste informazioni per visualizzare un elenco di partecipanti con stato Raise Hand e il relativo ordine nella coda.

Configurare il sistema

Seguire questa procedura per configurare il sistema.

Creare il progetto di Visual Studio

Per un'app UWP (Universal Windows Platform), in Visual Studio 2022 creare un nuovo progetto App vuota (Windows universale). Dopo aver immesso il nome del progetto, è possibile scegliere qualsiasi Windows SDK successivo alla versione 10.0.17763.0.

Per un'app WinUI 3, creare un nuovo progetto con il modello App vuota, con pacchetto (WinUI 3 in Desktop) per impostare un'app WinUI 3 a pagina singola. È necessario Windows App SDK versione 1.3 o successiva.

Installare il pacchetto e le dipendenze usando Gestione pacchetti NuGet

Le API e le librerie di SDK Chiamata sono disponibili pubblicamente tramite un pacchetto NuGet.

Per trovare, scaricare e installare il pacchetto NuGet Calling SDK:

Aprire Gestione pacchetti NuGet selezionando Strumenti>Gestione pacchetti NuGet>Gestisci pacchetti NuGet per la soluzione.
Selezionare Sfoglia e quindi immettere Azure.Communication.Calling.WindowsClient nella casella di ricerca.
Assicurarsi che la casella di controllo Includi versione preliminare sia selezionata.
Selezionare il pacchetto Azure.Communication.Calling.WindowsClient e quindi selezionare Azure.Communication.Calling.WindowsClient1.4.0-beta.1 o una versione più recente.
Selezionare la casella di controllo corrispondente al progetto Servizi di comunicazione di Azure nel riquadro destro.
Selezionare Installa.

La funzionalità Alza mano consente ai partecipanti di una chiamata di indicare che hanno una domanda, un commento o un problema senza interrompere il relatore o altri partecipanti. È possibile usare questa funzionalità in qualsiasi tipo di chiamata, incluse le chiamate e le chiamate 1:1 con molti partecipanti, nel Servizio di comunicazione di Azure e nelle chiamate di Teams.

Prima di tutto è necessario importare le funzionalità chiamante da Calling SDK:

using Azure.Communication.Calling.WindowsClient;

È quindi possibile ottenere l'oggetto API della funzionalità dall'istanza di chiamata:

private RaiseHandCallFeature raiseHandCallFeature;

raiseHandCallFeature = (RaiseHandCallFeature)call.GetCallFeatureExtension(CallFeatureType.RaiseHand);

Mano alzata e abbassata per il partecipante corrente

Per modificare lo stato Alza mano per il partecipante corrente, è possibile utilizzare i raiseHand() metodi e lowerHand() .

Questi metodi sono asincroni. Per verificare i risultati, usare i listener RaisedHandReceived e LoweredhandReceived.

//publish raise hand state for local participant
raiseHandCallFeature.RaiseHandAsync();

//remove raise hand state for local participant
raiseHandCallFeature.LowerHandAsync();

Mani inferiori per altri partecipanti

La funzionalità della mano abbassata per altri partecipanti consente agli utenti con i ruoli Organizzatore e Relatore di abbassare tutte le mani per gli altri partecipanti nelle chiamate di Teams. Nelle chiamate di comunicazione di Azure non è possibile modificare lo stato di altri partecipanti, a meno che non si aggiungono prima i ruoli.

Per usare questa funzionalità, implementare il codice seguente:


// remove raise hand states for all participants on the call
raiseHandCallFeature.LowerAllHandsAsync();

// remove raise hand states for all remote participants on the call
var participants = call.RemoteParticipants;
var identifiers = participants.Select(p => p.Identifier).ToList().AsReadOnly();
raiseHandCallFeature.LowerHandsAsync(identifiers);

// remove raise hand state of specific user
var identifiers = new List<CallIdentifier>();
identifiers.Add(new UserCallIdentifier("USER_ID"));
raiseHandCallFeature.LowerHandsAsync(identifiers);

Gestire gli stati modificati

Con l'API Raise Hand è possibile sottoscrivere gli RaisedHandReceived eventi e LoweredHandReceived per gestire le modifiche nello stato dei partecipanti in una chiamata. L'istanza di chiamata attiva questi eventi e fornisce informazioni sul partecipante il cui stato è cambiato.

Per sottoscrivere questi eventi, usare il codice seguente:

raiseHandCallFeature = (RaiseHandCallFeature)call.GetCallFeatureExtension(CallFeatureType.RaiseHand);
raiseHandCallFeature.RaisedHandReceived += OnRaisedHandChange;
raiseHandCallFeature.LoweredHandReceived += OnLoweredHandChange;

private async void OnRaisedHandChange(object sender, RaisedHandChangedEventArgs args)
{
    Trace.WriteLine("RaiseHandEvent: participant " + args.Identifier + " is raised hand");
}

private async void OnLoweredHandChange(object sender, RaisedHandChangedEventArgs args)
{
    Trace.WriteLine("RaiseHandEvent: participant " + args.Identifier + " is lowered hand");
}

Gli RaisedHandReceived eventi e LoweredHandReceived contengono un oggetto con la identifier proprietà , che rappresenta l'identificatore di comunicazione del partecipante. Nell'esempio precedente viene registrato un messaggio nella console che indica che un partecipante ha alzato la mano.

Per annullare la sottoscrizione agli eventi, è possibile usare il off metodo .

Elenco di tutti i partecipanti con stato attivo

Per ottenere informazioni su tutti i partecipanti che hanno la mano alzata durante la chiamata corrente, è possibile usare getRaisedHands. La matrice restituita viene ordinata in base al campo dell'ordine.

Ecco un esempio di come usare RaisedHands:

raiseHandCallFeature = (RaiseHandCallFeature)call.GetCallFeatureExtension(CallFeatureType.RaiseHand);
foreach (RaiseHand rh in raiseHandCallFeature.RaisedHands.ToList())
{
    Trace.WriteLine("Participant " + rh.Identifier.RawId + " has raised hand ");
}

Ordine delle mani alzate

La RaisedHands variabile contiene una matrice di oggetti partecipante, in cui ogni oggetto ha le proprietà seguenti:

identifier: identificatore di comunicazione del partecipante.
order: l'ordine in cui il partecipante ha alzato la mano.

È possibile usare queste informazioni per visualizzare un elenco di partecipanti con stato Raise Hand e il relativo ordine nella coda.

Condividi tramite

Prerequisiti

Installazione dell'SDK

Inizializzare gli oggetti necessari

Gestire la connettività dell'SDK all'infrastruttura Microsoft

Mano alzata e abbassata per il partecipante corrente

Mani inferiori per altri partecipanti

Gestire gli stati modificati

Elenco di tutti i partecipanti con stato attivo

Ordine delle mani alzate

Installazione dell'SDK

Inizializzare gli oggetti necessari

Mano alzata e abbassata per il partecipante corrente

Mani inferiori per altri partecipanti

Gestire gli stati modificati

Elenco di tutti i partecipanti con stato attivo

Ordine delle mani alzate

Configurare il sistema

Creare il progetto Xcode

Installare il pacchetto e le dipendenze usando CocoaPods

Richiedere l'accesso al microfono

Configurare il framework dell'app

Inizializzare CallAgent

Mano alzata e abbassata per il partecipante corrente

Mani inferiori per altri partecipanti

Gestire gli stati modificati

Elenco di tutti i partecipanti con stato attivo

Ordine delle mani alzate

Configurare il sistema

Creare il progetto di Visual Studio

Installare il pacchetto e le dipendenze usando Gestione pacchetti NuGet

Mano alzata e abbassata per il partecipante corrente

Mani inferiori per altri partecipanti

Gestire gli stati modificati

Elenco di tutti i partecipanti con stato attivo

Ordine delle mani alzate

Passaggi successivi

Articoli correlati

Commenti e suggerimenti

Risorse aggiuntive