Configurer les paramètres de l'espace de réunion

Un espace de réunion représente un lieu virtuel ou un objet persistant (comme une salle de réunion) où se tiennent les conférences. Un espace de réunion permet également aux utilisateurs de se rencontrer et de trouver des ressources partagées.

Lorsque vous créez un espace de réunion à l'aide de la méthode spaces.create, elle renvoie une instance d'une ressource spaces. La ressource inclut l'objet SpaceConfig qui correspond à la configuration de l'espace de réunion. Il contient également l'objet ActiveConference qui est un lien vers la ressource conferenceRecords actuelle dans l'espace de réunion. Pour en savoir plus sur la gestion d'un espace de réunion, consultez Gérer les espaces de réunion.

Les sections suivantes expliquent comment configurer un espace de réunion à l'aide de ces objets et méthodes.

Définir la modération et l'accès aux réunions

Vous pouvez définir la façon dont les utilisateurs rejoignent une réunion, les modes de modération, les restrictions de fonctionnalités et les autorisations dont ils bénéficient lorsqu'ils rejoignent une réunion, grâce à l'objet SpaceConfig.

Configurer l'accès aux réunions

Pour déterminer qui peut rejoindre un espace de réunion sans demander à y participer, définissez le champ accessType à l'aide de l'objet AccessType. Vous pouvez choisir parmi plusieurs paramètres pour autoriser automatiquement les participants à rejoindre la réunion. Par défaut, le champ reprend les paramètres d'accès par défaut de l'utilisateur.

Pour définir les points d'entrée qui peuvent être utilisés pour rejoindre des réunions hébergées dans un espace de réunion, définissez le champ entryPointAccess à l'aide de l'objet EntryPointAccess. Définissez la valeur sur ALL pour autoriser tous les points d'entrée ou sur CREATOR_APP_ONLY pour limiter les points d'entrée à ceux appartenant au projet Google Cloud qui a créé l'espace de réunion.

L'exemple de code suivant montre comment configurer les paramètres d'accès pour un espace de réunion :

Java

import com.google.apps.meet.v2.Space;
import com.google.apps.meet.v2.SpaceConfig;
import com.google.apps.meet.v2.SpacesServiceClient;
import com.google.apps.meet.v2.UpdateSpaceRequest;
import com.google.protobuf.FieldMask;

public class ConfigureSpaceAccess {
  public static void main(String[] args) throws Exception {
    try (SpacesServiceClient client = SpacesServiceClient.create()) {
      Space space =
          Space.newBuilder()
              .setName("spaces/SPACE_NAME")
              .setConfig(
                  SpaceConfig.newBuilder()
                      .setAccessType(SpaceConfig.AccessType.RESTRICTED)
                      .setEntryPointAccess(SpaceConfig.EntryPointAccess.ALL)
                      .build())
              .build();
      FieldMask updateMask =
          FieldMask.newBuilder()
              .addPaths("config.access_type")
              .addPaths("config.entry_point_access")
              .build();
      UpdateSpaceRequest request =
          UpdateSpaceRequest.newBuilder()
              .setSpace(space)
              .setUpdateMask(updateMask)
              .build();
      Space response = client.updateSpace(request);
      System.out.println("Updated space: " + response.getName());
    }
  }
}

Node.js

const {SpacesServiceClient} = require('@google-apps/meet').v2;

async function configureSpaceAccess(spaceName) {
  const meetClient = new SpacesServiceClient();
  const [response] = await meetClient.updateSpace({
    space: {
      name: spaceName,
      config: {
        accessType: 'RESTRICTED',
        entryPointAccess: 'ALL',
      },
    },
    updateMask: {
      paths: ['config.access_type', 'config.entry_point_access'],
    },
  });
  console.log(`Updated space: ${response.name}`);
  return response;
}

Python

from google.apps import meet_v2
from google.protobuf import field_mask_pb2

