Recevoir des interactions utilisateur et y répondre

Cette page explique comment votre application Google Chat peut recevoir des interactions utilisateur et y répondre dans Google Chat.

Pour créer des interfaces interactives pour les applications Chat, vous utilisez les composants suivants :

• Déclencheurs : façons dont les utilisateurs de Google Chat peuvent appeler une application Chat, par exemple en l'ajoutant à un espace ou en lui envoyant un message.
• Objets d'événement : données que les applications Chat reçoivent des déclencheurs ou des interactions avec l'interface utilisateur.
• Actions : façons dont les applications Chat peuvent répondre aux interactions, par exemple en envoyant des messages ou en renvoyant une interface utilisateur basée sur des fiches.

Figure 1 : Lorsqu'un utilisateur ajoute une application Chat à un espace, le déclencheur Ajouté à l'espace se déclenche et envoie un objet d'événement. Pour répondre par un message, l'application Chat gère l'objet d'événement et renvoie une action qui crée le message.

Les applications Chat peuvent créer et afficher des interfaces de différentes manières :

• Messages pouvant contenir du texte, des fiches statiques ou interactives, et des boutons d'accessoires.
• Pages d'accueil (accueil de l'application) qui s'affichent dans l'onglet Accueil des messages privés avec l'application Chat.
• Boîtes de dialogue, qui sont des fiches s'ouvrant dans une nouvelle fenêtre et invitant généralement les utilisateurs à envoyer des informations.
• Aperçus de liens, qui sont des fiches prévisualisant des informations sur un service externe.

Prérequis

• Compte Google Workspace Business ou Enterprise ayant accès à Google Chat.
• Créez un projet Google Cloud.
• Configurez l'écran de consentement OAuth.
• Activez et configurez l'API Google Chat.

Fonctionnement des interactions utilisateur

Lorsqu'un utilisateur interagit avec une application Chat, Google Chat appelle un déclencheur configuré et envoie un objet d'événement au point de terminaison ou à la fonction de votre application Chat. Votre application Chat traite l'objet d'événement et peut soit renvoyer une action de manière synchrone dans un délai de 30 secondes, soit répondre de manière asynchrone à l'aide de l'API Chat.

Le schéma suivant montre comment les applications Google Chat traitent les interactions des utilisateurs et y répondent :

Déclencheurs

Les déclencheurs sont les moyens spécifiques par lesquels les utilisateurs appellent une application Chat à l'aide de l'interface utilisateur de Chat, par exemple en utilisant des @mentions ou des commandes d'application.

Le tableau suivant présente les déclencheurs Chat, leur description et la manière dont les applications Chat y répondent généralement :

Déclencheur	Description	Réponse type
Ajouté à l'espace	Un utilisateur ajoute l'application Chat à un espace, ou un administrateur Google Workspace installe l'application Chat dans les espaces de messages privés pour les utilisateurs de son organisation. Pour en savoir plus sur les applications Chat installées par les administrateurs, consultez Installer des applications Marketplace dans votre domaine dans la documentation d'aide de la console d'administration Google Workspace.	L'application Chat envoie un message d'intégration qui explique ce qu'elle fait et comment les utilisateurs de l'espace peuvent interagir avec elle.
Message	Un utilisateur interagit avec l'application Chat dans un message de l'une des manières suivantes : Envoie un message dans un espace de message privé (MP) avec l'application Chat. @mentionne l'application Chat dans n'importe quel type d'espace. Envoie un message contenant un lien qui correspond au format d'URL des aperçus de liens. Saisit du texte dans le menu de sélection multiple d'un widget selectionInput.	L'application Chat répond en fonction du contenu du message. Par exemple, une application Chat répond avec un message, joint une fiche d'aperçu de lien ou suggère des éléments dans un menu à sélection multiple.
Supprimé de l'espace	Un utilisateur supprime l'application Chat d'un espace ou un administrateur Google Workspace désinstalle l'application Chat pour un utilisateur de son organisation. Les utilisateurs ne peuvent pas supprimer les applications Chat installées par leur administrateur. Si un utilisateur a déjà installé l'application Chat, elle reste installée, même si un administrateur Google Workspace tente de la désinstaller.	L'application Chat supprime toutes les notifications entrantes configurées pour l'espace (par exemple, en supprimant un webhook) et libère de l'espace de stockage interne. Les applications Chat ne peuvent pas répondre à ce déclencheur par des messages, car elles ne sont plus membres de l'espace.
Commande d'application	Un utilisateur appelle une commande d'application Chat (par exemple, une commande à barre oblique, une commande rapide ou une action de message).	L'application Chat répond à la commande. Par exemple, elle répond par un message ou ouvre une boîte de dialogue.
Page d'accueil de l'application	Un utilisateur ouvre l'onglet Accueil dans un espace de message privé (MP) avec l'application Chat ou interagit avec un widget sur la fiche de la page d'accueil.	L'application Chat renvoie un objet RenderActions qui affiche une fiche de page d'accueil (pushCard) ou met à jour la fiche de page d'accueil affichée (updateCard).

