Nicht nutzbare digitale Transaktionen erstellen (Dialogflow)

In diesem Leitfaden wird erläutert, wie Sie Ihrer dialogorientierten Aktion digitale Transaktionen hinzufügen, damit Nutzer Ihre nicht konsumierbaren digitalen Waren kaufen können.

Schlüsselbegriffe: Eine nicht konsumierbare digitale Ware ist eine Bestandseinheit (SKU), die nur einmal erworben werden kann, wie z. B. kostenpflichtiger Zugriff auf zusätzliche Inhalte in einer Aktion oder Android-App. Diese Art von Produkt unterscheidet sich von konsumenten digitalen Waren, die gekauft, gebraucht und noch einmal gekauft werden können.

Weitere Informationen zu nicht verwendbaren Einmalprodukten findest du in der Android-Dokumentation zu einmaligen produktspezifischen Funktionen.

Einschränkungen und Richtlinien für Überprüfungen

Für Aktionen mit Transaktionen gelten zusätzliche Richtlinien. Es kann einige Wochen dauern, bis wir Aktionen überprüft haben, die Transaktionen enthalten. Berücksichtigen Sie diese Zeit bei der Planung Ihres Release-Zeitplans. Achte darauf, dass du die Richtlinien für Transaktionen einhältst, bevor du deine Aktion zur Überprüfung einreichst, um den Überprüfungsprozess zu vereinfachen.

Aktionen zum Verkauf digitaler Waren können nur in den folgenden Ländern bereitgestellt werden:

  • Australien
  • Brasilien
  • Kanada
  • Indonesien
  • Japan
  • Mexiko
  • Russland
  • Singapur
  • Thailand
  • Türkei
  • Vereinigtes Königreich
  • USA

Transaktionsablauf

In diesem Leitfaden wird jeder Entwicklungsschritt in einem Transaktionsablauf für digitale Waren beschrieben. Wenn deine Aktion Transaktionen für digitale Waren verarbeitet, verwendet sie den folgenden Ablauf:

  1. Richte einen API-Client für digitale Käufe ein: Deine Aktion verwendet die Digital Purchases API, um mit deinem Google Play-Inventar zu kommunizieren und Transaktionen durchzuführen. Bevor deine Aktion etwas anderes ausführt, erstellt sie einen JWT-Client mit einem Dienstschlüssel, der mit der Digital Purchases API kommuniziert.
  2. Informationen erfassen: Deine Aktion sammelt grundlegende Informationen über den Nutzer und dein Google Play-Inventar, um eine Transaktion vorzubereiten.
    1. Transaktionsanforderungen validieren: Deine Aktion verwendet die Hilfe für digitale Transaktionsanforderungen zu Beginn des Kaufvorgangs, um dafür zu sorgen, dass der Nutzer Transaktionen durchführen kann.
    2. Verfügbares Inventar zusammenstellen: Deine Aktion prüft dein Google Play-Inventar und ermittelt, welche Artikel derzeit zum Kauf verfügbar sind.
  3. Auftrag erstellen: Deine Aktion präsentiert dem Nutzer die verfügbaren digitalen Waren, damit er ein Produkt zum Kauf auswählen kann.
  4. Kauf abschließen: Deine Aktion verwendet die API für digitale Käufe, um einen Kauf mit der Auswahl des Nutzers im Google Play Store zu starten.
  5. Ergebnis verarbeiten: Die Aktion empfängt einen Statuscode für die Transaktion und benachrichtigt den Nutzer, dass der Kauf erfolgreich war oder zusätzliche Schritte erforderlich sind.

Voraussetzungen

Bevor du digitale Transaktionen in deine Aktion einbinden kannst, müssen die folgenden Voraussetzungen erfüllt sein:

  • Ein Entwicklerkonto und ein Händlerkonto bei Google Play, um Ihre digitalen Waren in der Google Play Console zu verwalten.

  • Eine Webdomain, die in der Google Search Console bestätigt wurde. Diese Domain muss nicht mit einer öffentlich zugänglichen Website verknüpft sein. Wir müssen nur auf Ihre Webdomain verweisen.

  • Eine Android-App mit der Berechtigung com.android.vending.BILLING in der Google Play Console. Ihre digitalen Waren werden mit dieser App in der Google Play Console als In-App-Käufe verknüpft.

    Mit dieser App müssen Sie auch einen Release in der Play Console erstellen. Wenn der Release jedoch nicht öffentlich sein soll, können Sie einen geschlossenen Alpharelease erstellen.

    Wenn du noch keine Android-App hast, folge der Anleitung zum Verknüpfen einer Android-App.

  • Ein oder mehrere verwaltete Produkte in der Google Play Console, d. h. die digitalen Waren, die du mit deiner Aktion verkaufst. Hinweis: Sie können erst dann verwaltete Produkte in der Play Console erstellen, wenn Sie die Voraussetzungen für die Android-App eingerichtet haben.

    Wenn Sie noch keine verwalteten Produkte haben, folgen Sie der Anleitung zum Erstellen digitaler Waren.

