Eine Nachricht posten

In diesem Leitfaden werden die verschiedenen Möglichkeiten erläutert, mit denen Google Chat-Apps Nachrichten senden können:

  • Text- und Kartennachrichten in Echtzeit senden, indem Sie auf eine Nutzerinteraktion antworten.
  • Senden Sie Text- und Kartennachrichten asynchron, indem Sie die Methode create für die Ressource Message aufrufen.
  • Sie können eine Unterhaltung starten oder darauf antworten.
  • Nachrichten senden und benennen

Die Ressource Message stellt eine Text- oder Kartennachricht in Google Chat dar. Sie können eine Nachricht in der Google Chat API mit create, get, update oder delete versehen, indem Sie die entsprechenden Methoden aufrufen. Weitere Informationen zu SMS und Kartennachrichten finden Sie unter Nachrichten in Google Chat.

Die maximale Nachrichtengröße (inklusive Text oder Karten) beträgt 32.000 Byte. Wenn eine Nachricht diese Größe überschreitet, kann Ihre Chat-App stattdessen mehrere Nachrichten senden.

Anstatt die Methode create für die Ressource Message der Google Chat API aufzurufen, um eine Text- oder Kartennachricht asynchron zu senden, können Google Chat-Apps auch Nachrichten erstellen, um auf Nutzerinteraktionen in Echtzeit zu reagieren. Für Antworten auf Nutzerinteraktionen ist keine Authentifizierung erforderlich. Außerdem werden andere Arten von Nachrichten unterstützt, einschließlich interaktiver Dialogfelder und Linkvorschauen. Weitere Informationen finden Sie unter Interaktionen mit der Google Chat App empfangen und beantworten.

Voraussetzungen

Node.js

Python

  • Ein Google Workspace-Konto mit Zugriff auf Google Chat.
  • Python 3.6 oder höher
  • Das Paketverwaltungstool pip

  • Die neuesten Google-Clientbibliotheken für Python. Führen Sie den folgenden Befehl in der Befehlszeile aus, um sie zu installieren oder zu aktualisieren:

    pip3 install --upgrade google-api-python-client google-auth
  • Ein Google Cloud-Projekt mit aktivierter und konfigurierter Google Chat API. Eine Anleitung dazu finden Sie unter Google Chat-App erstellen.

  • Autorisierung, die für die Chat-App zum Senden asynchroner Nachrichten konfiguriert ist. Zum Senden von Nachrichten in Echtzeit ist keine Autorisierungskonfiguration erforderlich.

Apps Script

  • Ein Google Workspace-Konto mit Zugriff auf Google Chat.
  • Eine veröffentlichte Chat-App. Informationen zum Erstellen einer Chat-App finden Sie in dieser quickstart.
  • Autorisierung, die für die Chat-App zum Senden asynchroner Nachrichten konfiguriert ist. Zum Senden von Nachrichten in Echtzeit ist keine Autorisierungskonfiguration erforderlich.

SMS senden

In diesem Abschnitt wird beschrieben, wie Sie auf die beiden folgenden Arten Textnachrichten senden:

  • Senden Sie eine Textnachricht in Echtzeit, indem Sie auf eine Nutzerinteraktion antworten.
  • Senden Sie eine Textnachricht, indem Sie die Google Chat API asynchron aufrufen.

SMS in Echtzeit senden

In diesem Beispiel erstellt und sendet Ihre Chat-App jedes Mal eine Textnachricht, wenn sie einem Gruppenbereich hinzugefügt wird. Weitere Informationen zu Best Practices für das Onboarding von Nutzern finden Sie unter Hilfreiches Onboarding für Personen und Gruppenbereiche.

Ihre Chat-App reagiert auf ein ADDED_TO_SPACE-Interaktionsereignis, um eine SMS zu senden, wenn ein Nutzer Ihre Chat-App einem Gruppenbereich hinzufügt. Verwenden Sie den folgenden Code, um auf ADDED_TO_SPACE-Interaktionsereignisse mit einer Textnachricht zu antworten:

Node.js

/**
 * 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. An onboarding message that
 * introduces the app and helps people get started with it.
 */
