Estados de mão levantada

Importante

Este recurso dos Serviços de Comunicação do Azure estão atualmente em versão prévia. Os recursos em versão prévia estão disponíveis publicamente e podem ser usados por todos os clientes novos e existentes da Microsoft.

Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou recursos podem ser restritos.

Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Importante

Este recurso dos Serviços de Comunicação do Azure estão atualmente em versão prévia. Os recursos em versão prévia estão disponíveis publicamente e podem ser usados por todos os clientes novos e existentes da Microsoft.

Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou recursos podem ser restritos.

Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Importante

Este recurso dos Serviços de Comunicação do Azure estão atualmente em versão prévia. Os recursos em versão prévia estão disponíveis publicamente e podem ser usados por todos os clientes novos e existentes da Microsoft.

Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou recursos podem ser restritos.

Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Instalar o SDK

Use o comando npm install para instalar o SDK Comum e de Chamada dos Serviços de Comunicação do Azure para JavaScript:

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

Inicializar objetos necessários

Uma instância CallClient é necessária para a maioria das operações de chamada. Ao criar uma instância de CallClient, você pode configurá-la com opções personalizadas, como uma instância de Logger.

Com a instância de CallClient, você pode criar uma instância de CallAgent chamando o createCallAgent. Esse método retorna de modo assíncrono um objeto de instância CallAgent.

O método createCallAgent usa CommunicationTokenCredential como um argumento. Ele aceita um token de acesso do usuário.

Você pode usar o método getDeviceManager na instância CallClient para acessar o 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()

Gerenciar a conectividade do SDK com a infraestrutura da Microsoft

A instância Call Agent ajuda você a gerenciar chamadas (para ingressar ou iniciar chamadas). Para trabalhar, o SDK de chamada precisa se conectar à infraestrutura da Microsoft para receber notificações de chamadas de entrada e coordenar outros detalhes da chamada. O seu Call Agent tem dois estados possíveis:

Conectado: um valor connectionStatue Call Agent de Connected significa que o SDK do cliente está conectado e capaz de receber notificações da infraestrutura da Microsoft.

Desconectado: um valor connectionStatue Call Agent de Disconnected declara que há um problema que está impedindo o SDK de se conectar corretamente. Call Agent deve ser recriado.

invalidToken: se um token tiver expirado ou for inválido, a instância Call Agent se desconecta com este erro.
connectionIssue: caso haja um problema de conexão do cliente com a infraestrutura da Microsoft, depois de muitas tentativas, Call Agent expõe o erro connectionIssue.

Você pode verificar se o local Call Agent está conectado à infraestrutura da Microsoft inspecionando o valor atual da propriedade connectionState. Durante uma chamada ativa, você pode ouvir o evento connectionStateChanged para determinar se Call Agent é alterado do estado Conectado ao Desconectado.

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

O recurso Levantar Mão permite que os participantes em uma chamada indiquem que têm uma pergunta, comentário ou preocupação sem interromper o locutor ou outros participantes. Você pode usar esse recurso em qualquer tipo de chamada, incluindo chamadas 1:1 e chamadas com muitos participantes, no Serviço de Comunicação do Azure e em chamadas do Teams.

Primeiro, você precisa importar recursos de chamada do SDK de Chamada:

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

Em seguida, você pode obter o objeto de API de recurso da instância de chamada:

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

Levantar e baixar a mão para o participante atual

Para alterar o estado Levantar Mão do participante atual, você pode usar os métodos raiseHand() e lowerHand().

Esses métodos são assíncronos. Para verificar os resultados, use ouvintes raisedHandChanged e loweredHandChanged.

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

Mãos abaixadas para outros participantes

Esse recurso permite que os usuários com as funções Organizador e Apresentador baixem todas as mãos de outros participantes em chamadas do Teams. Nas chamadas de Comunicação do Azure, você não pode alterar o estado de outros participantes, a menos que estiver adicionando as funções primeiro.

Para usar esse recurso, implemente o seguinte código:

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

Gerenciar estados alterados

Com a API Levantar Mão, você pode se inscrever em eventos raisedHandChanged e loweredHandChanged para lidar com mudanças no estado dos participantes da chamada. A instância de chamada dispara esses eventos e fornece informações sobre o participante cujo estado foi alterado.

Para assinar esses eventos, use o seguinte código:

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

Os eventos raisedHandChanged e loweredHandChanged contêm um objeto com a propriedade identifier, que representa o identificador de comunicação do participante. No exemplo anterior, registramos uma mensagem no console indicando que um participante levantou a mão.

Para cancelar a assinatura dos eventos, use o off método.

Lista de todos os participantes com estado ativo