Android-App verknüpfen

Wenn du derzeit keine Android-App mit der Berechtigung „Abrechnung“ in der Google Play Console hast, gehe so vor:

  1. Erstellen Sie in Android Studio oder in der Android-IDE Ihrer Wahl ein neues Projekt. Wählen Sie Optionen in den Eingabeaufforderungen zur Projekteinrichtung aus, um eine sehr einfache App zu erstellen.
  2. Geben Sie dem Projekt einen Paketnamen wie com.mycompany.myapp. Behalten Sie diesen Namen nicht bei, da Sie keine Pakete mit com.example in die Play Console hochladen können.
  3. Öffnen Sie die Datei AndroidManifest.xml Ihrer App.
  4. Fügen Sie die folgende Codezeile in das manifest-Element ein:

    <uses-permission android:name="com.android.vending.BILLING" />

    Die Datei AndroidManifest.xml sollte wie der folgende Codeblock aussehen:

    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        package="com.mycompany.myapp">
        <uses-permission android:name="com.android.vending.BILLING" />
    
        <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/AppTheme" />
    </manifest>
    
  5. Erstellen Sie Ihre App als signiertes APK. Gehen Sie in Android Studio so vor:

    1. Gehen Sie zu Build, Generate Signed Bundle/APK (Signiertes Bundle/APK generieren).
    2. Klicken Sie auf Weiter.
    3. Klicken Sie unter Schlüsselspeicherpfad auf Neu erstellen.
    4. Füllen Sie alle Felder aus und klicken Sie dann auf OK. Notieren Sie sich Ihr Schlüsselspeicherpasswort und Ihr Schlüsselpasswort und bewahren Sie diese an einem sicheren Ort auf, da Sie diese später benötigen.
    5. Klicken Sie auf Weiter.
    6. Wählen Sie Release aus.
    7. Wählen Sie V1 (JAR-Signatur) aus.
    8. Klicken Sie auf Fertig.
    9. Nach einigen Sekunden erstellt Android Studio eine app-release.apk-Datei. Suchen Sie diese Datei zur späteren Verwendung.
  6. Erstellen Sie in der Google Play Console eine neue App.

  7. Gehen Sie zu App-Releases.

  8. Klicken Sie unter Geschlossene Tracks auf Verwalten und dann auf Alpha.

  9. Klicken Sie auf die Schaltfläche Release erstellen.

  10. Geben Sie unter Google den Signaturschlüssel verwalten und schützen lassen die Informationen zum Signaturschlüssel ein.

  11. Laden Sie Ihre APK-Datei hoch.

  12. Klicken Sie auf Speichern.

Digitale Waren erstellen

Wenn Sie derzeit keine digitalen Waren in der Play Console haben, gehen Sie so vor:

  1. Rufen Sie in der Google Play Console In-App-Produkte und dann Verwaltete Produkte auf. Wenn eine Warnung angezeigt wird, folge der vorherigen Anleitung zum Erstellen einer Android-App oder klicke auf den Link zum Erstellen eines Händlerprofils.
  2. Klicken Sie auf Verwaltetes Produkt erstellen.
  3. Füllen Sie die Felder für Ihr digitales Produkt aus. Notiere dir die Produkt-ID, mit der du dieses Produkt aus deiner Aktion referenzieren kannst.
  4. Klicken Sie auf Speichern.
  5. Wiederholen Sie die Schritte 2 bis 4 für jedes Produkt, das Sie verkaufen möchten.

Beispiel für nicht konsumierbare Artikel in der Google Play Console

Actions-Projekt vorbereiten

Wenn Sie Ihre digitalen Waren in der Google Play Console eingerichtet haben, müssen Sie digitale Transaktionen aktivieren und Ihr Actions-Projekt mit Ihrer Play-App verknüpfen.