def configure_space_access(space_name):
    client = meet_v2.SpacesServiceClient()
    space = meet_v2.Space(
        name=space_name,
        config=meet_v2.SpaceConfig(
            access_type=meet_v2.SpaceConfig.AccessType.RESTRICTED,
            entry_point_access=meet_v2.SpaceConfig.EntryPointAccess.ALL,
        ),
    )
    update_mask = field_mask_pb2.FieldMask(
        paths=["config.access_type", "config.entry_point_access"]
    )
    request = meet_v2.UpdateSpaceRequest(
        space=space,
        update_mask=update_mask
    )
    response = client.update_space(request=request)
    print(f"Updated space: {response.name}")
    return response

Apps Script

function configureSpaceAccess(spaceName) {
  const baseUrl = 'https://meet.googleapis.com/v2/';
  const mask = 'updateMask=config.accessType,config.entryPointAccess';
  const response = UrlFetchApp.fetch(`${baseUrl}${spaceName}?${mask}`, {
    method: 'patch',
    contentType: 'application/json',
    headers: {
      Authorization: 'Bearer ' + ScriptApp.getOAuthToken(),
    },
    payload: JSON.stringify({
      config: {
        accessType: 'RESTRICTED',
        entryPointAccess: 'ALL',
      },
    }),
  });
  const space = JSON.parse(response.getContentText());
  Logger.log('Updated space: ' + space.name);
  return space;
}

cURL

curl -X PATCH \
  "https://meet.googleapis.com/v2/spaces/SPACE_NAME?updateMask=config.accessType,config.entryPointAccess" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "config": {
      "accessType": "RESTRICTED",
      "entryPointAccess": "ALL"
    }
  }'

Remplacez ACCESS_TOKEN par le jeton d'accès qui permet d'accéder à l'API.

Remplacez le nom de l'espace par l'ID unique généré par le serveur pour l'espace de réunion.

Configurer les paramètres de modération

Pour modérer une réunion, vous pouvez définir le champ moderation à l'aide de l'objet Moderation. Lorsque le mode moderation est défini sur on, l'organisateur de la réunion contrôle la réunion à l'aide de fonctionnalités telles que la gestion des coorganisateurs (voir spaces.members) et les restrictions de fonctionnalités à l'aide du champ moderationRestrictions. Pour en savoir plus sur les membres, consultez Gérer les membres d'un espace de réunion.

Pour définir des restrictions concernant les fonctionnalités lorsque la réunion est modérée (moderation est défini sur on), définissez le champ moderationRestrictions à l'aide de l'objet ModerationRestrictions. Les restrictions définissent qui est autorisé à envoyer des messages de chat ou des réactions, ou à partager son écran dans l'espace de réunion.

Pour définir les restrictions de fonctionnalités sur le champ moderationRestrictions, utilisez RestrictionType pour appliquer chatRestriction, reactionRestriction et presentRestriction. Définissez la valeur sur HOSTS_ONLY pour appliquer les autorisations à l'organisateur de la réunion et aux coorganisateurs, ou sur NO_RESTRICTION pour les appliquer à tous les participants.

Pour limiter le rôle par défaut attribué aux utilisateurs à celui de lecteur, définissez le champ defaultJoinAsViewerType à l'aide de DefaultJoinAsViewerType. Si defaultJoinAsViewerType est défini sur on, les utilisateurs rejoignent la réunion en tant que spectateurs. Si la valeur est off, les utilisateurs rejoignent le groupe en tant que contributeurs. La valeur par défaut est off Si un rôle explicite est défini pour un utilisateur dans spaces.members, il rejoint la réunion avec ce rôle.

Configurer les rapports de présence

Pour créer un rapport sur la présence dans l'espace de réunion, définissez le champ attendanceReportGenerationType à l'aide de l'objet AttendanceReportGenerationType. Si un rapport est demandé, Google Meet l'enregistre dans le Google Drive de l'organisateur de la réunion et envoie également un e-mail.

Gérer les artefacts automatiques