Para obter informações sobre todos os participantes com estado de mãos levantadas na chamada atual, você pode usar getRaisedHands. A matriz retornada é classificada pelo campo Ordem.

Aqui está um exemplo de como usar o getRaisedHands:

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

Ordem das mãos levantadas

A participantsWithRaisedHands variável contém uma matriz de objetos participantes, em que cada objeto tem as seguintes propriedades:

identifier: o identificador de comunicação do participante.
order: a ordem na qual o participante levantou a mão.

Você pode usar essas informações para exibir uma lista de participantes com o estado Levantar Mão e sua ordem na fila.

Instalar o SDK

Localize o arquivo build.gradle de nível do projeto e adicione mavenCentral() à lista de repositórios em buildscript e allprojects:

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

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

Em seguida, no arquivo build.gradle no nível do módulo, adicione as seguintes linhas à seção dependencies:

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

Inicializar objetos necessários

Para criar uma instância CallAgent, você precisa chamar o método createCallAgent em uma instância CallClient. Essa chamada retorna de forma assíncrona um objeto de instância CallAgent.

O método createCallAgent usa CommunicationUserCredential como argumento, que encapsula um token de acesso.

Para acessar DeviceManager, você deverá criar uma instância callAgent primeiro. Em seguida, você poderá usar o método CallClient.getDeviceManager para obter 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();

Para definir um nome de exibição para o chamador, use este método 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();

O recurso Levantar Mão permite que os participantes em uma chamada indiquem que têm uma pergunta, comentário ou preocupação sem interromper o locutor ou outros participantes. Você pode usar esse recurso em qualquer tipo de chamada, incluindo chamadas 1:1 e chamadas com muitos participantes, no Serviço de Comunicação do Azure e em chamadas do Teams.

Primeiro, você precisa importar recursos de chamada do SDK de Chamada:

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

Em seguida, você pode obter o objeto de API de recurso da instância de chamada:

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

Levantar e baixar a mão para o participante atual

Para alterar o estado Levantar Mão do participante atual, você pode usar os métodos raiseHand() e lowerHand().

Esses métodos são assíncronos. Para verificar os resultados, use ouvintes RaisedHandReceived e LoweredHandReceived.

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

Mãos abaixadas para outros participantes

Esse recurso permite que os usuários com as funções Organizador e Apresentador baixem todas as mãos de outros participantes em chamadas do Teams. Nas chamadas de Comunicação do Azure, você não pode alterar o estado de outros participantes, a menos que estiver adicionando as funções primeiro.

Para usar esse recurso, implemente o seguinte código:

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

Gerenciar estados alterados

Com a API Raise Hand, você pode assinar os eventos RaisedHandReceived e LoweredHandReceived para lidar com alterações no estado dos participantes em uma chamada. A instância de chamada dispara esses eventos e fornece informações sobre o participante cujo estado foi alterado.

Para assinar esses eventos, use o seguinte código:

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

Os eventos RaisedHandReceived e LoweredHandReceived contêm um objeto com a propriedade identifier, que representa o identificador de comunicação do participante. No exemplo anterior, registramos uma mensagem no console indicando que um participante levantou a mão.

Para cancelar inscrição dos eventos, você pode usar o método off.

Lista de todos os participantes com estado ativo

Para obter informações sobre todos os participantes com estado de mãos levantadas na chamada atual, você pode usar getRaisedHands. A matriz retornada é classificada pelo campo Ordem.

Aqui está um exemplo de como usar o getRaisedHands:

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

Ordem das mãos levantadas

A participantsWithRaisedHands variável contém uma matriz de objetos participantes, em que cada objeto tem as seguintes propriedades:

identifier: o identificador de comunicação do participante.
order: a ordem na qual o participante levantou a mão.

Você pode usar essas informações para exibir uma lista de participantes com o estado Levantar Mão e sua ordem na fila.

Configurar o backup do sistema

Siga essas etapas para configurar seu sistema.

Criar o projeto do Xcode

No Xcode, crie um projeto do iOS e selecione o modelo Aplicativo de Modo de Exibição Único. Como este artigo usa a estrutura SwiftUI, defina Linguagem como Swift e Interface como SwiftUI.

Você não criará testes neste artigo. Fique à vontade para limpar a caixa de seleção Incluir Testes.

Captura de tela que mostra a janela para a criação de um projeto no Xcode.

Instalar o pacote e as dependências usando o CocoaPods

Crie um Podfile para seu aplicativo, como este exemplo:

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

Execute pod install.
Abra o .xcworkspace usando o Xcode.

Solicitar acesso ao microfone