So aktivieren Sie Transaktionen für digitale Waren in Ihrem Actions-Projekt:

  1. Öffnen Sie Ihr Projekt in der Actions Console oder erstellen Sie ein neues.
  2. Klicken Sie auf Bereitstellen und dann auf Verzeichnisinformationen.
  3. Setzen Sie unter Zusätzliche Informationen und Transaktionen ein Häkchen bei Ja unter Verwenden Ihre Aktionen die Digital Purchase API, um Transaktionen digitaler Waren durchzuführen?.
  4. Klicken Sie auf Speichern.

API-Schlüssel für digitale Waren erstellen

Wenn du Anfragen an die Digital Goods API senden möchtest, musst du einen JSON-Dienstkontoschlüssel herunterladen, der mit deinem Actions Console-Projekt verknüpft ist.

So rufen Sie Ihren Dienstkontoschlüssel ab:

  1. Klicken Sie in der Actions Console oben rechts auf das Dreipunkt-Menü und dann auf Projekteinstellungen.
  2. Suche nach der Projekt-ID deiner Aktion.
  3. Folgen Sie diesem Link und ersetzen Sie dabei „<project_id>“ durch Ihre Projekt-ID: https://console.developers.google.com/apis/credentials?project=project_id
  4. Gehen Sie in der Hauptnavigation zu Anmeldedaten.
  5. Klicken Sie auf der angezeigten Seite auf Anmeldedaten erstellen und dann auf Dienstkontoschlüssel.
  6. Gehen Sie zu Dienstkonto und klicken Sie auf Neues Dienstkonto.
  7. Geben Sie dem Dienstkonto einen Namen wie „digitaltransactions“.
  8. Klicken Sie auf Erstellen.
  9. Legen Sie die Rolle auf Projekt > Inhaber fest.
  10. Klicken Sie auf Weiter.
  11. Klicken Sie auf Schlüssel erstellen.
  12. Wählen Sie den Schlüsseltyp JSON aus.
  13. Klicken Sie auf Schlüssel erstellen und laden Sie den JSON-Dienstkontoschlüssel herunter.

Bewahren Sie diesen Dienstkontoschlüssel an einem sicheren Ort auf. Du verwendest diesen Schlüssel bei der Auftragsausführung, um einen Client für die Digital Purchases API zu erstellen.

Mit Ihrem Google Play-Inventar verbinden

Damit Sie über ein Actions-Projekt auf Ihre digitalen Waren zugreifen können, verknüpfen Sie Ihre Webdomain und App mit Ihrem Projekt als verbundene Properties.

Hinweis:Die Verbindungsschritte können bis zu einer Woche dauern, während wir Ihre Properties überprüfen. Wenn Ihre Website oder App danach immer noch nicht verknüpft ist, wenden Sie sich an den Support.

So verbinden Sie Ihre Webdomain und App der Play Console mit Ihrem Actions-Projekt:

  1. Klicken Sie in der Actions Console auf Bereitstellen und dann auf Markenüberprüfung.
  2. Wenn Sie noch keine Properties verknüpft haben, verknüpfen Sie zuerst eine Website:

    1. Klicken Sie auf die Schaltfläche für die Web-Property (</>).
    2. Geben Sie die URL Ihrer Webdomain ein und klicken Sie auf Verbinden.

    Google sendet eine E-Mail mit weiteren Anleitungen an die Person, die in der Google Search Console für diese Webdomain bestätigt wurde. Nachdem der Empfänger dieser E-Mail diese Schritte ausgeführt hat, sollte die Website unter Markenüberprüfung erscheinen.

  3. Sobald Sie mindestens eine Website verknüpft haben, führen Sie die folgenden Schritte aus, um Ihre Android-App zu verbinden:

    1. Klicken Sie in der Actions Console auf Bereitstellen und dann auf Markenüberprüfung.
    2. Klicken Sie auf App verknüpfen.
    3. Folgen Sie auf der angezeigten Seite der Anleitung zur Bestätigung Ihrer Webdomain in der Play Console. Wählen Sie die Play App aus, die Ihre digitalen Waren enthält, und geben Sie die Webdomain-URL genau so ein, wie sie auf der Seite Markenüberprüfung angezeigt wird.

      Google sendet wieder eine Bestätigungs-E-Mail an den bestätigten Inhaber der Domain. Sobald die Überprüfung genehmigt wurde, sollte deine Play-App unter Markenüberprüfung angezeigt werden.

    4. Aktivieren Sie Auf Play-Käufe zugreifen.

