Memperluas UI compose dengan tindakan compose

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Selain menyediakan antarmuka berbasis kartu saat pengguna membaca pesan Gmail, Google Workspace add-on yang memperluas Gmail dapat memberikan antarmuka lain saat pengguna menulis pesan baru atau membalas pesan yang ada. Hal ini memungkinkan Google Workspace add-on mengotomatiskan tugas penulisan email untuk pengguna.

Mengakses UI compose add-on

Ada dua cara untuk melihat UI compose add-on. Cara pertama adalah mulai menulis draf atau balasan baru saat add-on sudah terbuka. Cara kedua adalah memulai add-on saat menulis draf.

Apa pun kasusnya, add-on akan menjalankan fungsi pemicu compose yang sesuai, yang ditentukan dalam manifes add-on. Fungsi pemicu compose membuat UI compose untuk tindakan penulisan tersebut, yang kemudian ditampilkan Gmail kepada pengguna.

Membuat add-on compose

Anda dapat menambahkan fungsi tulis ke add-on dengan mengikuti langkah-langkah umum berikut:

  1. Tambahkan kolom gmail.composeTrigger ke manifes project skrip add-on dan perbarui cakupan manifes untuk menyertakan yang diperlukan untuk tindakan menulis.
  2. Terapkan fungsi pemicu compose yang mem-build UI compose saat pemicu diaktifkan. Fungsi pemicu Compose menampilkan satu objek Card atau array objek Card yang membentuk UI compose untuk tindakan compose.
  3. Terapkan fungsi callback terkait yang diperlukan untuk bereaksi terhadap interaksi UI pengguna. Fungsi ini bukanlah tindakan compose itu sendiri (yang hanya menyebabkan UI compose muncul); sebaliknya, ini adalah fungsi individual yang mengatur apa yang terjadi saat elemen UI yang berbeda dipilih. Misalnya, kartu UI yang berisi tombol biasanya memiliki fungsi callback terkait yang dieksekusi saat pengguna mengklik tombol tersebut. Fungsi callback untuk widget yang memperbarui konten pesan draf harus menampilkan objek UpdateDraftActionResponse.

Fungsi pemicu Compose

UI compose add-on dibuat dengan cara yang sama seperti UI pesan add-on—menggunakan Layanan kartu Apps Script untuk membuat kartu Apps dan mengisinya dengan widget.

Anda harus mengimplementasikan gmail.composeTrigger.selectActions[].runFunction yang Anda tentukan dalam manifes. Fungsi pemicu compose harus menampilkan satu objek Card atau array objek Card yang membentuk UI compose untuk tindakan tersebut. Fungsi ini sangat mirip dengan fungsi pemicu kontekstual dan harus membuat kartu dengan cara yang sama.

Objek peristiwa pemicu Compose

Jika dipilih, tindakan compose akan menjalankan fungsi pemicu compose yang sesuai dan meneruskan fungsi objek peristiwa sebagai parameter. Objek peristiwa dapat membawa informasi tentang konteks add-on dan draf yang disusun ke fungsi pemicu.

Lihat Struktur objek peristiwa untuk mengetahui detail tentang cara informasi disusun dalam objek peristiwa. Informasi yang dimuat dalam objek peristiwa dikontrol sebagian oleh nilai kolom manifes gmail.composeTrigger.draftAccess:

  • Jika kolom manifes gmail.composeTrigger.draftAccess adalah NONE atau tidak disertakan, objek peristiwa hanya akan memiliki informasi yang minimal.

  • Jika gmail.composeTrigger.draftAccess disetel ke METADATA, objek peristiwa yang diteruskan ke fungsi pemicu compose diisi dengan daftar penerima email yang sedang disusun.

Menyisipkan konten ke draf aktif

Biasanya Google Workspace UI Compose add-on menyediakan opsi dan kontrol pengguna yang membantu menulis pesan. Untuk kasus penggunaan ini, setelah pengguna membuat pilihan di UI, add-on akan menafsirkan pilihan dan memperbarui draf email yang sedang berjalan sebagaimana mestinya.

Untuk mempermudah pembaruan email draf saat ini, layanan Card telah diperluas dengan class berikut:

Biasanya UI compose add-on menyertakan 'Save' atau 'Insert' widget yang dapat diklik pengguna untuk menunjukkan bahwa mereka telah selesai membuat pilihan di UI dan ingin pilihan mereka ditambahkan ke email yang ditulis. Untuk menambahkan interaktivitas ini, widget harus memiliki objek Action terkait yang menginstruksikan add-on untuk menjalankan fungsi callback tertentu saat widget diklik. Anda harus mengimplementasikan fungsi callback ini. Setiap fungsi callback akan menampilkan objek UpdateDraftActionResponse bawaan yang memerinci perubahan yang akan dilakukan pada draf email saat ini.

Contoh 1