Vous configurez les points de terminaison ou les fonctions de rappel pour ces déclencheurs dans la console Google Cloud, sur la page Configuration de l'API Chat. Pour obtenir des instructions détaillées, consultez Configurer l'API Google Chat.

Configurer les prompts de démarrage

Preview développeur : disponible dans le cadre du programme Preview développeur Google Workspace, qui permet d'accéder en accès anticipé à certaines fonctionnalités.

Les prompts de démarrage aident les utilisateurs à découvrir les fonctionnalités de votre application Chat lorsqu'ils ouvrent un message privé vide avec votre application. Vous pouvez configurer jusqu'à trois prompts de démarrage.

Pour ajouter et configurer des prompts de démarrage :

1. Dans la console Google Cloud, accédez à la page Configuration de l'API Chat :

   Accéder à la page de configuration de l'API Chat

2. Sous Fonctionnalités interactives, recherchez Prompts de démarrage, puis cliquez sur Ajouter un prompt.

3. Dans le champ Classement (1-3), saisissez un nombre compris entre 1 et 3 pour spécifier l'ordre d'affichage.

4. Sous Sélection du type, choisissez le comportement de l'invite :

   • Prompt textuel : remplit la barre de rédaction avec du texte prédéfini lorsque l'utilisateur clique sur le chip de prompt.
   • Invite de commande : exécute une commande à barre oblique ou une commande rapide enregistrée lorsque vous cliquez dessus. Les commandes qui nécessitent des arguments supplémentaires ne peuvent pas être sélectionnées.