Abbildung der Website und der Apps, die mit dem Actions-Projekt verknüpft sind.

Kaufvorgang aufbauen

Nachdem Sie Ihr Actions-Projekt und Ihr Inventar für digitale Waren vorbereitet haben, erstellen Sie in Ihrem Webhook für die Auftragsausführung einen Kaufvorgang für digitale Waren.

1. API-Client für digitale Käufe einrichten

Erstellen Sie im Webhook der Unterhaltungsausführung einen JWT-Client mit dem JSON-Schlüssel Ihres Dienstkontos und dem Bereich https://www.googleapis.com/auth/actions.purchases.digital.

Mit dem folgenden Node.js-Code wird ein JWT-Client für die Digital Purchases API erstellt:

  const serviceAccount = {'my-file.json'};
  const request = require('request');
  const {google} = require('googleapis');

  const jwtClient = new google.auth.JWT(
    serviceAccount.client_email, null, serviceAccount.private_key,
    ['https://www.googleapis.com/auth/actions.purchases.digital'],
    null
  );

2. Informationen einholen

Bevor der Nutzer etwas kaufen kann, erfasst deine Aktion Informationen über die Kauffähigkeit des Nutzers und über die Waren, die in deinem Inventar verfügbar sind.

2. a) Transaktionsanforderungen validieren

Es empfiehlt sich, das Nutzerkonto für Transaktionen zu konfigurieren, bevor die Option zum Kauf angeboten wird. Bei diesem Schritt wird geprüft, ob der Nutzer eine Zahlungsmethode konfiguriert hat und sich in einer Sprache befindet, in der digitale Transaktionen unterstützt werden. Verwenden Sie zu Beginn des Transaktionsablaufs den Helper DIGITAL_PURCHASE_CHECK, um die Transaktionskonfiguration des Nutzers mit Assistant zu validieren.

Der folgende Node.js-Code verwendet DIGITAL_PURCHASE_CHECK zu Beginn der Unterhaltung:

app.intent('Default Welcome Intent', async (conv, { SKU }) => {
  // Immediately invoke digital purchase check intent to confirm
  // purchase eligibility.
  conv.ask(new DigitalPurchaseCheck());
});

Suchen Sie das Ergebnis dieser Prüfung in den Unterhaltungsargumenten als DIGITAL_PURCHASE_CHECK_RESULT. Basierend auf diesem Ergebnis kannst du entweder den Transaktionsablauf fortsetzen oder die Seite verlassen und den Kunden auffordern, seine Google Pay-Konfiguration zu prüfen.

Der folgende Node.js-Code verarbeitet das Ergebnis der Anforderungsprüfung :

app.intent('Digital Purchase Check', async (conv) => {
  const arg = conv.arguments.get('DIGITAL_PURCHASE_CHECK_RESULT');
  if (!arg || !arg.resultType) {
    conv.close('Digital Purchase check failed. Please check logs.');
    return;
  }
  // User does not meet necessary conditions for completing a digital purchase
  if (arg.resultType === 'CANNOT_PURCHASE' || arg.resultType === 'RESULT_TYPE_UNSPECIFIED') {
    conv.close(`It looks like you aren't able to make digital purchases. Please check your Google Pay configuration and try again.`);
    return;
  }
  conv.ask('Welcome to the Digital Goods Sample. Would you like to see what I have for sale?');
});

2. b) Verfügbares Inventar zusammenstellen

Fordern Sie mit der Digital Purchases API Ihr derzeit verfügbares Play Store-Inventar an und integrieren Sie es dann in ein Array von JSON-Objekten für jedes Produkt. Sie verweisen später auf dieses Array, um dem Nutzer zu zeigen, welche Optionen zum Kauf verfügbar sind.

Jede Ihrer digitalen Waren wird als SKU im JSON-Format dargestellt. Im folgenden Node.js-Code wird die erwartete Formatierung jeder Artikelnummer beschrieben:

body = {
  skus: [
    skuId: {
      skuType: one of "APP" or "UNSPECIFIED"
      id: string,
      packageName: string
    }
    formattedPrice: string,
    title: string,
    description: string
  ]
}