exports.onMessage = function onMessage(req, res) {
  if (req.method === 'GET' || !req.body.message) {
    res.send(
      'Hello! This function is meant to be used in a Google Chat space.');
  }

  // 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`.'
    });
  }
};

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. An onboarding message that
 * introduces the app and helps people get started with it.
 */
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`.'
  }
}

Im Codebeispiel wird die folgende Textnachricht zurückgegeben:

Beispiel für eine Onboarding-Nachricht.

SMS asynchron senden

Im folgenden Abschnitt wird erläutert, wie Sie eine Textnachricht asynchron mit Anwendungs- und Nutzerauthentifizierung senden.

Um eine Textnachricht zu senden, übergeben Sie in Ihrer Anfrage Folgendes:

  • Geben Sie für die App-Authentifizierung den Autorisierungsbereich chat.bot an. Geben Sie für die Nutzerauthentifizierung den Autorisierungsbereich chat.messages.create an.
  • Rufen Sie die Methode create für die Ressource Message auf.

SMS mit App-Authentifizierung senden

So senden Sie eine Textnachricht mit der App-Authentifizierung:

Python

  1. Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen chat_create_text_message_app.py.

  2. Fügen Sie den folgenden Code in chat_create_text_message_app.py ein:

    from apiclient.discovery import build
from google.oauth2 import service_account

# Specify required scopes.
SCOPES = ['https://www.googleapis.com/auth/chat.bot']

# Specify service account details.
CREDENTIALS = service_account.Credentials.from_service_account_file(
    'credentials.json', scopes=SCOPES)

# Build the URI and authenticate with the service account.
chat = build('chat', 'v1', credentials=CREDENTIALS)

# Create a Chat message.
result = chat.spaces().messages().create(

    # The space to create the message in.
    #
    # Replace SPACE with a space name.
    # Obtain the space name from the spaces resource of Chat API,
    # or from a space's URL.
    parent='spaces/SPACE',

    # The message to create.
    body={'text': 'Hello, world!'}

).execute()

print(result)

  3. Ersetzen Sie im Code SPACE durch einen Namen für den Gruppenbereich, den Sie über die Methode spaces.list() in der Chat API oder über die URL eines Gruppenbereichs abrufen können.

  4. Erstellen Sie das Beispiel in Ihrem Arbeitsverzeichnis und führen Sie es aus:

    python3 chat_create_text_message_app.py

Die Chat API gibt eine Instanz von Message zurück, in der die gesendete Nachricht detailliert aufgeführt ist.

SMS mit Nutzerauthentifizierung senden

So senden Sie eine Textnachricht mit der Nutzerauthentifizierung:

Python

  1. Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen chat_create_text_message_user.py.

  2. Fügen Sie den folgenden Code in chat_create_text_message_user.py ein:

    import os.path

from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# Define your app's authorization scopes.
# When modifying these scopes, delete the file token.json, if it exists.
SCOPES = ["https://www.googleapis.com/auth/chat.messages.create"]

def main():
    '''
    Authenticates with Chat API via user credentials,
    then creates a text message in a Chat space.
    '''

    # Start with no credentials.
    creds = None

    # Authenticate with Google Workspace
    # and get user authorization.
    flow = InstalledAppFlow.from_client_secrets_file(
                    'client_secrets.json', SCOPES)
    creds = flow.run_local_server()

    # Build a service endpoint for Chat API.
    chat = build('chat', 'v1', credentials=creds)

    # Use the service endpoint to call Chat API.
    result = chat.spaces().messages().create(

        # The space to create the message in.
        #
        # Replace SPACE with a space name.
        # Obtain the space name from the spaces resource of Chat API,
        # or from a space's URL.
        parent='spaces/SPACE',

        # The message to create.
        body={'text': 'Hello, world!'}

    ).execute()

    # Prints details about the created message.
    print(result)

if __name__ == '__main__':
    main()

  3. Ersetzen Sie im Code SPACE durch einen Namen für den Gruppenbereich, den Sie über die Methode spaces.list() in der Chat API oder über die URL eines Gruppenbereichs abrufen können.

  4. Erstellen Sie das Beispiel in Ihrem Arbeitsverzeichnis und führen Sie es aus:

    python3 chat_create_text_message_user.py

Die Chat API gibt eine Instanz von Message zurück, in der die gesendete Nachricht detailliert aufgeführt ist.

Kartennachrichten senden

In diesem Abschnitt wird beschrieben, wie Sie Kartennachrichten auf die beiden folgenden Arten senden:

  • Du kannst in Echtzeit eine Kartennachricht senden, indem du auf eine Nutzerinteraktion antwortest.
  • Senden Sie eine Kartennachricht, indem Sie die Google Chat API asynchron aufrufen.

Kartennachrichten in Echtzeit senden

Chat-Apps können Kartennachrichten erstellen, um auf eine Nutzerinteraktion zu reagieren, z. B. wenn ein Nutzer der Chat-App eine Nachricht sendet oder die Chat-App einem Gruppenbereich hinzufügt. Weitere Informationen zum Reagieren auf Nutzerinteraktionen finden Sie unter Chat-App-Interaktionsereignisse empfangen und beantworten.

In diesem Beispiel sendet ein Nutzer eine Nachricht an eine Chat-App und die Chat-App antwortet mit einer Kartennachricht, die den Namen und das Avatarbild des Nutzers enthält:

Eine Chat-App antwortet mit einer Karte mit dem Anzeigenamen und dem Avatar des Absenders.

Node.js

node/avatar-app/index.js
/**
 * Google Cloud Function that responds to messages sent from a
 * Google Chat room.
 *
 * @param {Object} req Request sent from Google Chat room
 * @param {Object} res Response to send back
 */
exports.helloChat = function helloChat(req, res) {
  if (req.method === 'GET' || !req.body.message) {
    res.send('Hello! This function is meant to be used in a Google Chat ' +
      'Room.');
  }

  const sender = req.body.message.sender.displayName;
  const image = req.body.message.sender.avatarUrl;

  const data = createMessage(sender, image);

  res.send(data);
};

/**
 * Creates a card with two widgets.
 * @param {string} displayName the sender's display name
 * @param {string} imageUrl the URL for the sender's avatar
 * @return {Object} a card with the user's avatar.
 */
function createMessage(displayName, imageUrl) {
  const cardHeader = {
    title: `Hello ${displayName}!`,
  };

  const avatarWidget = {
    textParagraph: {text: 'Your avatar picture: '},
  };

  const avatarImageWidget = {
    image: {imageUrl},
  };

  const avatarSection = {
    widgets: [
      avatarWidget,
      avatarImageWidget,
    ],
  };

  return {
    text: 'Here\'s your avatar',
    cardsV2: [{
      cardId: 'avatarCard',
      card: {
        name: 'Avatar Card',
        header: cardHeader,
        sections: [avatarSection],
      }
    }],
  };
}

Python

python/avatar-app/main.py
from typing import Any, Mapping

import flask
import functions_framework


# Google Cloud Function that responds to messages sent in
# Google Chat.
#
# @param {Object} req Request sent from Google Chat.
# @param {Object} res Response to send back.
@functions_framework.http
def hello_chat(req: flask.Request) -> Mapping[str, Any]:
  if req.method == "GET":
    return "Hello! This function must be called from Google Chat."

  request_json = req.get_json(silent=True)

  display_name = request_json["message"]["sender"]["displayName"]
  avatar = request_json["message"]["sender"]["avatarUrl"]

  response = create_message(name=display_name, image_url=avatar)

  return response


# Creates a card with two widgets.
# @param {string} name the sender's display name.
# @param {string} image_url the URL for the sender's avatar.
# @return {Object} a card with the user's avatar.
def create_message(name: str, image_url: str) -> Mapping[str, Any]:
  avatar_image_widget = {"image": {"imageUrl": image_url}}
  avatar_text_widget = {"textParagraph": {"text": "Your avatar picture:"}}
  avatar_section = {"widgets": [avatar_text_widget, avatar_image_widget]}

  header = {"title": f"Hello {name}!"}

  cards = {
      "text": "Here's your avatar",
      "cardsV2": [
          {
              "cardId": "avatarCard",
              "card": {
                  "name": "Avatar Card",
                  "header": header,
                  "sections": [avatar_section],
              },
          }
      ]
  }

  return cards

Apps Script

In diesem Beispiel wird eine Kartennachricht gesendet, indem Karten-JSON zurückgegeben wird. Sie können auch den Apps Script-Kartendienst verwenden.

apps-script/avatar-app/hello-chat.gs
/**
 * Responds to a MESSAGE event in Google Chat.
 *
 * @param {Object} event the event object from Google Chat
 */
function onMessage(event) {
  const displayName = event.message.sender.displayName;
  const avatarUrl = event.message.sender.avatarUrl;

  return createMessage(displayName, avatarUrl);
}

/**
 * Creates a card with two widgets.
 * @param {string} displayName the sender's display name
 * @param {string} avatarUrl the URL for the sender's avatar
 * @return {Object} a card with the sender's avatar.
 */
function createMessage(displayName, avatarUrl) {
  const cardHeader = {
    title: `Hello ${displayName}!`
  };

  const avatarWidget = {
    textParagraph: {text: 'Your avatar picture: '}
  };

  const avatarImageWidget = {
    image: {imageUrl: avatarUrl}
  };

  const avatarSection = {
    widgets: [
      avatarWidget,
      avatarImageWidget
    ],
  };

  return {
    text: 'Here\'s your avatar',
    cardsV2: [{
      cardId: 'avatarCard',
      card: {
        name: 'Avatar Card',
        header: cardHeader,
        sections: [avatarSection],
      }
    }],
  };
}

Kartennachricht asynchron senden

Um eine Kartennachricht zu senden, übergib in deiner Anfrage Folgendes:

  • Geben Sie für die App-Authentifizierung den Autorisierungsbereich chat.bot an. Sie können keine Kartennachricht mit Nutzerauthentifizierung senden.
  • Rufen Sie die Methode create für die Ressource Message auf.

Das folgende Beispiel zeigt eine Kartennachricht:

Eine Kartennachricht, die mit der Chat API gesendet wurde.

So senden Sie eine Kartennachricht mit App-Authentifizierung:

Python

  1. Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen chat_create_card_message.py.

  2. Fügen Sie den folgenden Code in chat_create_card_message.py ein:

    from apiclient.discovery import build
from google.oauth2 import service_account

# Specify required scopes.
SCOPES = ['https://www.googleapis.com/auth/chat.bot']

# Specify service account details.
CREDENTIALS = service_account.Credentials.from_service_account_file(
    'credentials.json', scopes=SCOPES)

# Build the URI and authenticate with the service account.
chat = build('chat', 'v1', credentials=CREDENTIALS)

# Create a Chat message.
result = chat.spaces().messages().create(

    # The space to create the message in.
    #
    # Replace SPACE with a space name.
    # Obtain the space name from the spaces resource of Chat API,
    # or from a space's URL.
    parent='spaces/SPACE',

    # The message to create.
    body=
    {
      'cardsV2': [{
        'cardId': 'createCardMessage',
        'card': {
          'header': {
            'title': 'A card message!',
            'subtitle': 'Created with the Chat API',
            'imageUrl': 'https://developers.google.com/chat/images/chat-product-icon.png',
            'imageType': 'CIRCLE'
          },
          'sections': [
            {
              'widgets': [
                {
                  'buttonList': {
                    'buttons': [
                      {
                        'text': 'Read the docs!',
                        'onClick': {
                          'openLink': {
                            'url': 'https://developers.google.com/chat'
                          }
                        }
                      }
                    ]
                  }
                }
              ]
            }
          ]
        }
      }]
    }

).execute()

print(result)

  3. Ersetzen Sie im Code SPACE durch einen Namen für den Gruppenbereich, den Sie über die Methode spaces.list in der Chat API oder über die URL eines Gruppenbereichs abrufen können.

  4. Erstellen Sie das Beispiel in Ihrem Arbeitsverzeichnis und führen Sie es aus:

    python3 chat_create_card_message.py

Nachrichten-Thread starten oder beantworten

Um einen Nachrichtenthread zu starten, senden Sie eine Nachricht und lassen Sie thread.name leer. Google Chat füllt es beim Erstellen des Threads aus. Optional: Geben Sie das Feld thread.threadKey an, um den Namen des Threads anzupassen.

Wenn Sie auf einen Nachrichtenthread antworten möchten, senden Sie eine Nachricht, in der das Feld threadKey oder name des Threads angegeben ist. Wenn der Thread von einer Person oder einer anderen Chat-App erstellt wurde, müssen Sie das Feld thread.name verwenden.

Wenn keine passende Unterhaltung gefunden wird, können Sie mit dem Feld messageReplyOption angeben, ob eine Nachricht einen neuen Thread starten soll oder nicht gepostet werden soll.

Wenn messageReplyOption festgelegt ist, müssen Sie auch entweder thread.name oder thread.threadKey festlegen.

So starten oder beantworten Sie einen Thread, wobei das Feld threadKey als nameOfThread definiert ist:

Python

  1. Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen chat_create_message_thread.py.

  2. Fügen Sie den folgenden Code in chat_create_message_thread.py ein:

    from apiclient.discovery import build
from google.oauth2 import service_account

# Specify required scopes.
SCOPES = ['https://www.googleapis.com/auth/chat.bot']

# Specify service account details.
CREDENTIALS = service_account.Credentials.from_service_account_file(
    'credentials.json', scopes=SCOPES)

# Build the URI and authenticate with the service account.
chat = build('chat', 'v1', credentials=CREDENTIALS)

# Create a Chat message.
result = chat.spaces().messages().create(

    # The space to create the message in.
    #
    # Replace SPACE with a space name.
    # Obtain the space name from the spaces resource of Chat API,
    # or from a space's URL.
    parent='spaces/SPACE',

    # Whether to start a thread or reply to an existing one.
    #
    # Required when threading is enabled in a space unless starting a
    # thread.  Ignored in other space types. Threading is enabled when
    # space.spaceThreadingState is THREADED_MESSAGES.
    #
    # REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD replies to an existing thread
    # if one exists, otherwise it starts a new one.
    messageReplyOption='REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD',

    # The message body.
    body={

        # The message to create.
        'text': 'Start or reply to another message in a thread!',

        # The thread to start or reply to.
        'thread': {
            'threadKey': 'nameOfThread'
        }
    }

).execute()

print(result)

  3. Ersetzen Sie im Code SPACE durch einen Namen für den Gruppenbereich, den Sie über die Methode spaces.list in der Chat API oder über die URL eines Gruppenbereichs abrufen können.

  4. Erstellen Sie das Beispiel in Ihrem Arbeitsverzeichnis und führen Sie es aus:

    python3 chat_create_message_thread.py

Die Chat API gibt eine Instanz von Message zurück, in der die gesendete Nachricht detailliert aufgeführt ist.

Nachrichten benennen

In diesem Abschnitt wird erläutert, wie Sie eine Nachricht durch Festlegen einer benutzerdefinierten ID benennen können. Sie können benutzerdefinierte IDs verwenden, um Nachrichten abzurufen, zu aktualisieren oder zu löschen. Mit benutzerdefinierten IDs können Sie eine Nachricht angeben, ohne die vom System zugewiesene ID aus dem Ressourcennamen der Nachricht (im Feld name) speichern zu müssen. Der Ressourcenname wird beim Erstellen der Nachricht im Antworttext generiert.

Wenn Sie beispielsweise eine Nachricht mit der Methode get() abrufen möchten, geben Sie mit dem Ressourcennamen an, welche Nachricht abgerufen werden soll. Der Ressourcenname hat das Format spaces/{space}/messages/{message}, wobei {message} für die vom System zugewiesene ID steht. Wenn Sie die Nachricht benannt haben, können Sie den Wert von {message} durch die benutzerdefinierte ID ersetzen.

Um eine Nachricht zu benennen, geben Sie beim Erstellen der Nachricht eine benutzerdefinierte ID im Feld messageId an. Das Feld messageId legt den Wert für das Feld clientAssignedMessageId der Ressource Message fest.

Sie können eine Nachricht nur benennen, wenn Sie sie erstellen. Für vorhandene Nachrichten können Sie keine benutzerdefinierte ID benennen oder ändern. Die benutzerdefinierte ID muss die folgenden Anforderungen erfüllen:

  • Beginnt mit client-. Beispielsweise ist client-custom-name eine gültige benutzerdefinierte ID, custom-name jedoch nicht.
  • Enthält bis zu 63 Zeichen und darf nur Kleinbuchstaben, Ziffern und Bindestriche enthalten.
  • Ist innerhalb eines Gruppenbereichs eindeutig. Eine Chat-App kann nicht dieselbe benutzerdefinierte ID für verschiedene Nachrichten verwenden.

So senden Sie eine Nachricht mit einer benutzerdefinierten ID:

Python

  1. Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen chat_create_named_message.py.

  2. Fügen Sie den folgenden Code in chat_create_named_message.py ein:

    from apiclient.discovery import build
from google.oauth2 import service_account

# Specify required scopes.
SCOPES = ['https://www.googleapis.com/auth/chat.bot']

# Specify service account details.
CREDENTIALS = service_account.Credentials.from_service_account_file(
    'credentials.json', scopes=SCOPES)

# Build the URI and authenticate with the service account.
chat = build('chat', 'v1', credentials=CREDENTIALS)

# Create a Chat message with a custom name.
result = chat.spaces().messages().create(

    # The space to create the message in.
    #
    # Replace SPACE with a space name.
    # Obtain the space name from the spaces resource of Chat API,
    # or from a space's URL.
    parent='spaces/SPACE',

    # Custom name for the message used to facilitate later operations.
    messageId='client-NAME',

    # The message to create.
    body={'text': 'Hello, world!'}

).execute()

print(result)

  3. Ersetzen Sie im Code Folgendes:

    • SPACE: Die ID des Gruppenbereichs, in dem Sie die Nachricht posten möchten. Sie finden sie in der Chat API über die Methode spaces.list oder über die URL eines Gruppenbereichs.
    • NAME: Der benutzerdefinierte Name der Nachricht.

  4. Erstellen Sie das Beispiel in Ihrem Arbeitsverzeichnis und führen Sie es aus:

    python3 chat_create_named_message.py

Die Chat API gibt eine Instanz von Message zurück.

Interaktive Widgets am Ende einer Nachricht hinzufügen

Optional können Sie Nachrichten mit Zubehör-Widgets anhängen. Zubehör-Widgets werden nach jedem Text oder jeder Karte in einer Nachricht angezeigt. Mit diesen Widgets können Sie Nutzer auf verschiedene Arten auffordern, mit Ihrer Mitteilung zu interagieren. Beispiele:

  • Bewerten Sie die Genauigkeit oder Zufriedenheit einer Nachricht.
  • Problem mit der Messages App oder der Chat App melden
  • Öffnen Sie einen Link zu ähnlichen Inhalten, z. B. zur Dokumentation.
  • Ähnliche Nachrichten aus der Chat-App schließen oder für einen bestimmten Zeitraum zurückstellen.

Wenn Sie Zubehör-Widgets hinzufügen möchten, nehmen Sie das Objekt accessoryWidgets[] in die Nachricht auf und geben Sie ein oder mehrere AccessoryWidgets an, die einbezogen werden sollen. Die Nachricht muss für alle im Gruppenbereich sichtbar sein. Sie können privaten Nachrichten keine Zubehör-Widgets hinzufügen.

Die folgende Abbildung zeigt eine Chat-App, an die eine SMS mit Zubehör-Widgets angehängt wird, damit Nutzer die Chat-App bewerten können.

Beispiele für Zubehör-Widgets

Das folgende Codebeispiel zeigt den JSON-Code für diese Nachricht. Wenn ein Nutzer auf eine der Schaltflächen klickt, löst die Interaktion die entsprechende Funktion aus (z. B. doUpvote), die die Bewertung verarbeitet.


 "text": "Rate your experience with this Chat app.",
 "accessoryWidgets": [
   {
     "buttonList": {
       "buttons": [
         {
           "icon": {
             "material_icon": {
               "name": "thumb_up"
             }
           },
           "color": {
             "red": 0,
             "blue": 255,
             "green": 0
           },
           "onClick": {
             "action": {
               "function": "doUpvote",
             }
           }
         },
         {
           "icon": {
             "material_icon": {
               "name": "thumb_down"
             }
           },
           "color": {
             "red": 0,
             "blue": 255,
             "green": 0
           },
           "onClick": {
             "action": {
               "function": "doDownvote",
             }
           }
         }
       ]
     }
   }
 ]

Nachrichten privat senden

Chat-Apps können Text- und Kartennachrichten privat senden, sodass die Nachricht nur für einen Nutzer im Gruppenbereich sichtbar ist. Wenn Sie eine Nachricht privat senden möchten, geben Sie das Feld privateMessageViewer in der Nachricht an. Nur Chat-Apps können private Nachrichten senden. Wenn Sie eine private Nachricht asynchron senden möchten, müssen Sie die Anwendungsauthentifizierung verwenden.

Weitere Informationen finden Sie unter Private Nachrichten an Google Chat-Nutzer senden.

Fehlerbehebung

Wenn eine Google Chat-App oder -Karte einen Fehler zurückgibt, wird in der Chat-Oberfläche die Meldung „Ein Fehler ist aufgetreten“ angezeigt. oder „Ihre Anfrage kann nicht verarbeitet werden.“ Manchmal wird in der Chat-UI keine Fehlermeldung angezeigt, aber die Chat-App oder -Karte liefert ein unerwartetes Ergebnis. So kann z. B. keine Kartenmeldung angezeigt werden.

Obwohl eine Fehlermeldung möglicherweise nicht in der Chat-UI angezeigt wird, sind beschreibende Fehlermeldungen und Protokolldaten verfügbar, um Sie beim Beheben von Fehlern zu unterstützen, wenn das Fehler-Logging für Chat-Apps aktiviert ist. Informationen zum Ansehen, Debuggen und Beheben von Fehlern finden Sie unter Google Chat-Fehler beheben.