5. Configurez la requête en fonction de votre sélection de type :

   • Si vous avez sélectionné "Prompt textuel" :

     1. Dans Titre, saisissez le titre du prompt affiché sur le chip (jusqu'à 30 caractères).
     2. Dans Texte du prompt, saisissez le texte renseigné dans la barre de rédaction (60 caractères maximum).
     3. (Facultatif) Ajoutez des titres et du texte localisés pour les utilisateurs d'autres langues :
     4. Sous Requêtes localisées, cliquez sur Ajouter une langue.
     5. Dans Langue, sélectionnez une langue compatible dans le menu déroulant.
     6. Dans Titre localisé, saisissez le titre localisé (jusqu'à 30 caractères).
     7. Dans Texte de l'invite localisé, saisissez le texte de l'invite localisé (60 caractères maximum).
     8. Répétez l'opération pour ajouter d'autres langues si nécessaire.

   • Si vous avez sélectionné "Invite de commande" :

     1. Dans Commande à barre oblique/Commande rapide, sélectionnez la commande dans le menu déroulant.

6. Cliquez sur OK, puis sur Enregistrer en bas de la page.

Gérer les nouvelles tentatives d'appel HTTP vers votre service

Si une requête HTTPS adressée à votre service échoue (par exemple, en raison d'un délai d'expiration, d'une défaillance temporaire du réseau ou d'un code d'état HTTPS autre que 2xx), Google Chat peut réessayer de l'envoyer plusieurs fois en quelques minutes (mais cela n'est pas garanti). Par conséquent, une application Chat peut recevoir le même événement plusieurs fois dans certaines situations. Si la requête aboutit, mais renvoie une charge utile de réponse non valide, Google Chat ne la relance pas.

Objets d'événement

Les applications Chat reçoivent des objets d'événement lorsqu'un déclencheur Chat s'exécute ou lorsque les utilisateurs de Chat interagissent avec une UI de l'application Chat (par exemple, en cliquant sur un bouton ou en envoyant une boîte de dialogue). L'objet d'événement vous permet d'utiliser les données d'interaction pour répondre ou mettre à jour une UI.

En 2025, les applications Google Chat ont été étendues pour prendre en charge les événements de modules complémentaires, et cela est devenu la valeur par défaut pour les nouvelles applications Chat depuis juillet 2025. Dans la documentation Chat, les événements de modules complémentaires sont le type d'événement standard présenté dans les guides et les exemples de code. La documentation sur les événements Chat (pour les applications Chat qui ne sont pas des modules complémentaires Google Workspace) est divisée en sections réductibles (par exemple, Applications Chat qui ne sont pas des modules complémentaires : recevoir des événements d'interaction et y répondre).

Déterminer les types d'événements et de réponses

Lorsque votre application Chat reçoit un objet d'événement, la structure de la charge utile et la façon dont vous répondez dépendent de la configuration de votre application Chat en tant que module complémentaire Google Workspace.

Pour confirmer le type d'objets d'événement que votre application reçoit et comment elle doit y répondre, vérifiez la configuration de votre application à l'aide du tableau suivant :

Type d'application	Reçoit les événements des modules complémentaires (par défaut pour les nouvelles applications créées après juillet 2025)	Recevoir les événements Chat (Ancienne valeur par défaut, avant juillet 2025)
Applications Apps Script Vérifiez le fichier manifeste (appsscript.json)	L'objet chat est configuré dans addOns : { "addOns": { "chat": {} } }	L'objet chat est configuré à la racine du fichier manifeste : { "chat": {} }
Autres applications Consultez la page de configuration de l'API Google Chat.	La case "Créer cette application Chat en tant que module complémentaire Google Workspace" est cochée.	La case "Créer cette application Chat en tant que module complémentaire Google Workspace" n'est pas cochée.
Où trouver la documentation	Dans les guides et les exemples de code Documentation de référence sur les événements : Objets d'événement du module complémentaire	Sections réduites (par exemple, Applications Chat qui ne sont pas des modules complémentaires : recevoir des événements d'interaction et y répondre) Documentation de référence sur les événements : Événements d'interaction de l'API Chat
Actions à mettre en place	Renvoyez une action, telle que DataActions ou RenderActions. Découvrir comment répondre avec une action	Renvoie une ressource Message. Découvrez comment répondre par un message

Charges utiles des objets d'événement

Chaque objet d'événement de module complémentaire inclut un commonEventObject avec des détails sur l'hôte et la plate-forme (hostApp: "CHAT", clientPlatform, userLocale, userTimezone, parameters et formInputs) et un objet chat contenant un contexte spécifique à Chat :

• Pour un déclencheur Accueil de l'application (lorsqu'un utilisateur ouvre l'onglet Accueil dans un message privé avec l'application Chat), l'objet chat contient chat.user et chat.eventTime sans champ d'union payload. Lorsqu'un utilisateur clique sur un bouton de la fiche de la page d'accueil, l'objet d'événement inclut chat.buttonClickedPayload ainsi que commonEventObject.parameters (et commonEventObject.formInputs si la fiche contient des entrées de formulaire).
• Pour les interactions avec l'espace et les messages (Ajouté à l'espace, Message, Supprimé de l'espace, Commande d'application, ou interactions avec les boutons et les widgets), l'objet chat inclut chat.user, chat.space, chat.eventTime et la charge utile d'interaction correspondante :
  • messagePayload : contient les éléments space, message et configCompleteRedirectUri lorsqu'un utilisateur envoie un message.
  • addedToSpacePayload : contient les éléments space, interactionAdd et configCompleteRedirectUri lorsque l'application Chat est ajoutée à un espace.
  • removedFromSpacePayload : contient l'space lorsque l'application Chat est supprimée d'un espace.
  • buttonClickedPayload : contient les éléments space, message, isDialogEvent et dialogEventType lorsqu'un utilisateur clique sur un bouton d'une fiche ou d'une boîte de dialogue.
  • widgetUpdatedPayload : contient la valeur space lorsqu'un utilisateur interagit avec un widget, par exemple en saisissant du texte dans un menu à sélection multiple avec une source de données externe.
  • appCommandPayload : contient les éléments space, message, appCommandMetadata, isDialogEvent, dialogEventType et configCompleteRedirectUri lorsqu'un utilisateur appelle une commande d'application.