Les organisateurs de réunions, mais pas les coorganisateurs, peuvent préconfigurer l'enregistrement automatique, la transcription automatique et les notes intelligentes dans l'espace de réunion. Lorsque ces paramètres sont activés, l'espace de réunion est enregistré, des transcriptions sont générées, et les notes de réunion sont capturées et organisées automatiquement dans Google Docs. Chaque fonctionnalité est indépendante et est définie pour chaque espace de réunion. Les sous-titres des enregistrements ne sont disponibles qu'en anglais.

Vous pouvez préconfigurer les artefacts automatiques lorsque vous créez un espace de réunion ou une fois l'espace de réunion créé. Les deux méthodes nécessitent le champ d'application OAuth meetings.space.settings. Pour en savoir plus, consultez Champs d'application OAuth par cas d'utilisation.

Vous pouvez également configurer des artefacts automatiques pour les réunions créées à partir de Google Agenda.

Pour définir des artefacts automatiques, utilisez l'objet ArtifactConfig dans l'objet SpaceConfig. ArtifactConfig est composé des champs recordingConfig, transcriptionConfig et smartNotesConfig.

Chaque champ est mappé à un objet similaire tel que RecordingConfig, TranscriptionConfig et SmartNotesConfig. Pour définir chaque objet, utilisez AutoGenerationType pour activer ou désactiver l'objet de configuration on ou off.

Pour récupérer les artefacts créés lors d'une conférence, consultez Utiliser des artefacts.

Différences entre les transcriptions et les notes intelligentes

Bien que les transcriptions de réunion et les notes intelligentes (également appelées "Prendre des notes pour moi") capturent des informations issues de votre réunion, ces fonctionnalités ont des objectifs différents et produisent des artefacts différents.

Le tableau suivant présente les différences entre ces deux types de comptes :

Fonctionnalité Transcriptions Notes intelligentes
Présentation Un enregistrement mot pour mot. Un résumé concis des points clés généré par Gemini.
Niveau de détail 100% de détails. Tout ce qui est dit est écrit. Général. Se concentre sur les décisions et les tâches à effectuer.
Cas d'utilisation Conformité légale, vérification des citations exactes et accessibilité pour les utilisateurs Permet aux participants en retard de rattraper leur retard instantanément, et automatise la prise de notes et le suivi des projets.
Utilisation en temps réel Utilisé pour les sous-titres. Le fichier est généré après l'appel. Vous pouvez voir le résumé se construire dans le panneau latéral pendant l'appel.
Résultat Un long document Docs avec le nom des intervenants et des codes temporels. Document Docs concis contenant des notes de réunion avec des sections et des puces.
Citation Contient le texte intégral auquel il est possible d'associer un lien. Inclut des citations (codes temporels) qui renvoient au moment précis de la transcription pour le contexte, si les transcriptions et les notes intelligentes sont activées. Pour en savoir plus, consultez Lorsque les deux fonctionnalités sont activées.

Lorsque les deux fonctionnalités sont activées

Bien que chaque fonctionnalité puisse être utilisée séparément, les transcriptions et les notes intelligentes peuvent également être utilisées en même temps pour créer de meilleurs artefacts post-réunion.

Lorsque les deux sont activées, des citations s'affichent dans le document de notes intelligentes généré. Ces citations se trouvent dans la section "Détails" et renvoient à des codes temporels spécifiques dans la transcription de la réunion. En cliquant sur ces citations, vous pouvez accéder directement à la section correspondante de la transcription afin de mieux comprendre la discussion.

Pendant la réunion, les participants voient des indicateurs indiquant que les deux fonctionnalités sont actives. Ils doivent rester actifs pendant toute la durée de la réunion pour générer des citations cliquables. Même si les fichiers sont liés, le système génère toujours deux documents distincts dans le Drive de l'hôte. Les deux fichiers sont également associés automatiquement à l'événement Agenda.

Pour en savoir plus sur les champs d'application OAuth requis pour les espaces et les paramètres de réunion, consultez Champs d'application OAuth par cas d'utilisation.