Cuplikan kode berikut menunjukkan cara mem-build UI Compose yang memperbarui subjek, dan penerima Kepada, Cc, Bcc draf email saat ini.

    /**
     * Compose trigger function that fires when the compose UI is
     * requested. Builds and returns a compose UI for inserting images.
     *
     * @param {event} e The compose trigger event object. Not used in
     *         this example.
     * @return {Card[]}
     */
    function getComposeUI(e) {
      return [buildComposeCard()];
    }

    /**
     * Build a card to display interactive buttons to allow the user to
     * update the subject, and To, Cc, Bcc recipients.
     *
     * @return {Card}
     */
    function buildComposeCard() {

      var card = CardService.newCardBuilder();
      var cardSection = CardService.newCardSection().setHeader('Update email');
      cardSection.addWidget(
          CardService.newTextButton()
              .setText('Update subject')
              .setOnClickAction(CardService.newAction()
                  .setFunctionName('applyUpdateSubjectAction')));
      cardSection.addWidget(
          CardService.newTextButton()
              .setText('Update To recipients')
              .setOnClickAction(CardService.newAction()
                  .setFunctionName('updateToRecipients')));
      cardSection.addWidget(
          CardService.newTextButton()
              .setText('Update Cc recipients')
              .setOnClickAction(CardService.newAction()
                  .setFunctionName('updateCcRecipients')));
      cardSection.addWidget(
          CardService.newTextButton()
              .setText('Update Bcc recipients')
              .setOnClickAction(CardService.newAction()
                  .setFunctionName('updateBccRecipients')));
      return card.addSection(cardSection).build();
    }

    /**
     * Updates the subject field of the current email when the user clicks
     * on "Update subject" in the compose UI.
     *
     * Note: This is not the compose action that builds a compose UI, but
     * rather an action taken when the user interacts with the compose UI.
     *
     * @return {UpdateDraftActionResponse}
     */
    function applyUpdateSubjectAction() {
      // Get the new subject field of the email.
      // This function is not shown in this example.
      var subject = getSubject();
      var response = CardService.newUpdateDraftActionResponseBuilder()
          .setUpdateDraftSubjectAction(CardService.newUpdateDraftSubjectAction()
              .addUpdateSubject(subject))
          .build();
      return response;
    }

    /**
     * Updates the To recipients of the current email when the user clicks
     * on "Update To recipients" in the compose UI.
     *
     * Note: This is not the compose action that builds a compose UI, but
     * rather an action taken when the user interacts with the compose UI.
     *
     * @return {UpdateDraftActionResponse}
     */
    function applyUpdateToRecipientsAction() {
      // Get the new To recipients of the email.
      // This function is not shown in this example.
      var toRecipients = getToRecipients();
      var response = CardService.newUpdateDraftActionResponseBuilder()
          .setUpdateDraftToRecipientsAction(CardService.newUpdateDraftToRecipientsAction()
              .addUpdateToRecipients(toRecipients))
          .build();
      return response;
    }

    /**
     * Updates the Cc recipients  of the current email when the user clicks
     * on "Update Cc recipients" in the compose UI.
     *
     * Note: This is not the compose action that builds a compose UI, but
     * rather an action taken when the user interacts with the compose UI.
     *
     * @return {UpdateDraftActionResponse}
     */
    function applyUpdateCcRecipientsAction() {
      // Get the new Cc recipients of the email.
      // This function is not shown in this example.
      var ccRecipients = getCcRecipients();
      var response = CardService.newUpdateDraftActionResponseBuilder()
          .setUpdateDraftCcRecipientsAction(CardService.newUpdateDraftCcRecipientsAction()
              .addUpdateToRecipients(ccRecipients))
          .build();
      return response;
    }

    /**
     * Updates the Bcc recipients  of the current email when the user clicks
     * on "Update Bcc recipients" in the compose UI.
     *
     * Note: This is not the compose action that builds a compose UI, but
     * rather an action taken when the user interacts with the compose UI.
     *
     * @return {UpdateDraftActionResponse}
     */
    function applyUpdateBccRecipientsAction() {
      // Get the new Bcc recipients of the email.
      // This function is not shown in this example.
      var bccRecipients = getBccRecipients();
      var response = CardService.newUpdateDraftActionResponseBuilder()
          .setUpdateDraftBccRecipientsAction(CardService.newUpdateDraftBccRecipientsAction()
              .addUpdateToRecipients(bccRecipients))
          .build();
      return response;
    }

Contoh 2

Cuplikan kode berikut ini menunjukkan cara mem-build UI Compose yang menyisipkan gambar ke dalam email draf saat ini.

    /**
     * Compose trigger function that fires when the compose UI is
     * requested. Builds and returns a compose UI for inserting images.
     *
     * @param {event} e The compose trigger event object. Not used in
     *         this example.
     * @return {Card[]}
     */
    function getInsertImageComposeUI(e) {
      return [buildImageComposeCard()];
    }

    /**
     * Build a card to display images from a third-party source.
     *
     * @return {Card}
     */
    function buildImageComposeCard() {
      // Get a short list of image URLs to display in the UI.
      // This function is not shown in this example.
      var imageUrls = getImageUrls();

      var card = CardService.newCardBuilder();
      var cardSection = CardService.newCardSection().setHeader('My Images');
      for (var i = 0; i < imageUrls.length; i++) {
        var imageUrl = imageUrls[i];
        cardSection.addWidget(
            CardService.newImage()
                .setImageUrl(imageUrl)
                .setOnClickAction(CardService.newAction()
                      .setFunctionName('applyInsertImageAction')
                      .setParameters({'url' : imageUrl})));
      }
      return card.addSection(cardSection).build();
    }

    /**
     * Adds an image to the current draft email when the image is clicked
     * in the compose UI. The image is inserted at the current cursor
     * location. If any content of the email draft is currently selected,
     * it is deleted and replaced with the image.
     *
     * Note: This is not the compose action that builds a compose UI, but
     * rather an action taken when the user interacts with the compose UI.
     *
     * @param {event} e The incoming event object.
     * @return {UpdateDraftActionResponse}
     */
    function applyInsertImageAction(e) {
      var imageUrl = e.parameters.url;
      var imageHtmlContent = '<img style=\"display: block\" src=\"'
           + imageUrl + '\"/>';
      var response = CardService.newUpdateDraftActionResponseBuilder()
          .setUpdateDraftBodyAction(CardService.newUpdateDraftBodyAction()
              .addUpdateContent(
                  imageHtmlContent,
                  CardService.ContentType.MUTABLE_HTML)
              .setUpdateType(
                  CardService.UpdateDraftBodyType.IN_PLACE_INSERT))
          .build();
      return response;
    }