Pour en savoir plus sur les objets d'événement de module complémentaire dans Chat et d'autres applications Google Workspace, consultez Objets d'événement.

Transmission d'une réponse

Cette section explique comment les applications Chat utilisent des actions pour répondre de manière synchrone aux interactions des utilisateurs.

Pour répondre par une action, une application Chat doit répondre dans un délai de 30 secondes, et la réponse doit s'appliquer à l'espace où l'interaction a eu lieu. Ces réponses synchrones ne nécessitent pas d'authentification. Si votre application Chat a besoin de plus de 30 secondes ou doit agir en dehors de l'espace, configurez l'authentification et répondez de manière asynchrone à l'aide de l'API Google Chat.

Remarque : Cette documentation suppose que votre application reçoit des événements de modules complémentaires. Pour confirmer le type de réponse que votre application doit renvoyer, consultez Déterminer les types d'événements et de réponses.

Pour répondre aux interactions des utilisateurs de manière synchrone, votre application Chat gère l'objet d'événement entrant et renvoie l'un des objets JSON suivants :

• DataActions : crée ou met à jour des messages de chat (CreateMessageAction, UpdateMessageAction) ou associe des aperçus de liens (UpdateInlinePreviewAction) à l'aide de chatDataActionMarkup.
• RenderActions : crée, met à jour ou ferme une page d'accueil ou une boîte de dialogue (pushCard, updateCard, endNavigation: "CLOSE_DIALOG"), ou fournit des suggestions de saisie dynamiques pour un menu à sélection multiple (modifyCard).
• AuthorizationError : invite les utilisateurs à se connecter ou à s'authentifier auprès d'un service externe à l'aide d'une fiche d'autorisation de base (basic_authorization_prompt).

Le tableau suivant montre comment les applications Chat peuvent répondre avec des actions. Les applications Chat peuvent renvoyer directement des objets JSON ou créer la réponse à l'aide de AddOnResponseService et CardService d'Apps Script.

Réponse de l'application Chat	Action requise à renvoyer (JSON)	Action requise pour le retour (Apps Script)
Envoyez un message ou mettez-en un à jour.	DataActions (createMessageAction ou updateMessageAction)	DataActionsResponse
Prévisualiser les liens dans les messages que les utilisateurs de Chat envoient dans un espace.	DataActions (updateInlinePreviewAction)	DataActionsResponse
Afficher ou mettre à jour une page d'accueil dans l'onglet Accueil d'un message privé.	RenderActions (pushCard ou updateCard)	ActionResponse
Ouvrir, mettre à jour ou fermer une boîte de dialogue.	RenderActions (pushCard, updateCard ou endNavigation: "CLOSE_DIALOG")	ActionResponse
Pour collecter des informations à partir d'une fiche ou d'une boîte de dialogue, suggérez des éléments de sélection en fonction de ce que les utilisateurs saisissent dans un menu à sélection multiple.	RenderActions (modifyCard)	ActionResponse
Demandez la configuration ou l'autorisation d'un service externe.	AuthorizationError (basic_authorization_prompt)	AuthorizationException

Répondre par un message

Les applications Chat peuvent répondre par un message à l'un des déclencheurs ou interactions suivants :

• Déclencheurs de messages, par exemple lorsqu'un utilisateur @mentionne une application Chat ou lui envoie un message privé.
• Déclencheurs Ajouté à l'espace, par exemple lorsque les utilisateurs installent l'application Chat depuis Google Workspace Marketplace ou l'ajoutent à un espace.
• Déclencheurs de commande d'application, par exemple lorsqu'un utilisateur appelle une commande à barre oblique ou une commande rapide.
• Clics sur les boutons des fiches dans les messages ou les boîtes de dialogue. Par exemple, lorsque les utilisateurs saisissent des informations et cliquent sur "Envoyer".

Remarque : Pour les déclencheurs Supprimé de l'espace, les applications Chat ne peuvent pas répondre par un message, car elles ne sont plus dans l'espace.

Les applications Chat peuvent inclure l'un des éléments suivants dans un message :

• Texte contenant des liens hypertextes, des @mentions et des emoji. Consultez Mettre en forme des messages.
• Une ou plusieurs fiches, qui peuvent apparaître dans un message ou s'ouvrir dans une nouvelle fenêtre sous forme de boîte de dialogue. Consultez Créer des fiches pour les applications Google Chat.
• Un ou plusieurs widgets d'accessoires, qui sont des boutons qui s'affichent après le texte ou les fiches d'un message.

