Condividi tramite

Creare una risorsa per sala

Questo articolo descrive come creare una sala all'interno della risorsa di Servizi di comunicazione di Azure. Una sala è uno spazio di comunicazione gestito dal server per un set di partecipanti noto, fisso e di cui collaborare per una durata predeterminata. Per altre informazioni e casi d'uso, vedere API Rooms per riunioni strutturate.

Modello a oggetti

Nella tabella seguente sono elencate le proprietà principali degli oggetti sala:

Nome Descrizione
roomId Identificatore univoco della stanza.
validFrom Orario di inizio disponibilità della sala.
validUntil Ultima ora possibile per utilizzare una stanza.
pstnDialOutEnabled Abilitare o disabilitare la chiamata in uscita a un numero PSTN (Public Switched Telephone Network) da una stanza.
participants Elenco dei partecipanti in una sala. Specificato come CommunicationUserIdentifier.
roleType Ruolo di un partecipante alla sala. Può essere Presenter, Attendee, Consumer o Collaborator.

Prerequisiti

Configurazione

Aggiungere l'estensione

Aggiungere l'estensione Servizi di comunicazione di Azure per l'interfaccia della riga di comando di Azure usando il comando az extension.

az extension add --name communication

Accedere all'interfaccia della riga di comando di Azure

È necessario accedere all'interfaccia della riga di comando di Azure. È possibile accedere eseguendo il comando az login dal terminale e specificando le credenziali.

Archiviare la stringa di connessione in una variabile di ambiente

È possibile configurare la variabile di ambiente AZURE_COMMUNICATION_CONNECTION_STRING per usare le operazioni principali dell'interfaccia della riga di comando di Azure senza dover usare --connection_string per passare la stringa di connessione. Per configurare una variabile di ambiente, aprire una finestra della console e selezionare il sistema operativo dalle schede seguenti. Sostituire <connectionString> con la stringa di connessione effettiva.

setx AZURE_COMMUNICATION_CONNECTION_STRING "<connectionString>"

Dopo l'aggiunta della variabile di ambiente potrebbe essere necessario riavviare eventuali programmi in esecuzione che devono leggere la variabile di ambiente, inclusa la finestra della console. Se ad esempio si usa Visual Studio come editor, riavviare Visual Studio prima di eseguire l'esempio.

Operazioni

Creare una sala

Usare il comando rooms create per creare una sala.

az communication rooms create --presenter-participants "<participantId>" --consumer-participants "<participantId>" --attendee-participant "<participantId>" --valid-from "<valid-from>" --valid-until "<valid-until>" --pstn-dial-out-enabled "<pstn-dial-out-enabled>" --connection-string "<connection-string>"
  • Usare facoltativamente <participantId> per specificare il tipo di partecipante come relatore-partecipanti, utente-partecipanti o partecipanti semplici. Se non si specifica un valore, l'impostazione predefinita è vuota.
  • Sostituire <connection-string> con la stringa di connessione di Servizi di comunicazione di Azure.
  • Usare facoltativamente <valid-from> per specificare il timestamp quando la sala è aperta per la partecipazione, in formato ISO8601 (ad esempio: 2022-07-14T10:21).
  • Usare facoltativamente <valid-until> per specificare il timestamp quando non è più possibile accedere alla sala, in formato ISO8601 (ad esempio: 2022-07-14T10:21).
  • Usare facoltativamente <pstn-dial-out-enabled> impostando questo flag (su "True" o "False") per abilitare o disabilitare la chiamata PSTN in uscita per una sala. Per impostazione predefinita, questo flag è impostato su "False" durante la creazione di una sala.

Se si archivia la stringa di connessione nelle variabili di ambiente, non è necessario passarle al comando.

az communication rooms create

Abilitare la funzionalità di chiamata PSTN in uscita per una sala

È possibile abilitare la chiamata PSTN durante rooms create definendo il --pstn-dial-out-enabled parametro come True. È possibile modificare questa funzionalità durante q rooms update specificando il --pstn-dial-out-enabled parametro .

az communication rooms create --pstn-dial-out-enabled "<pstn-dial-out-enabled>" --connection-string "<connection-string>"

az communication rooms update --pstn-dial-out-enabled "<pstn-dial-out-enabled>" --room "<roomId>"
  • Per abilitare o disabilitare la chiamata PSTN in uscita per una sala, impostare il flag <pstn-dial-out-enabled> (True o False).

Ottenere le sale

Il comando rooms get restituisce gli attributi di una sala esistente.

az communication rooms get --room "<roomId>"
  • Sostituire <roomId> con l'ID sala.

Aggiornare l'intervallo di tempo di una sala

È possibile aggiornare il timestamp di una sala. Prima di chiamare il comando room update, assicurarsi di aver acquisito una nuova sala con un intervallo di tempo valido.

az communication rooms update --valid-from "<valid-from>" --valid-until "<valid-until>" --pstn-dial-out-enabled "<pstn-dial-out-enabled>" --room "<roomId>"
  • Sostituire <valid-from> con il timestamp in formato ISO8601, ad esempio: 2022-07-14T10:21, per specificare quando la sala è aperta per l'accesso. Deve essere usato insieme a --valid-until.
  • Sostituire <valid-until> con il timestamp nel formato ISO8601, ad esempio: 2022-07-14T10:21, per specificare quando non è più possibile accedere alla sala. Deve essere usato insieme a --valid-from.
  • Sostituire <pstn-dial-out-enabled> imposta questo flag ("True" o "False") per abilitare o disabilitare la chiamata PSTN in uscita per una sala. Deve essere usato insieme a --pstn-dial-out-enabled.
  • Sostituire <roomId> con l'ID sala.

Elencare tutte le sale attive

Il comando rooms list restituisce tutte le sale attive appartenenti alla risorsa Servizi di comunicazione di Azure.

az communication rooms list

Aggiungere nuovi partecipanti o aggiornare i partecipanti esistenti

Quando si crea una sala, è possibile aggiornarla aggiungendo un nuovo partecipante o aggiornando un partecipante esistente. Prima di chiamare il room participant add-or-update comando, assicurarsi di aver acquisito un nuovo utente.

Usare il comando identity user create per creare un nuovo partecipante, identificato da participantId.

az communication identity user create

Aggiungere un utente come partecipante alla sala.

az communication rooms participant add-or-update --attendee-participant "<participantId>" --room "<roomId>"
  • Sostituire <participantId> con l'ID partecipante. Se <participantId> non è presente nella sala, il partecipante viene aggiunto alla sala con il ruolo di partecipante. In caso contrario, il ruolo del partecipante viene aggiornato a un ruolo di partecipante.
  • Sostituire <roomId> con l'ID sala.