Para acessar o microfone do dispositivo, você precisa atualizar a lista de propriedades de informações do aplicativo usando NSMicrophoneUsageDescription. Defina o valor associado como uma cadeia de caracteres incluída na caixa de diálogo que é usada pelo sistema para solicitar o acesso do usuário.

Clique com o botão direito do mouse na entrada Info.plist da árvore de projeto e selecione Abrir Como>Código-Fonte. Adicione as linhas a seguir na seção do nível superior<dict>e, em seguida, salve o arquivo.

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

Configurar o framework de aplicativos

Abra o arquivo ContentView.swift do projeto. Adicione uma declaração import à parte superior do arquivo para importar a biblioteca AzureCommunicationCalling. Além disso, importeAVFoundation. Você precisa dele para solicitações de permissão de áudio no código.

import AzureCommunicationCalling
import AVFoundation

Inicialização do CallAgent

Para criar umaCallAgentinstânciaCallClient,você precisa usar um método callClient.createCallAgentque retorne de modo assíncrono um objetoCallAgentdepois que ele for inicializado.

Para criar um cliente de chamada, passe um objeto 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)
}

Passe o objeto CommunicationTokenCredential que você criou para CallClient e defina o nome de exibição:

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

O recurso Levantar Mão permite que os participantes em uma chamada indiquem que têm uma pergunta, comentário ou preocupação sem interromper o locutor ou outros participantes. Você pode usar esse recurso em qualquer tipo de chamada, incluindo chamadas 1:1 e chamadas com muitos participantes, no Serviço de Comunicação do Azure e em chamadas do Teams.

Primeiro, você precisa importar recursos de chamada do SDK de Chamada:

import AzureCommunicationCalling

Em seguida, você pode obter o objeto de API de recurso da instância de chamada:

@State var raisehandFeature: RaiseHandCallFeature?

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

Levantar e baixar a mão para o participante atual

Para alterar o estado Levantar Mão do participante atual, você pode usar os métodos raiseHand() 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)
    }
})

Mãos abaixadas para outros participantes

Esse recurso permite que os usuários com as funções Organizador e Apresentador baixem todas as mãos de outros participantes em chamadas do Teams. Nas chamadas de Comunicação do Azure, você não pode alterar o estado de outros participantes, a menos que estiver adicionando as funções primeiro.

Para usar esse recurso, implemente o seguinte código:


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

Gerenciar estados alterados

Com a API Levantar Mão, você pode se inscrever em eventos RaisedHandReceived e LoweredHandReceived para lidar com mudanças no estado dos participantes da chamada. A instância de chamada dispara esses eventos e fornece informações sobre o participante cujo estado foi alterado.

Para assinar esses eventos, use o seguinte código:

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

Os eventos RaisedHandReceived e LoweredHandReceived contêm um objeto com a propriedade identifier, que representa o identificador de comunicação do participante. No exemplo anterior, registramos uma mensagem no console indicando que um participante levantou a mão.

Para cancelar a assinatura dos eventos, use o off método.

Lista de todos os participantes com estado ativo

Para obter informações sobre todos os participantes com estado de mãos levantadas na chamada atual, você pode usar getRaisedHands. A matriz retornada é classificada pelo campo Ordem.

Aqui está um exemplo de como usar o raisedHands:

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

Ordem das mãos levantadas

A raisedHands variável contém uma matriz de objetos participantes, em que cada objeto tem as seguintes propriedades:

identifier: o identificador de comunicação do participante.
order: a ordem na qual o participante levantou a mão.

Você pode usar essas informações para exibir uma lista de participantes com o estado Levantar Mão e sua ordem na fila.

Configurar o backup do sistema

Siga essas etapas para configurar seu sistema.

Criar o projeto do Visual Studio

Para um aplicativo da Plataforma Universal do Windows, no Visual Studio 2022, crie um projeto Aplicativo em Branco (Universal do Windows). Depois de inserir o nome do projeto, fique à vontade para escolher qualquer SDK do Windows posterior a 10.0.17763.0.

Para um aplicativo WinUI 3, crie um novo projeto com o modelo Blank App, Packaged (WinUI 3 in Desktop) para configurar um aplicativo WinUI 3 de página única. O SDK do Aplicativo do Windows versão 1.3 ou posterior é necessário.

Instalar o pacote e as dependências usando o Gerenciador de Pacotes do NuGet

As bibliotecas e as APIs do SDK de Chamada estão disponíveis publicamente por meio de um pacote NuGet.

Para localizar, baixar e instalar o pacote NuGet do SDK de Chamada:

Abra o Gerenciador de Pacotes do NuGet selecionando Ferramentas>Gerenciador de Pacotes do NuGet>Gerenciar de Pacotes do NuGet para Solução.
Selecione Procurar e insira Azure.Communication.Calling.WindowsClient na caixa de pesquisa.
Verifique se a caixa de seleção Incluir pré-lançamento está marcada.
Selecione o pacote Azure.Communication.Calling.WindowsClient, e em seguida, selecione Azure.Communication.Calling.WindowsClient1.4.0-beta.1 ou uma versão mais recente.
Marque a caixa de seleção que corresponde ao projeto dos Serviços de Comunicação do Azure no painel direito.
Selecione Instalar.

O recurso Levantar Mão permite que os participantes em uma chamada indiquem que têm uma pergunta, comentário ou preocupação sem interromper o locutor ou outros participantes. Você pode usar esse recurso em qualquer tipo de chamada, incluindo chamadas 1:1 e chamadas com muitos participantes, no Serviço de Comunicação do Azure e em chamadas do Teams.

Primeiro, você precisa importar recursos de chamada do SDK de Chamada:

using Azure.Communication.Calling.WindowsClient;

Em seguida, você pode obter o objeto de API de recurso da instância de chamada:

private RaiseHandCallFeature raiseHandCallFeature;

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

Levantar e baixar a mão para o participante atual

Para alterar o estado Levantar Mão do participante atual, você pode usar os métodos raiseHand() e lowerHand().

Esses métodos são assíncronos. Para verificar os resultados, use ouvintes RaisedHandReceived e LoweredhandReceived.

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

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

Mãos abaixadas para outros participantes

A funcionalidade de baixar as mãos de outros participantes permite que os usuários com as funções Organizador e Apresentador baixem todas as mãos de outros participantes em chamadas do Teams. Nas chamadas de Comunicação do Azure, você não pode alterar o estado de outros participantes, a menos que adicione suas funções primeiro.

Para usar esse recurso, implemente o seguinte código:


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

Gerenciar estados alterados

Com a API Levantar Mão, você pode se inscrever em eventos RaisedHandReceived e LoweredHandReceived para lidar com mudanças no estado dos participantes da chamada. A instância de chamada dispara esses eventos e fornece informações sobre o participante cujo estado foi alterado.

Para assinar esses eventos, use o seguinte código:

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

Os eventos RaisedHandReceived e LoweredHandReceived contêm um objeto com a propriedade identifier, que representa o identificador de comunicação do participante. No exemplo anterior, registramos uma mensagem no console indicando que um participante levantou a mão.

Para cancelar inscrição dos eventos, você pode usar o método off.

Lista de todos os participantes com estado ativo

Para obter informações sobre todos os participantes com estado de mãos levantadas na chamada atual, você pode usar getRaisedHands. A matriz retornada é classificada pelo campo Ordem.

Aqui está um exemplo de como usar o RaisedHands:

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

Ordem das mãos levantadas

A RaisedHands variável contém uma matriz de objetos participantes, em que cada objeto tem as seguintes propriedades:

identifier: o identificador de comunicação do participante.
order: a ordem na qual o participante levantou a mão.

Você pode usar essas informações para exibir uma lista de participantes com o estado Levantar Mão e sua ordem na fila.

Compartilhar via

Pré-requisitos

Instalar o SDK

Inicializar objetos necessários

Gerenciar a conectividade do SDK com a infraestrutura da Microsoft

Levantar e baixar a mão para o participante atual

Mãos abaixadas para outros participantes

Gerenciar estados alterados

Lista de todos os participantes com estado ativo

Ordem das mãos levantadas

Instalar o SDK

Inicializar objetos necessários

Levantar e baixar a mão para o participante atual

Mãos abaixadas para outros participantes

Gerenciar estados alterados

Lista de todos os participantes com estado ativo

Ordem das mãos levantadas

Configurar o backup do sistema

Criar o projeto do Xcode

Instalar o pacote e as dependências usando o CocoaPods

Solicitar acesso ao microfone

Configurar o framework de aplicativos

Inicialização do CallAgent

Levantar e baixar a mão para o participante atual

Mãos abaixadas para outros participantes

Gerenciar estados alterados

Lista de todos os participantes com estado ativo

Ordem das mãos levantadas

Configurar o backup do sistema

Criar o projeto do Visual Studio

Instalar o pacote e as dependências usando o Gerenciador de Pacotes do NuGet

Levantar e baixar a mão para o participante atual

Mãos abaixadas para outros participantes

Gerenciar estados alterados

Lista de todos os participantes com estado ativo

Ordem das mãos levantadas

Próximas etapas

Artigos relacionados

Comentários

Recursos adicionais