Pour répondre avec un message, renvoyez DataActions avec un objet CreateMessageAction :

{
  "hostAppDataAction": {
    "chatDataAction": {
      "createMessageAction": {
        "message": <var>MESSAGE</var>
      }
    }
  }
}

Remplacez MESSAGE par une ressource Message de l'API Chat.

Dans l'exemple suivant, une application Chat crée et envoie un message d'intégration chaque fois qu'elle est ajoutée à un espace en répondant au déclencheur Ajouté à l'espace avec DataActions :

Node.js

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} req The request object from Google Chat.
 * @param {Object} res The response object from the Chat app.
 */
exports.cymbalApp = function cymbalApp(req, res) {
  const chatEvent = req.body.chat;
  // Send an onboarding message when added to a Chat space
  if (chatEvent.addedToSpacePayload) {
    res.json({ hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
      text: 'Hi, Cymbal at your service. I help you manage your calendar ' +
        'from Google Chat. Take a look at your schedule today by typing ' +
        '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. ' +
        'To learn what else I can do, type `/help`.'
    }}}}});
  }
};

Python

from flask import Flask, request, json
app = Flask(__name__)

@app.route('/', methods=['POST'])
def cymbal_app():
  """Sends an onboarding message when the Chat app is added to a space.

  Returns:
    Mapping[str, Any]: The response object from the Chat app.
  """
  chat_event = request.get_json()["chat"]
  if "addedToSpacePayload" in chat_event:
    return json.jsonify({ "hostAppDataAction": { "chatDataAction": {
      "createMessageAction": { "message": {
        "text": 'Hi, Cymbal at your service. I help you manage your calendar ' +
        'from Google Chat. Take a look at your schedule today by typing ' +
        '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. ' +
        'To learn what else I can do, type `/help`.'
      }}
    }}})

Java

@SpringBootApplication
@RestController
public class App {
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }

  /*
   * Sends an onboarding message when the Chat app is added to a space.
   *
   * @return The response object from the Chat app.
   */
  @PostMapping("/")
  @ResponseBody
  public GenericJson onEvent(@RequestBody JsonNode event) throws Exception {
    JsonNode chatEvent = event.at("/chat");
    if (!chatEvent.at("/addedToSpacePayload").isEmpty()) {
      return new GenericJson() { {
        put("hostAppDataAction", new GenericJson() { {
          put("chatDataAction", new GenericJson() { {
            put("createMessageAction", new GenericJson() { {
              put("message", new Message().setText(
                "Hi, Cymbal at your service. I help you manage your calendar " +
                "from Google Chat. Take a look at your schedule today by typing " +
                "`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. " +
                "To learn what else I can do, type `/help`."
              ));
            } });
          } });
        } });
      } };
    }
    return new GenericJson();
  }
}

Apps Script

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} event The event object from Google Chat.
 * @return {Object} Response from the Chat app.
 */
function onAddedToSpace(event) {
  return { hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
    text: 'Hi, Cymbal at your service. I help you manage your calendar ' +
          'from Google Chat. Take a look at your schedule today by typing ' +
          '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. ' +
          'To learn what else I can do, type `/help`.'
  }}}}};
}

L'exemple de code renvoie le message suivant :

Mettre à jour un message

Les applications Chat peuvent également modifier les messages qu'elles envoient. Par exemple, une application Chat peut mettre à jour un message après qu'un utilisateur a envoyé une boîte de dialogue ou cliqué sur un bouton d'une fiche dans un message.

Pour mettre à jour un message d'application Chat en réponse à une interaction, renvoyez DataActions avec un UpdateMessageAction :

{
  "hostAppDataAction": {
    "chatDataAction": {
      "updateMessageAction": {
        "message": <var>MESSAGE</var>
      }
    }
  }
}

Remplacez MESSAGE par une ressource Message de l'API Chat.

Les applications Chat peuvent également modifier un message envoyé par un utilisateur pour joindre une fiche d'aperçu de lien à l'aide de updateInlinePreviewAction. Pour en savoir plus, consultez Prévisualiser les liens.

Répondre de manière asynchrone à l'aide de l'API Google Chat