Ottenere l'elenco dei partecipanti in una sala

az communication rooms participant get --room "<roomId>"
  • Sostituire <roomId> con l'ID sala.

Rimuovere un partecipante da una sala

È possibile rimuovere un partecipante da una sala usando rooms participant -remove.

az communication rooms participant remove --room "<roomId>" --participants "<participant1>" "<participant2>" "<participant3>"
  • Sostituire <roomId> con l'ID sala.
  • Sostituire <participant1>, <participant2><participant3> con gli ID utente ottenuti in precedenza eseguendo il comando identity user create.

Eliminare una sala

Proprio come è possibile creare una sala, è anche possibile eliminarla.

Usare il comando room delete per eliminare la sala esistente.

az communication rooms delete --room "<roomId>"
  • Sostituire <roomId> con l'ID sala.

Una sala è uno spazio di comunicazione gestito dal server per un set di partecipanti noto e fisso per collaborare per una durata predeterminata. Per altre informazioni, vedere API Rooms per riunioni strutturate.

Prerequisiti

Codice di esempio

Esaminare e scaricare il codice di esempio da GitHub su Rooms Quickstart - .NET.

Configurazione

Creare una nuova applicazione C#

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome RoomsQuickstart. Questo comando crea un semplice progetto C# "Hello World" con un singolo file di origine: Program.cs.

dotnet new console -o RoomsQuickstart

Passare alla cartella dell'app appena creata e usare il comando dotnet build per compilare l'applicazione.

cd RoomsQuickstart
dotnet build

Installare il pacchetto