Sende eine POST-Anfrage an den Endpunkt https://actions.googleapis.com/v3/packages/{packageName}/skus:batchGet, wobei {packageName} der Paketname deiner App in der Google Play Console ist (z. B. com.myapp.digitalgoods). Formatiere das Ergebnis als Array von SKU-Objekten.

Wenn du nur bestimmte digitale Waren im resultierenden Array abrufen möchtest, gib die Produkt-IDs für digitale Waren an, die du in body.ids zum Kauf anbieten möchtest (wie unter jedem In-App-Produkt in der Google Play Console angezeigt).

Mit dem folgenden Node.js-Code wird eine Liste der verfügbaren Waren von der Digital Purchases API angefordert und das Ergebnis als Array von SKUs formatiert:

return jwtClient.authorize((err, tokens) => {
    if (err) {
      throw new Error(`Auth error: ${err}`);
    }

    const packageName = 'com.example.projectname';

    request.post(`https://actions.googleapis.com/v3/packages/${packageName}/skus:batchGet`, {
      'auth': {
        'bearer': tokens.access_token,
      },
      'json': true,
      'body': {
        'conversationId': conversationId,
        'skuType': 'APP',
        // This request is filtered to only retrieve SKUs for the following product IDs
        'ids': ['nonconsumable.1']
      },
    }, (err, httpResponse, body) => {
      if (err) {
        throw new Error(`API request error: ${err}`);
      }
      console.log(`${httpResponse.statusCode}: ${httpResponse.statusMessage}`);
      console.log(JSON.stringify(body));
    });
  });
});

3. Auftrag erstellen

Um den digitalen Kauf des Nutzers zu starten, präsentieren Sie eine Liste Ihrer digitalen Waren, die zum Kauf verfügbar sind. Sie können Ihren Bestand mit verschiedenen Rich-Media-Antworten darstellen und den Nutzer auffordern, eine Auswahl zu treffen.

Mit dem folgenden Node.js-Code wird ein Inventararray von SKU-Objekten gelesen und eine Listenantwort mit jeweils einem Listenelement erstellt:

skus.forEach((sku) => {
  const key = `${sku.skuId.skuType},${sku.skuId.id}`
  list.items[key] = {
    title: sku.title,
    description: `${sku.description} | ${sku.formattedPrice}`,
  };
});

4. Kauf abschließen

Verwenden Sie den Hilfs-Intent COMPLETE_PURCHASE mit dem vom Nutzer ausgewählten Artikel, um den Kauf abzuschließen.

Der folgende Node.js-Code verarbeitet die SKU-Auswahl des Nutzers aus einer Listenantwort und fordert den Intent COMPLETE_PURCHASE mit diesen Informationen an:

app.intent('Send Purchase', (conv, params, option) => {
  let [skuType, id] = option.split(',');

  conv.ask(new CompletePurchase({
    skuId: {
      skuType: skuType,
      id: id,
      packageName: <PACKAGE_NAME>,
    },
  }));
});

5. Ergebnis verarbeiten

Wenn der Kauf abgeschlossen ist, wird das Dialogflow-Ereignis actions_intent_COMPLETE_PURCHASE (oder der Intent actions.intent.COMPLETE_PURCHASE Actions SDK) mit dem Argument COMPLETE_PURCHASE_VALUE ausgelöst, das das Ergebnis beschreibt. Erstellen Sie einen Intent, der durch dieses Ereignis ausgelöst wird und dem Nutzer das Ergebnis übermittelt.