Au lieu de renvoyer une action de manière synchrone, les applications Chat peuvent avoir besoin d'appeler l'API Google Chat pour répondre à une interaction ou envoyer des messages proactifs. Par exemple, les applications Chat doivent appeler l'API Google Chat pour effectuer l'une des opérations suivantes :

• Répondre à une interaction après 30 secondes (par exemple, après avoir terminé une tâche de longue durée).
• Envoyez des messages selon un calendrier ou envoyez des notifications sur les modifications apportées aux ressources externes.
• effectuer des tâches en dehors de l'espace où l'interaction a eu lieu.
• Effectuer des tâches dans Chat qui ne sont pas disponibles en tant qu'actions synchrones, comme lister des espaces ou ajouter des membres à un espace.
• Effectuer des tâches au nom d'un utilisateur Chat (ce qui nécessite l'authentification de l'utilisateur).

Lorsque vous répondez à une interaction après 30 secondes, pour éviter qu'un message d'erreur visible par l'utilisateur indiquant que votre application Chat ne répond pas, vous devez accuser réception de l'objet d'événement dans les 30 secondes en renvoyant une réponse vide :

Node.js

async function onEvent(req, res) {
  // Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return res.send({});
};

Python

def on_event(event) -> dict:
  # Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return {}

Java

public String onEvent(JsonNode event) {
  // Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return "{}";
}

Apps Script

function onEvent(event) {
  // Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return null;
}

Pour envoyer un message à l'aide de l'API Chat, configurez l'authentification et appelez la méthode spaces.messages.create. Pour connaître la procédure à suivre, consultez Envoyer un message. Pour obtenir des guides sur l'utilisation d'autres méthodes de l'API Chat, consultez la présentation de l'API Chat.

Articles associés

• Configurer l'API Google Chat
• Envoyer un message
• Répondre aux commandes
• Ouvrir des boîtes de dialogue interactives
• Lire les données de formulaire saisies par les utilisateurs sur les fiches
• Liens d'aperçu
• Créer une page d'accueil pour une application Chat
• Valider les requêtes de Chat
• Tester les fonctionnalités interactives des applications Google Chat

Applications Chat qui ne sont pas des modules complémentaires : recevoir des interactions utilisateur et y répondre

Les applications Chat qui ne sont pas des modules complémentaires Google Workspace reçoivent des événements d'interaction de l'API Chat (Event) au lieu d'objets d'événement de module complémentaire Google Workspace (EventObject), et répondent en renvoyant une ressource Message au lieu d'une action.

Pour mettre à niveau une application Chat qui n'est pas un module complémentaire vers le framework des modules complémentaires Google Workspace, consultez Convertir une application Google Chat en module complémentaire Google Workspace.

Types d'événements d'interaction

Pour chaque type d'interaction utilisateur, Google Chat envoie à une application Chat qui n'est pas un module complémentaire un objet Event dont le type est représenté par le champ eventType :

Interaction de l'utilisateur	eventType	Réponse typique d'une application Chat qui n'est pas un module complémentaire
Un utilisateur envoie un message à une application Chat. Par exemple, il @mentionne l'application Chat ou utilise une commande à barre oblique.	MESSAGE	L'application Chat répond en fonction du contenu du message. Par exemple, une application Chat répond à la commande à barre oblique /about par un message expliquant les tâches qu'elle peut effectuer.
Un utilisateur ajoute une application Chat à un espace.	ADDED_TO_SPACE	L'application Chat envoie un message d'intégration qui explique ce qu'elle fait et comment les utilisateurs de l'espace peuvent interagir avec elle.
Un utilisateur supprime une application Chat d'un espace.	REMOVED_FROM_SPACE	L'application Chat supprime toutes les notifications entrantes configurées pour l'espace (par exemple, en supprimant un webhook) et libère de l'espace de stockage interne.
Un utilisateur clique sur un bouton d'une fiche à partir d'un message, d'une boîte de dialogue ou de la page d'accueil d'une application Chat.	CARD_CLICKED	L'application Chat traite et stocke les données envoyées par l'utilisateur, ou renvoie une autre fiche.
Un utilisateur ouvre la page d'accueil de l'application Chat en cliquant sur l'onglet Accueil dans un message privé.	APP_HOME	L'application Chat renvoie une fiche statique ou interactive depuis la page d'accueil.
Un utilisateur envoie un formulaire depuis la page d'accueil de l'application Chat.	SUBMIT_FORM	L'application Chat traite et stocke les données envoyées par l'utilisateur, ou renvoie une autre fiche.
Un utilisateur appelle une commande à l'aide d'une commande rapide.	APP_COMMAND	L'application Chat répond en fonction de la commande appelée. Par exemple, une application Chat répond à la commande About par un message expliquant les tâches qu'elle peut effectuer.