Installare la libreria client di Azure Communication Rooms per .NET con [NuGet][https://www.nuget.org/]:

dotnet add package Azure.Communication.Rooms

Usare la libreria client di Azure Communication Rooms per .NET versione 1.1.0 o successiva.

Configurare il framework dell'app

Nel file Program.cs aggiungere il codice seguente per importare gli spazi dei nomi necessari e creare la struttura di base del programma.


using System;
using Azure;
using Azure.Core;
using Azure.Communication.Rooms;

namespace RoomsQuickstart
{
    class Program
    {
        static async System.Threading.Tasks.Task Main(string[] args)
        {
            Console.WriteLine("Azure Communication Services - Rooms Quickstart");

            // Quickstart code goes here
        }
    }
}

Inizializzare un client della sala

Creare un nuovo oggetto RoomsClient necessario per creare nuovi rooms e gestire le loro proprietà e il loro ciclo di vita. Usare la stringa di connessione del servizio comunicazioni per autenticare la richiesta. Per altre informazioni sulle stringhe di connessione, vedere questa pagina.


// Find your Communication Services resource in the Azure portal
var connectionString = "<connection_string>";
RoomsClient roomsClient = new RoomsClient(connectionString);

Creare una sala

Configurare i partecipanti alla sala

Per configurare chi può partecipare a una sala, è necessario avere l'elenco delle identità di tali utenti. Seguire le istruzioni in Token di accesso per creareeusers ed emettere token di accesso. In alternativa, per creare gli utenti su richiesta, è possibile crearli usando .CommunicationIdentityClient Servizi di comunicazione di Azure Rooms supporta attualmente solo un partecipante alla sala di tipo CommunicationUserIdentifier, l'uso di altri tipi di CommunicationIdentity causa un errore di runtime.

Per usare CommunicationIdentityClient, installare il pacchetto seguente:

dotnet add package Azure.Communication.Identity

Importare anche lo spazio dei nomi del pacchetto nella parte superiore del file Program.cs:

using Azure.Communication.Identity;

È ora possibile inizializzare CommunicationIdentityClient e usarlo per creare utenti:

// Create identities for users who will join the room
CommunicationIdentityClient identityClient = new CommunicationIdentityClient(connectionString);
CommunicationUserIdentifier user1 = identityClient.CreateUser();
CommunicationUserIdentifier user2 = identityClient.CreateUser();

Creare quindi l'elenco dei partecipanti alla sala facendo riferimento a tali utenti:

List<RoomParticipant> participants = new List<RoomParticipant>()
{
    new RoomParticipant(user1) { Role = ParticipantRole.Presenter },
    new RoomParticipant(user2) // The default participant role is ParticipantRole.Attendee
};

Inizializzare la sala

Creare una nuova sala usando l'oggetto participants definito nel frammento di codice precedente:

// Create a room
DateTimeOffset validFrom = DateTimeOffset.UtcNow;
DateTimeOffset validUntil = validFrom.AddDays(1);
CancellationToken cancellationToken = new CancellationTokenSource().Token;

CommunicationRoom createdRoom = await roomsClient.CreateRoomAsync(validFrom, validUntil, participants, cancellationToken);

// CreateRoom or CreateRoomAsync methods can take CreateRoomOptions type as an input parameter.
bool pstnDialOutEnabled = false;
CreateRoomOptions createRoomOptions = new CreateRoomOptions()
{
    ValidFrom = validFrom,
    ValidUntil = validUntil,
    PstnDialOutEnabled = pstnDialOutEnabled,
    Participants = participants
};

createdRoom = await roomsClient.CreateRoomAsync(createRoomOptions, cancellationToken);
string roomId = createdRoom.Id;
Console.WriteLine("\nCreated room with id: " + roomId);

Poiché le sale sono entità lato server, è necessario tenere traccia e rendere persistente la roomId nel supporto di archiviazione preferito. È possibile fare riferimento a roomId per visualizzare o aggiornare le proprietà di un oggetto sala.

Abilitare la funzionalità di chiamata PSTN in uscita per una sala

Per impostazione predefinita, ogni camera ha la chiamata PSTN disattivata. È possibile abilitare la chiamata telefonica PSTN per una stanza al momento della creazione, definendo il pstnDialOutEnabled parametro come true. È possibile modificare questa funzionalità per una sala inviando una richiesta di aggiornamento per il pstnDialOutEnabled parametro .

// Create a room
CancellationToken cancellationToken = new CancellationTokenSource().Token;

// CreateRoom or CreateRoomAsync methods to create a room with PSTN dial out capability
bool pstnDialOutEnabled = true;
CreateRoomOptions createRoomOptions = new CreateRoomOptions()
{
    PstnDialOutEnabled = pstnDialOutEnabled,
};

CommunicationRoom createdRoom = await roomsClient.CreateRoomAsync(createRoomOptions, cancellationToken);
Console.WriteLine("\nCreated a room with PSTN dial out enabled: " + createdRoom.PstnDialOutEnabled);

// UpdateRoom or UpdateRoomAsync methods can take UpdateRoomOptions to enable or disable PSTN dial out capability
pstnDialOutEnabled = false;
UpdateRoomOptions updateRoomOptions = new UpdateRoomOptions()
{
    PstnDialOutEnabled = pstnDialOutEnabled,
};

CommunicationRoom updatedRoom = await roomsClient.UpdateRoomAsync(roomId, updateRoomOptions, cancellationToken);
Console.WriteLine("\nUpdated a room with PSTN dial out enabled: " + updatedRoom.PstnDialOutEnabled);

Ottenere le proprietà di una sala esistente

Per recuperare i dettagli di una stanza esistente, fare riferimento a roomId:


// Retrieve the room with corresponding ID
CommunicationRoom room = await roomsClient.GetRoomAsync(roomId);
Console.WriteLine("\nRetrieved room with id: " + room.Id);

Aggiornare la durata di una sala

È possibile modificare la durata di una sala inviando una richiesta di aggiornamento per i ValidFrom parametri e ValidUntil . Una sala può avere una validità massima di sei mesi.


// Update room lifetime
DateTimeOffset updatedValidFrom = DateTimeOffset.UtcNow;
DateTimeOffset updatedValidUntil = DateTimeOffset.UtcNow.AddDays(10);
CommunicationRoom updatedRoom = await roomsClient.UpdateRoomAsync(roomId, updatedValidFrom, updatedValidUntil, cancellationToken);

// UpdateRoom or UpdateRoomAsync methods can take UpdateRoomOptions type as an input parameter.
bool pstnDialOutEnabled = true;
UpdateRoomOptions updateRoomOptions = new UpdateRoomOptions()
{
    ValidFrom = validFrom,
    ValidUntil = validUntil,
    PstnDialOutEnabled = pstnDialOutEnabled,
};

updatedRoom = await roomsClient.UpdateRoomAsync(roomId, updateRoomOptions, cancellationToken);
Console.WriteLine("\nUpdated room with validFrom: " + updatedRoom.ValidFrom + ", validUntil: " + updatedRoom.ValidUntil + " and pstnDialOutEnabled: " + updatedRoom.PstnDialOutEnabled);

Elencare tutte le sale attive

Per recuperare tutte le sale attive, usare il metodo GetRoomsAsync esposto nel client.


// List all active rooms
AsyncPageable<CommunicationRoom> allRooms = roomsClient.GetRoomsAsync();
await foreach (CommunicationRoom currentRoom in allRooms)
{
    Console.WriteLine("\nFirst room id in all active rooms: " + currentRoom.Id);
    break;
}

Aggiungere nuovi partecipanti o aggiornare i partecipanti esistenti

Per aggiungere nuovi partecipanti a una sala, usare il AddParticipantsAsync metodo esposto nel client.


List<RoomParticipant> addOrUpdateParticipants = new List<RoomParticipant>();
// Update participant2 from Attendee to Consumer
RoomParticipant participant2 = new RoomParticipant(user2) { Role = ParticipantRole.Consumer };
// Add participant3
CommunicationUserIdentifier user3 = identityClient.CreateUser();
RoomParticipant participant3 = new RoomParticipant(user3) { Role = ParticipantRole.Collaborator };
addOrUpdateParticipants.Add(participant2);
addOrUpdateParticipants.Add(participant3);

Response addOrUpdateParticipantsResponse = await roomsClient.AddOrUpdateParticipantsAsync(roomId, addOrUpdateParticipants);
Console.WriteLine("\nAdded or updated participants to room");

Quando si aggiungono partecipanti a una sala, diventano idonei per partecipare alle chiamate. I partecipanti aggiornati visualizzano il nuovo role nella chiamata.

Ottenere l'elenco dei partecipanti

Recuperare l'elenco dei partecipanti per una sala esistente facendo riferimento a roomId:


// Get list of participants in room
AsyncPageable<RoomParticipant> existingParticipants = roomsClient.GetParticipantsAsync(roomId);
Console.WriteLine("\nRetrieved participants from room: ");
await foreach (RoomParticipant participant in existingParticipants)
{
    Console.WriteLine($"{participant.CommunicationIdentifier.ToString()},  {participant.Role.ToString()}");
}

Rimuovere partecipanti

Per rimuovere un partecipante da una stanza e revocarne l'accesso, usare il RemoveParticipantsAsync metodo .


// Remove user from room
List<CommunicationIdentifier> removeParticipants = new List<CommunicationIdentifier>();
removeParticipants.Add(user2);

Response removeParticipantsResponse = await roomsClient.RemoveParticipantsAsync(roomId, removeParticipants);
Console.WriteLine("\nRemoved participants from room");

Eliminare sala

Se si desidera eliminare una stanza esistente, emettere una richiesta di eliminazione esplicita. Tutte le sale e le relative risorse associate vengono eliminate automaticamente alla scadenza della loro validità seguita da un periodo di tolleranza.


// Deletes the specified room
Response deleteRoomResponse = await roomsClient.DeleteRoomAsync(roomId);
Console.WriteLine("\nDeleted room with id: " + roomId);

Eseguire il codice

Per eseguire il codice, assicurarsi di trovarsi nella stessa directory del Program.cs file.


dotnet run

L'output previsto descrive ogni azione completata:


Azure Communication Services - Rooms Quickstart

Created a room with id: 99445276259151407

Retrieved room with id: 99445276259151407

Updated room with validFrom: 2023-05-11T22:11:46.784Z, validUntil: 2023-05-21T22:16:46.784Z and pstnDialOutEnabled: true

First room id in all active rooms: 99445276259151407

Added or updated participants to room

Retrieved participants from room:
8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-ac89-7c76-35f3-343a0d00e901, Presenter
8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-f00d-aa4b-0cf9-9c3a0d00543e, Consumer
8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-f00d-aaf2-0cf9-9c3a0d00543f, Collaborator

Removed participants from room

Deleted room with id: 99445276259151407

Documentazione di riferimento

Per informazioni sul set completo di funzionalità delle sale di Servizi di comunicazione di Azure, vedere le informazioni di riferimento su .NET SDK o le informazioni di riferimento sull'API REST.

Una sala è uno spazio di comunicazione gestito dal server per un set di partecipanti noto e fisso per collaborare per una durata predeterminata. Per altre informazioni, vedere API Rooms per riunioni strutturate.

Prerequisiti

Codice di esempio

Esamina e scarica il codice di esempio disponibile su GitHub in Servizi di comunicazione di Azure - Rooms - Java.

Configurazione

Creare una nuova applicazione Java

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando mvn per creare una nuova app console con il nome rooms-quickstart. Questo comando crea un semplice progetto Java "Hello World" con un singolo file di origine: App.java.

mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Includere il pacchetto

È necessario usare la libreria client di Azure Communication Rooms per Java versione 1.1.0 o successiva.

Includere il file BOM

Includere azure-sdk-bom nel proprio progetto per prendere la dipendenza dalla versione di disponibilità generale (GA) della libreria. Nel frammento di codice seguente sostituire il segnaposto {bom_version_to_target} con il numero di versione.

Per altre informazioni sulla distinta base (BOM), vedere il file leggimi della distinta base di Azure SDK.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Includere quindi la dipendenza diretta nella sezione dependencies senza il tag di versione.

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-rooms</artifactId>
  </dependency>
</dependencies>

Includi dipendenza diretta

Per creare una dipendenza da una versione specifica della libreria non presente nella distinta base, aggiungere la dipendenza diretta al progetto come indicato di seguito.

<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-communication-rooms</artifactId>
  <version>1.0.0-beta.1</version>
</dependency>

Configurare il framework dell'app

Passare alla /src/main/java/com/communication/quickstart directory e aprire il App.java file. Aggiungere il codice seguente:


package com.communication.rooms.quickstart;

import com.azure.communication.common.*;
import com.azure.communication.identity.*;
import com.azure.communication.identity.models.*;
import com.azure.core.credential.*;
import com.azure.communication.rooms.*;

import java.io.IOException;
import java.time.*;
import java.util.*;

public class App
{
    public static void main( String[] args ) throws IOException
    {
        System.out.println("Azure Communication Services - Rooms Quickstart");
        // Quickstart code goes here
    }
}

Inizializzare un client della sala

Creare un nuovo oggetto RoomsClient, necessario per creare nuove sale e gestire le loro proprietà e il loro ciclo di vita. Usare la stringa di connessione del servizio comunicazioni per autenticare la richiesta. Per altre informazioni sulle stringhe di connessione, vedere Creare una risorsa di comunicazione.


// Initialize the rooms client
// Find your Communication Services resource in the Azure portal
String connectionString = "<connection string>";
RoomsClient roomsClient = new RoomsClientBuilder().connectionString(connectionString).buildClient();

Creare una sala

Configurare i partecipanti alla sala

Per configurare chi può partecipare a una sala, è necessario avere l'elenco delle identità di tali utenti. Seguire le istruzioni in Token di accesso per creare utenti ed emettere token di accesso. In alternativa, se si desidera creare gli utenti su richiesta, è possibile crearli usando CommunicationIdentityClient. Servizi di comunicazione di Azure Rooms supporta attualmente solo un partecipante alla sala di tipo CommunicationUserIdentifier. L'uso di altri tipi di CommunicationIdentity causa un errore di runtime.

Per usare CommunicationIdentityClient, aggiungere il pacchetto seguente:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-identity</artifactId>
</dependency>

Importare il pacchetto nella parte superiore del file App.java:

import com.azure.communication.identity.CommunicationIdentityClient;
import com.azure.communication.identity.CommunicationIdentityClientBuilder;

Ora, inizializza CommunicationIdentityClient e usalo per creare utenti:

CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClientBuilder()
    .connectionString(connectionString)
    .buildClient();

CommunicationUserIdentifier user1 = communicationClient.createUser();
CommunicationUserIdentifier user2 = communicationClient.createUser();
CommunicationUserIdentifier user3 = communicationClient.createUser();

Creare quindi l'elenco dei partecipanti alla sala facendo riferimento a tali utenti:

//The default participant role is ParticipantRole.Attendee
RoomParticipant participant_1 = new RoomParticipant(user1);
RoomParticipant participant_2 = new RoomParticipant(user2);
RoomParticipant participant_3 = new RoomParticipant(user3);

List<RoomParticipant> roomParticipants = new ArrayList<RoomParticipant>();

roomParticipants.add(participant_1);
roomParticipants.add(participant_2.setRole(ParticipantRole.CONSUMER));

Inizializzare la sala

Creare una nuova sala usando l'oggetto roomParticipants definito nel frammento di codice precedente:

OffsetDateTime validFrom = OffsetDateTime.now();
OffsetDateTime validUntil = validFrom.plusDays(30);
boolean pstnDialOutEnabled = false;

CreateRoomOptions createRoomOptions = new CreateRoomOptions()
    .setValidFrom(validFrom)
    .setValidUntil(validUntil)
    .setPstnDialOutEnabled(pstnDialOutEnabled)
    .setParticipants(roomParticipants);

CommunicationRoom roomCreated = roomsClient.createRoom(createRoomOptions);

System.out.println("\nCreated a room with id: " + roomCreated.getRoomId());

Le sale sono entità lato server, quindi è necessario tenere traccia e rendere persistente l'oggetto roomId nel supporto di archiviazione preferito. È possibile fare riferimento a roomId per visualizzare o aggiornare le proprietà di un oggetto sala.

Abilitare la funzionalità di chiamata PSTN in uscita per una sala

Per impostazione predefinita, ogni camera ha la chiamata PSTN disattivata. La chiamata PSTN in uscita può essere abilitata per una stanza al momento della creazione, definendo il parametro pstnDialOutEnabled come true. È possibile modificare questa funzionalità per una sala inviando una richiesta di aggiornamento per il pstnDialOutEnabled parametro .

boolean pstnDialOutEnabled = true;
// Create a room with PSTN dial out capability
CreateRoomOptions createRoomOptions = new CreateRoomOptions()
    .setPstnDialOutEnabled(pstnDialOutEnabled)

CommunicationRoom roomCreated = roomsClient.createRoom(createRoomOptions);
System.out.println("\nCreated a room with PSTN dial out enabled: " + roomCreated.getPstnDialOutEnabled());

// Update a room to enable or disable PSTN dial out capability
pstnDialOutEnabled = false;
UpdateRoomOptions updateRoomOptions = new UpdateRoomOptions()
    .setPstnDialOutEnabled(pstnDialOutEnabled);

CommunicationRoom roomUpdated = roomsClient.updateRoom(roomId, updateRoomOptions);
System.out.println("\nUpdated a room with PSTN dial out enabled: " + roomUpdated.getPstnDialOutEnabled());

Ottenere le proprietà di una sala esistente

Recuperare i dettagli di una stanza esistente facendo riferimento a roomId:


// Retrieve the room with corresponding ID
CommunicationRoom roomResult = roomsClient.getRoom(roomId);

System.out.println("Retrieved room with id: " + roomResult.getRoomId());

Aggiornare la durata di una sala

È possibile modificare la durata di una sala inviando una richiesta di aggiornamento per i ValidFrom parametri e ValidUntil . Una sala può avere una validità massima di sei mesi.


OffsetDateTime validFrom = OffsetDateTime.now().plusDays(1);
OffsetDateTime validUntil = validFrom.plusDays(1);
boolean pstnDialOutEnabled = true;

UpdateRoomOptions updateRoomOptions = new UpdateRoomOptions()
    .setValidFrom(validFrom)
    .setValidUntil(validUntil)
    .setPstnDialOutEnabled(pstnDialOutEnabled);

CommunicationRoom roomResult = roomsClient.updateRoom(roomId, updateRoomOptions);

System.out.println("Updated room with validFrom: " + roomResult.getValidFrom() + ", validUntil: " + roomResult.getValidUntil() + " and pstnDialOutEnabled: " + roomResult.getPstnDialOutEnabled());

Aggiungere o aggiornare partecipanti

Per aggiungere o aggiornare i partecipanti a una sala, usare il addOrUpdateParticipants metodo esposto nel client.


List<RoomParticipant> participantsToAddAOrUpdate = new ArrayList<>();

// Updating current participant
participantsToAddAOrUpdate.add(participant_1.setRole(ParticipantRole.PRESENTER));

// Adding new participant
 participantsToAddAOrUpdate.add(participant_3.setRole(ParticipantRole.COLLABORATOR));

AddOrUpdateParticipantsResult addOrUpdateParticipantsResult = roomsClient.addOrUpdateParticipants(roomId, participantsToAddAOrUpdate);

System.out.println("Participant(s) added/updated");

Dopo aver aggiunto i partecipanti a una sala, sono idonei per partecipare alle chiamate.

Ottenere l'elenco dei partecipanti

Recuperare l'elenco dei partecipanti per una sala esistente facendo riferimento a roomId:


// Get list of participants
try {

PagedIterable<RoomParticipant> participants = roomsClient.listParticipants(roomId);

System.out.println("Participants:/n");

for (RoomParticipant participant : participants) {
    System.out.println(participant.getCommunicationIdentifier().getRawId() + " (" + participant.getRole() + ")");
   }
} catch (Exception ex) {
    System.out.println(ex);
}

Rimuovere partecipanti

Per rimuovere un partecipante da una stanza e revocarne l'accesso, usare il removeParticipants metodo .


// Remove a participant from the room
List<CommunicationIdentifier> participantsToRemove = new ArrayList<>();

participantsToRemove.add(participant_3.getCommunicationIdentifier());

RemoveParticipantsResult removeParticipantsResult = roomsClient.removeParticipants(roomId,participantsToRemove);

System.out.println("Participant(s) removed");

Elencare tutte le sale attive

Recuperare tutte le sale attive nella risorsa Servizi di comunicazione di Azure.

try {
    Iterable<PagedResponse<CommunicationRoom>> roomPages = roomsClient.listRooms().iterableByPage();

    System.out.println("Listing all the rooms IDs in the first two pages of the list of rooms:");

    int count = 0;
    for (PagedResponse<CommunicationRoom> page : roomPages) {
        for (CommunicationRoom room : page.getElements()) {
            System.out.println("\n" + room.getRoomId());
        }

        count++;
        if (count >= 2) {
            break;
        }
    }
} catch (Exception ex) {
    System.out.println(ex);
}

Eliminare sala

Per eliminare una stanza esistente, eseguire una richiesta di eliminazione esplicita. Tutte le sale e le relative risorse associate vengono eliminate automaticamente alla scadenza della loro validità seguita da un periodo di tolleranza.


// Deletes the specified room
roomsClient.deleteRoomWithResponse(roomId, Context.NONE);
System.out.println("\nDeleted the room with ID: " + roomId);

Eseguire il codice

Per eseguire il codice, passare alla directory che contiene il file pom.xml e compilare il programma.

mvn compile

Quindi, compilare il pacchetto:

mvn package

Eseguire l'app.

mvn exec:java -D"exec.mainClass"="com.communication.rooms.quickstart" -D"exec.cleanupDaemonThreads"="false"

L'output previsto descrive ogni azione completata:

Azure Communication Services - Rooms Quickstart

Created a room with id:  99445276259151407

Retrieved room with id:  99445276259151407

Updated room with validFrom: 2023-05-11T22:11:46.784Z, validUntil: 2023-05-11T22:16:46.784Z and pstnDialOutEnabled: true

Participant(s) added/updated

Participants:
8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-ac89-7c76-35f3-343a0d00e901 (Presenter)
8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-ac89-7c76-35f3-343a0d00e902 (Consumer)
8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-ac89-7c76-35f3-343a0d00e903 (Collaborator)

Participant(s) removed

Listing all the rooms IDs in the first two pages of the list of rooms: 
99445276259151407
99445276259151408
99445276259151409

Deleted the room with ID:  99445276259151407

Articoli di riferimento

Per informazioni sul set completo delle funzionalità delle sale di Azure Communication Services, vedere le informazioni di riferimento per l'SDK Java o le informazioni di riferimento per le API REST.

Una sala è uno spazio di comunicazione gestito dal server per un set di partecipanti noto e fisso per collaborare per una durata predeterminata. Per altre informazioni, vedere API Rooms per riunioni strutturate.

Prerequisiti

Codice di esempio

Esaminare e scaricare il codice di esempio da GitHub su Avvio rapido di Rooms - Python.

Configurazione

Creare una nuova applicazione Python

In una finestra del terminale o della console creare una nuova cartella per l'applicazione e passarvi.

mkdir acs-rooms-quickstart
cd acs-rooms-quickstart

Installare il pacchetto

È necessario usare la libreria client di Azure Communication Rooms per Python versione 1.1.0 o successiva.

Da un prompt della console, passare alla directory contenente il file rooms.py, quindi eseguire il comando seguente:

pip install azure-communication-rooms

Configurare il framework dell'app

Creare un nuovo file denominato rooms-quickstart.py e aggiungere la struttura del programma di base.

import os
from datetime import datetime, timedelta
from azure.core.exceptions import HttpResponseError
from azure.communication.rooms import (
    RoomsClient,
    RoomParticipant,
    ParticipantRole
)

class RoomsQuickstart(object):
    print("Azure Communication Services - Rooms Quickstart")
    #room method implementations goes here

if __name__ == '__main__':
    rooms = RoomsQuickstart()

Inizializzare un client della sala

Creare un nuovo oggetto RoomsClient, necessario per creare nuove sale e gestire le loro proprietà e il loro ciclo di vita. Usare la stringa di connessione del servizio comunicazioni per autenticare la richiesta. Per altre informazioni sulle stringhe di connessione, vedere Creare una risorsa di comunicazione.

#Find your Communication Services resource in the Azure portal
connection_string = '<connection_string>'
rooms_client = RoomsClient.from_connection_string(connection_string)

Creare una sala

Configurare i partecipanti alla sala

Per configurare chi può partecipare a una sala, è necessario un elenco delle identità di tali utenti. Seguire le istruzioni in Token di accesso per creare utenti ed emettere token di accesso. In alternativa, per creare gli utenti su richiesta, è possibile crearli usando .CommunicationIdentityClient Le sale di Servizi di comunicazione di Azure supportano attualmente solo un partecipante della sala di tipo CommunicationUserIdentifier. L'uso di CommunicationIdentity di altri tipi causa un errore di runtime.

Per usare CommunicationIdentityClient, installare il pacchetto seguente:

pip install azure-communication-identity

Importare anche lo spazio dei nomi del pacchetto nella parte superiore del file rooms-quickstart.py:

from azure.communication.identity import (
    CommunicationIdentityClient
)

A questo momento, inizializzare CommunicationIdentityClient e usarlo per creare utenti:

# Create identities for users who will join the room
identity_client = CommunicationIdentityClient.from_connection_string(connection_string)
user1 = identity_client.create_user()
user2 = identity_client.create_user()
user3 = identity_client.create_user()

Creare quindi l'elenco dei partecipanti alla sala facendo riferimento a tali utenti:

participant_1 = RoomParticipant(communication_identifier=user1, role=ParticipantRole.PRESENTER)
participant_2 = RoomParticipant(communication_identifier=user2, role=ParticipantRole.CONSUMER)
participants = [participant_1, participant_2]

Inizializzare la sala

Creare una nuova sala usando l'oggetto participants definito nel frammento di codice precedente:

# Create a room
valid_from = datetime.now()
valid_until = valid_from + timedelta(weeks=4)
pstn_dial_out_enabled = False

try:
    create_room = rooms_client.create_room(
        valid_from=valid_from,
        valid_until=valid_until,
        pstn_dial_out_enabled=pstn_dial_out_enabled,
        participants=participants
    )
    print("\nCreated a room with id: " + create_room.id)
except HttpResponseError as ex:
    print(ex)

Poiché le sale sono entità lato server, è necessario tenere traccia e rendere persistente la room.id nel supporto di archiviazione preferito. È possibile fare riferimento a id per visualizzare o aggiornare le proprietà di un oggetto sala.

Abilitare la funzionalità di chiamata PSTN in uscita per una sala

Per impostazione predefinita, ogni camera ha la chiamata PSTN disattivata. È possibile abilitare la chiamata telefonica PSTN per una stanza al momento della creazione, definendo il pstn_dial_out_enabled parametro come true. È possibile modificare questa funzionalità per una sala inviando una richiesta di aggiornamento per il pstn_dial_out_enabled parametro .

# Create a room with PSTN dial out capability
pstn_dial_out_enabled = True
create_room = rooms_client.create_room(pstn_dial_out_enabled=pstn_dial_out_enabled)
print("\nCreated room with pstn_dial_out_enabled: " + updated_room.pstn_dial_out_enabled)

# Update a room to enable or disable PSTN dial out capability
pstn_dial_out_enabled= False
updated_room = rooms_client.update_room(room_id=room_id, pstn_dial_out_enabled=pstn_dial_out_enabled)
print("\nUpdated room with pstn_dial_out_enabled: " + updated_room.pstn_dial_out_enabled)

Ottenere le proprietà di una sala esistente

Recuperare i dettagli di un oggetto room esistente facendo riferimento a id:

# Retrieves the room with corresponding ID
room_id = create_room.id
try:
    get_room = rooms_client.get_room(room_id=room_id)
    print("\nRetrieved room with id: ", get_room.id)
except HttpResponseError as ex:
    print(ex)

Aggiornare la durata di una sala

È possibile modificare la durata di una sala inviando una richiesta di aggiornamento per i valid_from parametri e valid_until . Una sala può avere una validità massima di sei mesi.

# Update the lifetime of a room
valid_from =  datetime.now()
valid_until = valid_from + timedelta(weeks=7)
pstn_dial_out_enabled=True

try:
    updated_room = rooms_client.update_room(room_id=room_id, valid_from=valid_from, valid_until=valid_until, pstn_dial_out_enabled=pstn_dial_out_enabled)
     print("\nUpdated room with validFrom: " + updated_room.valid_from + ", validUntil: " + updated_room.valid_until + " and pstn_dial_out_enabled: " + updated_room.pstn_dial_out_enabled)
except HttpResponseError as ex:
    print(ex)

Elencare tutte le sale attive

Per recuperare tutte le sale attive create nella risorsa, usare il metodo list_rooms esposto nel client.

# List all active rooms
try:
    rooms = rooms_client.list_rooms()
    count = 0
    for room in rooms:
        if count == 1:
            break
        print("\nPrinting the first room in list"
            "\nRoom Id: " + room.id +
            "\nCreated date time: " + str(room.created_at) +
            "\nValid From: " + str(room.valid_from) + 
            "\nValid Until: " + str(room.valid_until) +
            "\nPSTN Dial-Out Enabled: " + str(room.pstn_dial_out_enabled))
        count += 1
except HttpResponseError as ex:
    print(ex)

Aggiungere o aggiornare partecipanti

Per aggiungere nuovi partecipanti o aggiornare i partecipanti esistenti in una sala, usare il add_or_update_participants metodo esposto nel client.

# Add or update participants in a room
try:
    # Update existing user2 from consumer to attendee
    participants = []
    participants.append(RoomParticipant(communication_identifier=user2, role=ParticipantRole.ATTENDEE))

    # Add new participant user3
    participants.append(RoomParticipant(communication_identifier=user3, role=ParticipantRole.COLLABORATOR))
    rooms_client.add_or_update_participants(room_id=room_id, participants=participants)
    print("\nAdd or update participants in room")

except HttpResponseError as ex:
    print('Error in adding or updating participants to room.', ex)

Quando si aggiungono partecipanti a una sala, diventano idonei per partecipare alle chiamate.

Elencare i partecipanti in una sala

Recuperare l'elenco dei partecipanti per una sala esistente facendo riferimento a room_id:

# Get list of participants in room
try:
    participants = rooms_client.list_participants(room_id)
    print('\nParticipants in Room Id :', room_id)
    for p in participants:
        print(p.communication_identifier.properties['id'], p.role)
except HttpResponseError as ex:
    print(ex)

Rimuovere partecipanti

Per rimuovere un partecipante da una stanza e revocarne l'accesso, usare il remove_participants metodo .

# Remove Participants
try:
    participants = [user2]
    rooms_client.remove_participants(room_id=room_id, participants=participants)
    print("\nRemoved participants from room")

except HttpResponseError as ex:
    print(ex)

Eliminare sala

Per eliminare una stanza esistente, eseguire una richiesta di eliminazione esplicita. Tutte le sale e le risorse associate vengono eliminate automaticamente al termine della loro validità più un periodo di tolleranza.

# Delete Room

rooms_client.delete_room(room_id=room_id)
print("\nDeleted room with id: " + room_id)

Eseguire il codice

Per eseguire il codice, assicurarsi di trovarsi nella stessa directory del rooms-quickstart.py file.

python rooms-quickstart.py

L'output previsto descrive ogni azione completata:

Azure Communication Services - Rooms Quickstart

Created a room with id:  99445276259151407

Retrieved room with id:  99445276259151407

Updated room with validFrom: 2023-05-03T00:00:00+00:00, validUntil: 2023-06-23T00:00:00+00:00 and pstn_dial_out_enabled: True

Printing the first room in list
Room Id: 99445276259151407
Created date time: 2023-05-03T00:00:00+00:00
Valid From: 2023-05-03T00:00:00+00:00
Valid Until: 2023-06-23T00:00:00+00:00
PSTN Dial-Out Enabled: True

Add or update participants in room

Participants in Room Id : 99445276259151407
8:acs:42a0ff0c-356d-4487-a288-ad0aad95d504_00000018-ef00-6042-a166-563a0d0051c1 Presenter
8:acs:42a0ff0c-356d-4487-a288-ad0aad95d504_00000018-ef00-6136-a166-563a0d0051c2 Consumer
8:acs:42a0ff0c-356d-4487-a288-ad0aad95d504_00000018-ef00-61fd-a166-563a0d0051c3 Collaborator

Removed participants from room

Deleted room with id: 99445276259151407

Documentazione di riferimento

Per informazioni sul set completo di funzionalità delle sale di Servizi di comunicazione di Azure, vedere le informazioni di riferimento su Python SDK o le informazioni di riferimento per le API REST.

Una sala è uno spazio di comunicazione gestito dal server per un set di partecipanti noto e fisso per collaborare per una durata predeterminata. Per altre informazioni, vedere API Rooms per riunioni strutturate.

Prerequisiti

Codice di esempio

Esaminare e scaricare il codice di esempio da GitHub su Avvio rapido per le sale - JavaScript.

Configurazione

Creare una nuova applicazione Web

In una finestra del terminale o della console creare una nuova cartella per l'applicazione e passarvi.

mkdir acs-rooms-quickstart && cd acs-rooms-quickstart

Eseguire npm init per creare un file package.json con le impostazioni predefinite.

npm init -y

Creare un nuovo file index.js in cui aggiungere il codice per questo esempio.

Installare i pacchetti

È necessario usare la libreria client di Azure Communication Rooms per JavaScript versione 1.1.0 o successiva.

Usare il npm install comando per installare gli SDK di Servizi di comunicazione seguenti per JavaScript.

npm install @azure/communication-rooms --save

Configurare il framework dell'app

Nel file index.js aggiungere il codice seguente. Aggiungere il codice per questo esempio nella main funzione .

const { RoomsClient } = require('@azure/communication-rooms');

const main = async () => {
  console.log("Azure Communication Services - Rooms Quickstart")

  // Quickstart code goes here

};

main().catch((error) => {
  console.log("Encountered an error");
  console.log(error);
})

Inizializzare un client della sala

Creare un nuovo oggetto RoomsClient, necessario per creare nuove sale e gestire le loro proprietà e il loro ciclo di vita. Usare la stringa di connessione del servizio comunicazioni per autenticare la richiesta. Per altre informazioni sulle stringhe di connessione, vedere Creare una risorsa di comunicazione.

Aggiungere il codice seguente all'interno di index.js della funzione main.

const connectionString =
    process.env["COMMUNICATION_CONNECTION_STRING"] ||
    "endpoint=https://<resource-name>.communication.azure.com/;<access-key>";

// create RoomsClient
const roomsClient = new RoomsClient(connectionString);

Creare una sala

Configurare i partecipanti alla sala

Per configurare chi può partecipare a una sala, è necessario avere l'elenco delle identità di tali utenti. Seguire le istruzioni in Token di accesso per creare utenti ed emettere token di accesso. In alternativa, per creare gli utenti su richiesta, è possibile crearli usando .CommunicationIdentityClient Le sale di Servizi di comunicazione di Azure attualmente supportano solo un partecipante alla sala di tipo CommunicationUserIdentifier, l'uso di altri tipi di CommunicationIdentity causa un errore di runtime.

Per usare CommunicationIdentityClient, installare il pacchetto npm seguente:

npm install @azure/communication-identity --save

Aggiungere il pacchetto necessario seguente all'inizio del index.js file:

const { CommunicationIdentityClient } = require('@azure/communication-identity');

A questo momento, inizializzare CommunicationIdentityClient e usarlo per creare utenti:

// create identities for users
const identityClient = new CommunicationIdentityClient(connectionString);
const user1 = await identityClient.createUserAndToken(["voip"]);
const user2 = await identityClient.createUserAndToken(["voip"]);

Creare quindi l'elenco dei partecipanti alla sala facendo riferimento a tali utenti:

const participants = [
  {
      id: user1.user,
      role: "Presenter",
  },
  {
    id: user2.user,
    role: "Consumer",
  }
]

Inizializzare la sala

Creare una nuova sala usando l'oggetto participants definito nel frammento di codice precedente:

// Create a room
var validFrom = new Date(Date.now());
var validUntil = new Date(validFrom.getTime() + 60 * 60 * 1000);
var pstnDialOutEnabled = false;

const createRoomOptions = {
  validFrom,
  validUntil,
  pstnDialOutEnabled,
  participants
};

const createRoom = await roomsClient.createRoom(createRoomOptions);
const roomId = createRoom.id;
console.log("\nCreated a room with id: ", roomId);

Poiché le sale sono entità lato server, è necessario tenere traccia e rendere persistente la roomId nel supporto di archiviazione preferito. È possibile fare riferimento a roomId per visualizzare o aggiornare le proprietà di un oggetto room.

Abilitare la funzionalità di chiamata PSTN in uscita per una sala

Per impostazione predefinita, per ogni room la chiamata PSTN in uscita è disabilitata. È possibile abilitare la chiamata telefonica PSTN per una stanza al momento della creazione, definendo il pstnDialOutEnabled parametro come true. È anche possibile modificare questa funzionalità per un oggetto room inviando una richiesta di aggiornamento per il pstnDialOutEnabled parametro .

// Create a room with PSTN dial out capability
var pstnDialOutEnabled = true;
const createRoomOptions = {
  pstnDialOutEnabled,
};

const createRoom = await roomsClient.createRoom(createRoomOptions);
console.log("\nCreated a room with PSTN dial out enabled: ", createRoom.pstnDialOutEnabled);

// Update a room to enable or disable PSTN dial out capability
pstnDialOutEnabled = false;
const updateRoomOptions = {
  pstnDialOutEnabled,
};

const updateRoom = await roomsClient.updateRoom(roomId, updateRoomOptions);
console.log("\nUpdated a room with PSTN dial out enabled: ", updateRoom.pstnDialOutEnabled);

Ottenere le proprietà di una sala esistente

Recuperare i dettagli di una stanza esistente facendo riferimento a roomId:

// Retrieve the room with corresponding ID
const getRoom = await roomsClient.getRoom(roomId);
console.log("\nRetrieved room with id: ", getRoom.id);

Aggiornare la durata di una sala

È possibile modificare la durata di una sala inviando una richiesta di aggiornamento per i validFrom parametri e validUntil . Una sala può avere una validità massima di sei mesi.

// Update room lifetime
validFrom.setTime(validUntil.getTime());
validUntil.setTime(validFrom.getTime() + 5 * 60 * 1000);
pstnDialOutEnabled = true;
// request payload to update a room
const updateRoomOptions = {
  validFrom,
  validUntil,
  pstnDialOutEnabled,
};

const updateRoom = await roomsClient.updateRoom(roomId, updateRoomOptions);
console.log("\nUpdated room with validFrom: ", updateRoom.validFrom, ", validUntil: ", updateRoom.validUntil, " and pstnDialOutEnabled: ", updateRoom.pstnDialOutEnabled);

Ottenere l'elenco delle sale

Recuperare l'elenco di stanze usando il listRooms metodo :

const roomsList = await roomsClient.listRooms();
console.log("\nRetrieved list of rooms; printing first room:");
for await (const currentRoom of roomsList) {
  // access room data here
  console.log(currentRoom);
  break;
}

Aggiungere o aggiornare partecipanti

Per aggiungere nuovi partecipanti a una sala, usare il addOrUpdateParticipants metodo esposto nel client. Questo metodo aggiorna anche un partecipante se è già presente nella stanza.

// Add and update participants

const user3 = await identityClient.createUserAndToken(["voip"]);

// request payload to add and update participants
const addOUpdateParticipantsList = [
  {
      id: user1.user,
      role: "Presenter",
  },
  {
    id: user3.user,
    role: "Collaborator",
  }
]

// add user3 to the room and update user1 to Presenter role
await roomsClient.addOrUpdateParticipants(roomId, addOUpdateParticipantsList);
console.log("\nAdded and updated participants in the room");

Dopo aver aggiunto i partecipanti a una sala, sono idonei per partecipare alle chiamate.

Ottenere l'elenco dei partecipanti

Recuperare l'elenco dei partecipanti per una sala esistente facendo riferimento a roomId:

const participantsList = await roomsClient.listParticipants(roomId);
console.log("\nRetrieved participants for room:");
for await (const participant of participantsList) {
  // access participant data here
  console.log(participant);
}

Rimuovere partecipanti

Per rimuovere un partecipante da una stanza e revocarne l'accesso, usare il removeParticipants metodo .

// Remove both users from the room
const removeParticipantsList = [user1.user, user2.user]

// remove both users from the room with the request payload
await roomsClient.removeParticipants(roomId, removeParticipantsList);
console.log("\nRemoved participants from room");

Eliminare sala

Se si desidera eliminare una stanza esistente, è possibile inviare una richiesta di eliminazione esplicita. Tutte le sale e le relative risorse associate vengono eliminate automaticamente alla scadenza della loro validità seguita da un periodo di tolleranza.

// Deletes the specified room
await roomsClient.deleteRoom(roomId);
console.log("\nDeleted room with id: ", roomId)

Eseguire il codice

Per eseguire il codice, assicurarsi di trovarsi nella stessa directory del index.js file.

node index.js

L'output previsto descrive ogni azione completata:

Azure Communication Services - Rooms QuickStart

Created a room with id:  99445276259151407

Retrieved room with id:  99445276259151407

Updated room with validFrom:  2023-05-11T22:11:46.784Z, validUntil:  2023-05-11T22:16:46.784Z and pstnDialOutEnabled: true

Retrieved list of rooms; printing first room:

{
  id: "99445276259151407",
  createdAt: "2023-05-11T22:11:50.784Z",
  validFrom: "2023-05-11T22:11:46.784Z",
  validUntil: "2023-05-11T22:16:46.784Z"
}

Added and updated participants in the room

Retrieved participants for room:
{
  id: {
    kind: 'communicationUser',
    communicationUserId: '8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-ac89-7c76-35f3-343a0d00e901'
  },
  role: 'Presenter'
}
{
  id: {
    kind: 'communicationUser',
    communicationUserId: '8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-ac89-7ccc-35f3-343a0d00e902'
  },
  role: 'Consumer'
}
{
  id: {
    kind: 'communicationUser',
    communicationUserId: '8:acs:b6aada1f-0b1d-47ac-866f-91aae00a1d01_00000018-ac89-7ccc-35f3-343a0d00e903'
  },
  role: 'Collaborator'
}

Removed participants from room

Deleted room with id:  99445276259151407

Documentazione di riferimento

Per informazioni sul set completo di funzionalità delle sale di Servizi di comunicazione di Azure, vedere le informazioni di riferimento su JavaScript SDK o le informazioni di riferimento per le API REST.

Passaggi successivi

Dopo aver creato e configurato la stanza, puoi scoprire come partecipare a una chiamata in una sala.

Questo articolo descrive come:

  • Creare una nuova sala
  • Ottenere le proprietà di una sala
  • Aggiornare le proprietà di una sala
  • Eliminare una sala
  • Last updated on