Behandeln Sie die folgenden möglichen Kaufergebnisse:

  • PURCHASE_STATUS_OK: Der Kauf war erfolgreich. Die Transaktion ist an diesem Punkt abgeschlossen. Beenden Sie daher den Transaktionsablauf und kehren Sie zu Ihrer Unterhaltung zurück.
  • PURCHASE_STATUS_ALREADY_OWNED: Die Transaktion ist fehlgeschlagen, weil der Nutzer das Element bereits besitzt. Sie können diesen Fehler vermeiden, indem Sie die vorherigen Käufe des Nutzers überprüfen und die angezeigten Artikel so anpassen, dass der Nutzer keine Artikel noch einmal kaufen kann, die er bereits besitzt.
  • PURCHASE_STATUS_ITEM_UNAVAILABLE: Die Transaktion ist fehlgeschlagen, weil das angeforderte Element nicht verfügbar ist. Sie können diesen Fehler vermeiden, indem Sie die verfügbaren Artikelnummern kurz vor dem Kauf prüfen.
  • PURCHASE_STATUS_ITEM_CHANGE_REQUESTED: Die Transaktion ist fehlgeschlagen, weil der Nutzer etwas anderes gekauft hat. Fordern Sie die Auftragserstellung erneut an, damit der Nutzer sofort eine weitere Entscheidung treffen kann.
  • PURCHASE_STATUS_USER_CANCELLED: Die Transaktion ist fehlgeschlagen, weil der Nutzer den Kaufvorgang abgebrochen hat. Da der Nutzer den Ablauf vorzeitig beendet hat, fragen Sie ihn, ob er die Transaktion wiederholen oder die Transaktion vollständig beenden möchte.
  • PURCHASE_STATUS_ERROR: Die Transaktion ist aus einem unbekannten Grund fehlgeschlagen. Teilen Sie dem Nutzer mit, dass die Transaktion fehlgeschlagen ist, und fragen Sie, ob er es noch einmal versuchen möchte.
  • PURCHASE_STATUS_UNSPECIFIED: Die Transaktion ist aus einem unbekannten Grund fehlgeschlagen, was zu einem unbekannten Status führt. Behandeln Sie diesen Fehlerstatus, indem Sie den Nutzer darüber informieren, dass die Transaktion fehlgeschlagen ist, und fragen, ob er es noch einmal versuchen möchte.

Der folgende Node.js-Code liest das Argument COMPLETE_PURCHASE_VALUE und verarbeitet jedes Ergebnis:

app.intent('Purchase Result', (conv) => {
  const arg = conv.arguments.get('COMPLETE_PURCHASE_VALUE');
  console.log('User Decision: ' + JSON.stringify(arg));
  if (!arg || !arg.purchaseStatus) {
    conv.close('Purchase failed. Please check logs.');
    return;
  }
  if (arg.purchaseStatus === 'PURCHASE_STATUS_OK') {
    conv.close(`Purchase completed! You're all set!`);
  } else if (arg.purchaseStatus === 'PURCHASE_STATUS_ALREADY_OWNED') {
    conv.close('Purchase failed. You already own this item.');
  } else if (arg.purchaseStatus === 'PURCHASE_STATUS_ITEM_UNAVAILABLE') {
    conv.close('Purchase failed. Item is not available.');
  } else if (arg.purchaseStatus === 'PURCHASE_STATUS_ITEM_CHANGE_REQUESTED') {
    // Reprompt with your item selection dialog
  }  else {
    conv.close('Purchase Failed:' + arg.purchaseStatus);
  }
});

Käufe des Nutzers widerspiegeln

Wenn ein Nutzer deine Aktion abfragt, enthält das JSON-Objekt user der Anfrage eine Liste seiner Käufe. Überprüfe diese Informationen und ändere die Antwort deiner Aktion basierend auf den Inhalten, für die der Nutzer bezahlt hat.

Der folgende Beispielcode zeigt das user-Objekt einer Anfrage, das packageEntitlements früherer In-App-Käufe enthält, die der Nutzer für das com.digitalgoods.application-Paket getätigt hat:

  "user": {
    "userId": "xxxx",
    "locale": "en-US",
    "lastSeen": "2018-02-09T01:49:23Z",
    "packageEntitlements": [
      {
        "packageName": "com.digitalgoods.application",
        "entitlements": [
          {
            "sku": "non-consumable.1",
            "skuType": "APP"
          }
          {
            "sku": "consumable.2",
            "skuType": "APP"
          }
        ]
      },
      {
        "packageName": "com.digitalgoods.application",
        "entitlements": [
          {
            "sku": "annual.subscription",
            "skuType": "SUBSCRIPTION",
            "inAppDetails": {
              "inAppPurchaseData": {
                "autoRenewing": true,
                "purchaseState": 0,
                "productId": "annual.subscription",
                "purchaseToken": "12345",
                "developerPayload": "HSUSER_IW82",
                "packageName": "com.digitalgoods.application",
                "orderId": "GPA.233.2.32.3300783",
                "purchaseTime": 1517385876421
              },
              "inAppDataSignature": "V+Q=="
            }
          }
        ]
      }
    ]
  },
  "conversation": {
    "conversationId": "1518141160297",
    "type": "NEW"
  },
  "inputs": [
    {
      "intent": "actions.intent.MAIN",
      "rawInputs": [
        {
          "inputType": "VOICE",
          "query": "Talk to My Test App"
        }
      ]
    }
  ],
  ...
}