Pour afficher tous les événements d'interaction compatibles et des exemples de charges utiles JSON, consultez Types d'événements d'interaction des applications Chat et la documentation de référence sur EventType.

Événements d'interaction à partir de boîtes de dialogue

Si votre application Chat n'est pas un module complémentaire et qu'elle ouvre des boîtes de dialogue, l'événement d'interaction contient les informations supplémentaires suivantes que vous pouvez utiliser pour traiter une réponse :

• Le champ isDialogEvent est défini sur true.
• DialogEventType (REQUEST_DIALOG, SUBMIT_DIALOG ou CANCEL_DIALOG) indique si l'interaction déclenche l'ouverture d'une boîte de dialogue, envoie des informations à partir d'une boîte de dialogue ou ferme une boîte de dialogue.

Configurer une application Chat qui n'est pas un module complémentaire pour recevoir des événements d'interaction

1. Dans la console Google Cloud, accédez à la page Configuration de l'API Chat :

   Accéder à la page de configuration de l'API Chat

2. Sous Fonctionnalités interactives, décochez Créer cette application Chat en tant que module complémentaire Google Workspace, puis configurez Fonctionnalité, un seul point de terminaison Paramètres de connexion (URL du point de terminaison HTTP, Apps Script, nom du sujet Cloud Pub/Sub ou Dialogflow), Commandes, Prompts de démarrage, Aperçus des liens et Visibilité.

3. Cliquez sur Enregistrer.

Répondre avec un message dans une application Chat qui n'est pas un module complémentaire

Pour répondre de manière synchrone dans une application Chat qui n'est pas un module complémentaire, renvoyez directement un objet Message. L'exemple suivant répond à un événement d'interaction ADDED_TO_SPACE avec un message texte :

Node.js

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} req The event object from Chat API.
 * @param {Object} res The response object from the Chat app.
 */
exports.cymbalApp = function cymbalApp(req, res) {
  // Send an onboarding message when added to a Chat space
  if (req.body.type === 'ADDED_TO_SPACE') {
    res.json({
      'text': 'Hi, Cymbal at your service. I help you manage your calendar ' +
        'from Google Chat. Take a look at your schedule today by typing ' +
        '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. To ' +
        'learn what else I can do, type `/help`.'
    });
  }
};

Python

from flask import Flask, request, json
app = Flask(__name__)

@app.route('/', methods=['POST'])
def cymbal_app():
  """Sends an onboarding message when the Chat app is added to a space.

  Returns:
    Mapping[str, Any]: The response object from the Chat app.
  """
  event = request.get_json()
  if event['type'] == 'ADDED_TO_SPACE':
    return json.jsonify({
      'text': 'Hi, Cymbal at your service. I help you manage your calendar ' +
      'from Google Chat. Take a look at your schedule today by typing ' +
      '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. To ' +
      'learn what else I can do, type `/help`.'
    })
  return json.jsonify({})

Java

@SpringBootApplication
@RestController
public class App {
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }

  /*
   * Sends an onboarding message when the Chat app is added to a space.
   *
   * @return The response object from the Chat app.
   */
  @PostMapping("/")
  @ResponseBody
  public Message onEvent(@RequestBody JsonNode event) {
    switch (event.get("type").asText()) {
      case "ADDED_TO_SPACE":
        return new Message().setText(
          "Hi, Cymbal at your service. I help you manage your calendar " +
          "from Google Chat. Take a look at your schedule today by typing " +
          "`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. " +
          "To learn what else I can do, type `/help`.");
      default:
        return new Message();
    }
  }
}

Apps Script

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} event The event object from Chat API.
 * @return {Object} Response from the Chat app.
 */
function onAddToSpace(event) {
  return {
    'text': 'Hi, Cymbal at your service. I help you manage your calendar ' +
      'from Google Chat. Take a look at your schedule today by typing ' +
      '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. To learn ' +
      'what else I can do, type `/help`.'
  };
}