Play Billing-Integration optimieren

1. Übersicht

Mit diesem Codelab zur Integration der Play Billing Library von Google Play können Sie Ihre Einnahmequellen optimieren und Ihre App mit Zuversicht auf den Markt bringen. In diesem strukturierten Codelab erfahren Sie, wie Sie eine zuverlässige Kaufabwicklung einrichten, testen und implementieren, um Ihre Monetarisierungsziele zu erreichen und eine nahtlosere Nutzererfahrung zu bieten.

Wir helfen Ihnen dabei, Entwicklerbenachrichtigungen in Echtzeit (RTDNs) und Play Billing Lab für Abos und Einmalkaufprodukte für Ihre Apps und Spiele einzurichten. Sie erfahren, wie Sie die Abonnentenabwanderung reduzieren, sich vor Betrug und Missbrauch schützen, Grenzfälle testen, potenzielle Probleme simulieren, reproduzieren und beheben sowie Angebote und Preisänderungen testen können, ohne Nutzer zu beeinträchtigen.

Am Ende sind Sie bereit, Rückgewinnungsstrategien zu implementieren, Integrationsprobleme schnell zu beheben, den ROI zu steigern, eine erstklassige Nutzererfahrung zu bieten und Ihre App und Updates mit Zuversicht einzuführen.

Vorbereitung

• Grundkenntnisse der Play Billing Library-Einbindung
• Kenntnisse der Android-App-Entwicklung (Java)

Lerninhalte

• So verwalten Sie Ihre Kaufzyklen richtig, um das Wachstum zu optimieren. Außerdem erhalten Sie Tipps zur Verbesserung von Kauf-Conversions und Kundenbindung.
• Einrichtung von Entwicklerbenachrichtigungen in Echtzeit (Real-time developer notifications, RTDN) mit Google Cloud Pub/Sub, die dann zur Implementierung von Rückgewinnungskampagnen und anderen Strategien zur Verwaltung des Lebenszyklus genutzt werden können
• Einrichtung eines Receivers auf Ihrem Backend-Server zur sicheren Verarbeitung der Benachrichtigungen mit genauer Erfassung und Berechtigung, um unbeabsichtigte Erstattungen oder Betrugs- und Missbrauchsrisiken zu verringern
• So testen Sie Ihre Einbindung und simulieren Fehler mit dem Play Billing Lab, um die Nutzerfreundlichkeit zu verbessern und gleichzeitig die Entwicklungskosten zu senken

Voraussetzungen

• Zugriff auf das Play-Entwicklerkonto für Ihre App in der Google Play Console
• Zugriff auf Ihr Google Cloud-Projekt mit aktivierter Google Play Developer API
• Ein Backend-Server zur Verwaltung von Konten und Berechtigungen für Ihre Android-App
• Lizenztester, die für Ihre App in der Play Console registriert sind
• Play Billing Lab auf Ihrem Testgerät installiert

2. Monetarisierungsstrategien für Abos und einmalige Käufe

Wenn Sie digitale Produkte über Ihre App verkaufen, muss eine erfolgreiche Monetarisierungsstrategie die gesamte Nutzerfreundlichkeit berücksichtigen, sowohl für Einmalkäufe als auch für Abos. Ein reibungsloser Ablauf kann die Kaufbereitschaft steigern und die Abwanderung reduzieren.

Ein gängiger Kaufvorgang für einen einmaligen Kauf oder ein Abo umfasst mehrere Phasen:

1. Der Nutzer sieht sich Artikel an, die er kaufen möchte.
2. Starten Sie den Kaufvorgang, damit der Nutzer den Kauf und die Zahlung abschließen kann.
3. Server über den abgeschlossenen Kauf benachrichtigen
4. Bestätigen Sie den Kauf auf Ihrem Server.
5. Stelle dem Nutzer Inhalte zur Verfügung.
6. Bestätigen Sie den Erhalt der Inhalte. Verbrauchen Sie Verbrauchsgüter zum richtigen Zeitpunkt, damit der Nutzer den Artikel noch einmal kaufen kann.

Durch die In-App-Integration können Sie Kaufvorgänge starten und die Nutzererfahrung verwalten. Es ist jedoch wichtig, dass Sie Ihr Backend über die Berechtigungen auf dem Laufenden halten, die Nutzer kaufen. Dies ist wichtig, um Käufe zu erfassen und andere Aspekte der Nutzererfahrung zu verwalten, z. B. plattformübergreifende Berechtigungen.

Echtzeit-Entwicklerbenachrichtigungen (Real-time developer notifications, RTDN) sind eine gute Möglichkeit, diese verschiedenen Phasen im Kaufzyklus zu erkennen. Sie können sowohl als Echtzeit-Tool zur Leistungsanalyse als auch als Tool zur Umsetzung von Strategien zur Rückgewinnung von Abonnenten eingesetzt werden.

Beispiel: Ein Nutzer hat gerade einen neuen Artikel gekauft oder die Zahlung wurde nicht rechtzeitig ausgeführt und das Abo befindet sich im Kulanzzeitraum. Mit dem richtigen RTDN können Sie in Echtzeit erkennen, dass sich der Status des Nutzers geändert hat, und entsprechend reagieren. Sie können den Nutzer entweder noch stärker an den gerade gekauften Artikel binden oder ihm Erinnerungs-E-Mails senden, damit er seine Zahlungsdetails aktualisiert, um sein Abo fortzusetzen.

Truecaller konnte dank der Implementierung von RTDN etwa 40% der Abonnenten zurückgewinnen. Weitere Informationen

RTDNs sind auch eine gute Möglichkeit, zusätzliche serverseitige Steuerelemente hinzuzufügen, mit denen Sie Käufe verwalten können, auch wenn der Client des Nutzers Probleme hat. Angenommen, ein Nutzer hat einen erfolgreichen Kauf getätigt und eine Bestätigung von Google erhalten, aber die Netzwerkverbindung seines Geräts wird unterbrochen, bevor sein Gerät und Ihre App über den Kauf-Listener eine Benachrichtigung über den Kauf erhalten. Mit RTDNs erhalten Sie eine unabhängige Benachrichtigung über Ihren Server, sodass Sie den Kauf erkennen und dem Nutzer unabhängig vom Clientproblem das Recht gewähren können. So wird ein zuverlässiger Kaufprozess gewährleistet.

Weitere Informationen zu allen derzeit unterstützten Arten von Benachrichtigungen in Echtzeit Jeder Typ von RTDN signalisiert einen bestimmten Kaufstatus. Es ist wichtig, entsprechende Verarbeitungsmechanismen zu implementieren, um eine ordnungsgemäße Verarbeitung gemäß Ihren Anwendungsfällen zu gewährleisten. In diesem Codelab wird anhand eines Beispiels gezeigt, wie Sie die RTDN-Nachricht auf Ihrem sicheren Backend-Server verarbeiten. Dazu gehören das Empfangen der Nachricht, das Validieren des Kaufs und das Gewähren des Anspruchs für den richtigen Nutzer, wenn ein Nutzer einen Kauf in Ihrer App erfolgreich abschließt. Anschließend wird gezeigt, wie Sie RTDNs für Ihre App konfigurieren.

3. Entwicklerbenachrichtigungen in Echtzeit konfigurieren

Entwicklerbenachrichtigungen in Echtzeit (Real-time developer notifications, RTDN) nutzen Google Cloud Pub/Sub, damit Sie sofort auf Änderungen des Kaufstatus reagieren können. Cloud Pub/Sub ist ein vollständig verwalteter Echtzeit-Messaging-Dienst, mit dem Sie Nachrichten zwischen unabhängigen Anwendungen senden und empfangen können. Google Play verwendet Cloud Pub/Sub, um Push-Benachrichtigungen zu Themen zu veröffentlichen, die Sie abonnieren.

Wenn Sie RTDN aktivieren möchten, müssen Sie zuerst Cloud Pub/Sub mit Ihrem eigenen Google Cloud-Projekt (GCP) einrichten und dann die Benachrichtigungen für Ihre App aktivieren. Wenn Sie sich mit GCP und Cloud Pub/Sub nicht auskennen, lesen Sie die Kurzanleitung.

Thema erstellen

Damit Sie Benachrichtigungen erhalten, müssen Sie ein Thema erstellen, in dem Google Play die Benachrichtigungen veröffentlichen soll. Folgen Sie der Anleitung unter Thema erstellen, um ein Thema zu erstellen.

Pub/Sub-Abo erstellen

Wenn Sie Nachrichten empfangen möchten, die zu einem Thema veröffentlicht wurden, müssen Sie ein Pub/Sub-Abo für dieses Thema erstellen. So erstellen Sie ein Pub/Sub-Abo:

1. Im Cloud Pub/Sub-Abonnentenleitfaden erfahren Sie, wie Sie das Abo als Push-Abo oder Pull-Abo konfigurieren. In diesem Codelab arbeiten wir mit einem Pull-Abo, bei dem Ihr sicherer Backend-Server Anfragen an den Cloud Pub/Sub-Server initiieren muss, um Nachrichten abzurufen.

Unter Pull- oder Push-Zustellung finden Sie Informationen, die Ihnen bei der Entscheidung helfen, ob ein Push- oder Pull-Abo für Ihre App am besten geeignet ist.

2. Folge der Anleitung unter Abo hinzufügen, um ein Abo zu erstellen.

Veröffentlichungsrechte für das Thema gewähren

Für Cloud Pub/Sub müssen Sie Google Play-Berechtigungen gewähren, um Benachrichtigungen in Ihrem Thema zu veröffentlichen.

1. Öffnen Sie die Google Cloud Console.
2. Wählen Sie Ihr Projekt aus, suchen Sie in der Suchleiste nach Pub/Sub und rufen Sie die Pub/Sub-Konfigurationsseite auf.
3. Suchen Sie nach dem Thema und öffnen Sie die Berechtigungseinstellung.
4. Klicken Sie auf HAUPTKONTO HINZUFÜGEN, um das Dienstkonto [e-mail] hinzuzufügen, und weisen Sie ihm die Rolle Pub/Sub-Publisher zu.
5. Klicken Sie auf Speichern, um die Einrichtung des Themas abzuschließen.

Entwicklerbenachrichtigungen in Echtzeit für Ihre App aktivieren

Hier erfahren Sie, wie Sie Entwicklerbenachrichtigungen in Echtzeit einrichten, um Ihre Play Billing-Integration deutlich zu verbessern. Sie können die Zuverlässigkeit von Käufen durch personalisierte Nachrichten verbessern und Betrug und Missbrauch verhindern, um den ROI insgesamt zu steigern.

RTDNs bieten sofortige Server-zu-Server-Updates direkt von Google Play für wichtige Ereignisse wie Aboverlängerungen, neue Käufe und Zahlungsprobleme. Sie helfen Ihren Backend-Systemen, sich automatisch mit dem tatsächlichen Status der Nutzerberechtigungen zu synchronisieren. So können Sie Einschränkungen auf Clientseite umgehen und sofort und angemessen reagieren.

So aktivieren Sie Entwicklerbenachrichtigungen in Echtzeit für Ihre App:

1. Öffnen Sie die Google Play Console.
2. Wählen Sie Ihre App aus.
3. Rufen Sie Mit Google Play monetarisieren > Einrichtung der Monetarisierung auf.
4. Scrollen Sie zum Abschnitt Entwicklerbenachrichtigungen in Echtzeit.
5. Klicken Sie das Kästchen Echtzeitbenachrichtigungen aktivieren an.
6. Geben Sie im Feld Name des Themas den vollständigen Cloud Pub/Sub-Themennamen ein, den Sie zuvor konfiguriert haben. Der Themenname muss das Format projects/{project_id}/topics/{topic_name} haben, wobei project_id die eindeutige Kennzeichnung Ihres Projekts und topic_name der Name des zuvor erstellten Themas ist.
7. Klicken Sie auf Testnachricht senden, um eine Testnachricht zu senden. Mit einem Testlauf können Sie sicherstellen, dass alles richtig eingerichtet und konfiguriert ist. Wenn die Testveröffentlichung erfolgreich ist, wird eine entsprechende Meldung angezeigt. Wenn Sie ein Abo für dieses Thema angehängt haben, sollten Sie die Testnachricht erhalten. Rufen Sie für ein Pull-Abo das Abo in der Cloud Console auf, klicken Sie auf Nachrichten ansehen und rufen Sie Nachrichten ab. Sie sollten jede Nachricht bestätigen, die Sie abgerufen haben, um eine wiederholte Zustellung durch Cloud Pub/Sub zu vermeiden. Prüfen Sie bei einem Push-Abo, ob die Testnachricht an Ihren Push-Endpunkt gesendet wird. Ein erfolgreicher Antwortcode dient als Bestätigung. Wenn die Veröffentlichung fehlschlägt, wird ein Fehler angezeigt. Prüfen Sie, ob der Themenname korrekt ist und das Dienstkonto [e-mail] Zugriff auf das Thema mit der Rolle Pub/Sub Publisher hat.
8. Wählen Sie aus, welche Benachrichtigungstypen Sie erhalten möchten.

• Benachrichtigungen zu Abos und allen ungültigen Käufen erhalten: Sie erhalten Entwicklerbenachrichtigungen in Echtzeit zu Abos und ungültigen Käufen. Sie erhalten keine Benachrichtigungen für Einmalkaufprodukte.
• Alle Benachrichtigungen zu Abos und Einmalprodukten erhalten: Sie erhalten Benachrichtigungen zu allen Abo- und ungültigen Kaufereignissen. Sie erhalten auch Ereignisse für den Kauf von Einmalkaufprodukten, z. B. ONE_TIME_PRODUCT_PURCHASED und ONE_TIME_PRODUCT_CANCELED. Weitere Informationen zu diesen Kaufereignissen finden Sie unter Lebenszyklus von Einmalkäufen.

9. Klicken Sie auf Änderungen speichern.

Sie haben jetzt die Echtzeit-Entwicklerbenachrichtigungen für Ihre App eingerichtet. Damit haben Sie die Tools, um häufige Probleme wie Nutzerabwanderung durch Reaktivierungsnachrichten oder Betrug und Missbrauch zu beheben. Im nächsten Abschnitt erstellen wir einen Abonnenten auf Ihrem sicheren Backend-Server, um die an Ihr Cloud Pub/Sub-Thema gesendeten Nachrichten zu verarbeiten.

4. Benachrichtigungen erhalten

Es ist wichtig, dass der Backend-Server über den Status der Käufe auf dem Laufenden gehalten wird, damit die Nutzer in Ihrer App eine optimale Nutzererfahrung haben. Wenn ein Nutzer beispielsweise einen Kauf mit einer Zahlung in der App abschließt, sollten die Inhalte so schnell wie möglich an sein Konto gesendet werden.

Dazu muss der Abschluss des Kaufs rechtzeitig erkannt und verarbeitet werden. Die Play Billing Library bietet mehrere Möglichkeiten, Käufe in Ihrer App zu erkennen. Wenn ein abgeschlossener Kauf erkannt wird, muss Ihre App Ihren Backend-Server benachrichtigen, damit der Kauf bestätigt, der Inhalt dem richtigen Nutzer gewährt und Google darüber informiert wird, dass der Kauf verarbeitet wurde. Es kann jedoch aus verschiedenen Gründen vorkommen, dass der Kauf in Ihrer App nicht rechtzeitig erkannt wurde. Ein Nutzer kann beispielsweise einen erfolgreichen Kauf tätigen und eine Bestätigung von Google erhalten, aber die Netzwerkverbindung seines Geräts wird unterbrochen, bevor sein Gerät und Ihre App eine Benachrichtigung über die Play Billing Library-Schnittstelle erhalten. RTDN bietet zusätzliche serverseitige Steuerelemente, mit denen Sie Käufe auch dann verwalten können, wenn es Probleme mit dem Client des Nutzers gibt. RTDN garantiert unabhängige Benachrichtigungen an Ihren Server bei Änderungen des Kaufstatus. So können Sie Änderungen des Kaufstatus fast sofort über einen zweiten Pfad unabhängig von potenziellen Clientproblemen erkennen und einen zuverlässigeren Kaufprozess gewährleisten.

In diesem Abschnitt erstellen Sie einen Abonnenten, der die Nachrichten verarbeitet, die an Ihr Cloud Pub/Sub-Thema gesendet werden. Dazu verwenden Sie die Cloud Pub/Sub-Clientbibliotheken. Diese Bibliotheken sind in verschiedenen Sprachen verfügbar. In den folgenden Abschnitten fügen wir dem Abonnenten hinzu, um den Kauf zu bestätigen, dem richtigen Nutzer ein Recht zu gewähren und den Kauf auf dem Server zu bestätigen/zu verarbeiten. In diesem Codelab verwenden wir Java.

Jede Veröffentlichung in einem Cloud Pub/Sub-Thema enthält ein einzelnes base64-codiertes Datenfeld.

{
 "message": {
   "attributes": {
     "key": "value"
   },
   "data": "eyAidmVyc2lvbiI6IHN0cmluZywgInBhY2thZ2VOYW1lIjogc3RyaW5nLCAiZXZlbnRUaW1lTWlsbGlzIjogbG9uZywgIm9uZVRpbWVQcm9kdWN0Tm90aWZpY2F0aW9uIjogT25lVGltZVByb2R1Y3ROb3RpZmljYXRpb24sICJzdWJzY3JpcHRpb25Ob3RpZmljYXRpb24iOiBTdWJzY3JpcHRpb25Ob3RpZmljYXRpb24sICJ0ZXN0Tm90aWZpY2F0aW9uIjogVGVzdE5vdGlmaWNhdGlvbiB9",
   "messageId": "136969346945"
 },
 "subscription": "projects/myproject/subscriptions/mysubscription"
}

Nachdem Sie das Base64-codierte Datenfeld decodiert haben, enthält DeveloperNotification die folgenden Felder:

{
 "version": string,
 "packageName": string,
 "eventTimeMillis": long,
 "oneTimeProductNotification": OneTimeProductNotification,
 "subscriptionNotification": SubscriptionNotification,
 "voidedPurchaseNotification": VoidedPurchaseNotification,
 "testNotification": TestNotification
}

Weitere Informationen finden Sie in der Referenz zu Entwicklerbenachrichtigungen in Echtzeit.

Im Folgenden finden Sie den Beispielcode für einen NotificationReceiver für Ihren sicheren Backend-Server, um die Pub/Sub-Nachrichten zu verarbeiten. Richten Sie zur Authentifizierung bei Security Command Center die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import com.google.cloud.pubsub.v1.AckReplyConsumer;
import com.google.cloud.pubsub.v1.MessageReceiver;
import com.google.cloud.pubsub.v1.Subscriber;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.PubsubMessage;
import java.util.Base64;
import org.json.JSONObject;

/** Real-time developer notifications receiver. */
public class NotificationReceiver {

 private NotificationReceiver() {}

 /*
  * Receive notification messages from the subscription.
  *
  * @param projectId The project ID of your Google Cloud Project.
  * @param subscriptionId The subscription ID of the subscriber to the pub/sub topic.
  */
 public static void receiveNotificationMessages(String projectId, String subscriptionId) {
   ProjectSubscriptionName subscriptionName =
       ProjectSubscriptionName.of(projectId, subscriptionId);

   try {
     Subscriber subscriber =
         Subscriber.newBuilder(subscriptionName, new NotificationMessageReceiver()).build();
     // Start the subscriber.
     subscriber.startAsync().awaitRunning();

     subscriber.awaitTerminated();
   } catch (IllegalStateException e) {
     System.out.println("Subscriber stopped: " + e);
   }
 }

 static class NotificationMessageReceiver implements MessageReceiver {

   @Override
   public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
     // Decode the data into a String from the message data field.
     String jsonString = new String(Base64.getDecoder().decode(message.getData().toStringUtf8()));
     // Parse the String into a JSON object.
     JSONObject messageJson = new JSONObject(jsonString);

     // Fetch the value for certain fields.
     String version = messageJson.getString("version");
     String packageName = messageJson.getString("packageName");
     System.out.println("version: " + version);
     System.out.println("packageName: " + packageName);

     // Validate the purchase and grant the entitlement as needed.
     // More details in the following sections.
     // ......

     // Acknowledge the message to avoid repeated delivery.
     consumer.ack();
   }
 }
}

Sie haben jetzt einen Benachrichtigungsempfänger, der die Nachrichten verarbeitet, die an Ihr Cloud Pub/Sub-Thema auf Ihrem sicheren Backend-Server gesendet werden. In den folgenden Abschnitten werden die Best Practices für die Verarbeitung der RTDN-Nachrichten auf Ihrem Backend-Server beschrieben.

5. Nutzer-IDs im Kaufprozess in Ihrer App anhängen

Wenn Ihr Server die RTDN-Nachricht zur Aktualisierung des Kaufstatus empfängt, muss er wissen, welcher Nutzer den Kauf getätigt hat, um ihn zu verarbeiten, z. B. um die Inhalte an den richtigen Nutzer zu senden. Dazu können Sie alle Nutzerkennungen, die Sie für den Nutzer haben, der den Kauf tätigt, beim Starten des Kaufvorgangs in Ihrer App mit obfuscatedAccountId anhängen. Eine Beispielkennung könnte eine verschleierte Version der Anmeldung des Nutzers in Ihrem System sein. Wenn Sie diesen Parameter festlegen, kann Google Betrug besser erkennen. Außerdem können Sie so dafür sorgen, dass Käufe dem richtigen Nutzer zugeordnet werden, wie unter Nutzern Berechtigungen gewähren beschrieben.

Im Folgenden finden Sie Beispielcode zum Anhängen der Nutzer-ID beim Starten des Kaufvorgangs in der App durch Festlegen von obfuscatedAccountId.

// An activity reference from which the billing flow will be launched.
Activity activity = ...;
// A user identifier, e.g. an obfuscated user id in your system.
String obfuscatedAccountId = ...;

ImmutableList<ProductDetailsParams> productDetailsParamsList =
    ImmutableList.of(
        ProductDetailsParams.newBuilder()
            // retrieve a value for "productDetails" by calling queryProductDetailsAsync()
            .setProductDetails(productDetails)
            // set the offer token to specify the offer to purchase when applicable, e.g., subscription products
            // .setOfferToken(offerToken)
            .build()
    );

BillingFlowParams billingFlowParams = BillingFlowParams.newBuilder()
    .setProductDetailsParamsList(productDetailsParamsList)
    .setObfuscatedAccountId(obfuscatedAccountId)
    .build();

// Launch the billing flow
BillingResult billingResult = billingClient.launchBillingFlow(activity, billingFlowParams);

Wie Sie im nächsten Abschnitt sehen, wird die im Kaufvorgang festgelegte Nutzer-ID in den Kauf aufgenommen und kann verwendet werden, um dem richtigen Nutzer Berechtigungen zu gewähren.

6. Käufe vor dem Gewähren von Berechtigungen bestätigen

In diesem Abschnitt werden die Best Practices für die Überprüfung von Käufen beschrieben, bevor Berechtigungen auf Ihrem sicheren Backend-Server gewährt werden.

Nachdem ein Nutzer ein Einmalkaufprodukt gekauft hat, erhält der Pub/Sub-Abonnent auf Ihrem sicheren Backend-Server eine Pub/Sub-Nachricht. Sie sollten auf Ihrem Backend-Server Folgendes tun:

1. Parsen Sie purchaseToken aus der Pub/Sub-Nachricht. Sie sollten alle purchaseToken-Werte für alle Käufe aufzeichnen.
2. Prüfen Sie, ob der purchaseToken-Wert für den aktuellen Kauf mit einem vorherigen purchaseToken-Wert übereinstimmt. purchaseToken ist global eindeutig. Sie können diesen Wert also problemlos als Primärschlüssel in Ihrer Datenbank verwenden.
3. Verwenden Sie den Endpunkt purchases.products:get in der Google Play Developer API, um bei Google zu bestätigen, dass der Kauf legitim ist.

Verwenden Sie den Endpunkt purchases.subscriptionsv2:get in der Google Play Developer API für Abos.

4. Wenn der Kauf legitim ist und in der Vergangenheit nicht verwendet wurde, können Sie das In-App-Produkt oder das Abo sicher gewähren.
5. Du solltest die Berechtigung nur erteilen, wenn der Kaufstatus PURCHASED ist, und darauf achten, dass du die PENDING-Käufe richtig verarbeitest. Weitere Informationen finden Sie unter Ausstehende Transaktionen verarbeiten.

Im folgenden Codebeispiel wird ein API-Client für die Google Play Developer API erstellt. Wir verwenden sie später für die API-Aufrufe.

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.androidpublisher.AndroidPublisher;
import com.google.api.services.androidpublisher.AndroidPublisherScopes;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

/** Helper class to initialize the publisher APIs client library. */
public class AndroidPublisherHelper {
 /* Your application name */
 private static final String APPLICATION_NAME = "YourApplicationName";

 /* Load credentials from a JSON key file. Replace with the actual path to your downloaded service
  * account key file.
  */
 private static final String RESOURCES_CLIENT_SECRETS_JSON =
     "/path/to/your/service_account_key.json";

 /** Global instance of the JSON factory. */
 private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();

 /* The API client */
 private static final AndroidPublisher ANDROID_PUBLISHER = init();

 /**
  * Performs all necessary setup steps for running requests against the API.
  *
  * @return the {@link AndroidPublisher} service
  */
 private static AndroidPublisher init(){
   try {
     // Authorization.
     Credential credential =
         GoogleCredential.fromStream(
                 AndroidPublisherHelper.class.getResourceAsStream(RESOURCES_CLIENT_SECRETS_JSON))
             .createScoped(Collections.singleton(AndroidPublisherScopes.ANDROIDPUBLISHER));

     HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();

     // Set up and return API client.
     return new AndroidPublisher.Builder(httpTransport, JSON_FACTORY, credential)
         .setApplicationName(ApplicationConfig.APPLICATION_NAME)
         .build();
   } catch (GeneralSecurityException | IOException ex) {
     throw new RuntimeException("fail to initialize the publisher APIs client library", ex);
   }
 }
}

Anschließend fügen wir die Logik hinzu, um den API-Aufruf auszuführen, und ändern den zuvor erstellten Receiver, um den Kauf zu validieren und dem richtigen Nutzer die Berechtigung zu gewähren.

Fügen Sie in AndroidPublisherHelper die folgende Methode hinzu, um den ProductPurchase über den Endpunkt Purchases.products:get in der Google Play Developer API abzurufen.

 /* Fetch the ProductPurchase for the one-time product purchase from
  * Purchases.products.get endpoint in the Google Play Developer API
  */
 public static ProductPurchase executeProductPurchasesGet(
     String packageName, String sku, String purchaseToken) {
   try {
     ProductPurchase productPurchase =
         ANDROID_PUBLISHER.purchases().products().get(packageName, sku, purchaseToken).execute();
     return productPurchase;
   } catch (IOException ex) {
     log.error("Exception was thrown while getting a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to fetch the purchase in case of transient failures.
     return null;
   }
 }

Validieren Sie den Kauf in NotificationMessageReceiver und gewähren Sie dem richtigen Nutzer in Ihrem System die Berechtigung anhand der in der Benachrichtigung enthaltenen Daten. Sie sollten die purchaseToken auf Ihrem Server im Blick behalten, um eine doppelte Verarbeitung zu vermeiden.

Unter Referenz zu Entwicklerbenachrichtigungen in Echtzeit finden Sie alle Arten von Benachrichtigungen, die Sie von Google Play erhalten können. Sie können sie auf Ihrem Server entsprechend Ihren geschäftlichen Anforderungen verarbeiten.

 @Override
 public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
   // Decode the data into a String from the message data field.
   String jsonString = new String(Base64.getDecoder().decode(message.getData().toStringUtf8()));
   // Parse the String into a JSON object.
   JSONObject messageJson = new JSONObject(jsonString);

   // Fetch the value for certain fields.
   String version = messageJson.getString("version");
   String packageName = messageJson.getString("packageName");

   // Process notification data based on your business requirements.
   // Process oneTimeProductNotification in the message.
   JSONObject oneTimeProductNotificationJson =
       messageJson.getJSONObject("oneTimeProductNotification");
   if (oneTimeProductNotificationJson != null) {
     String purchaseToken = oneTimeProductNotificationJson.getString("purchaseToken");
     String sku = oneTimeProductNotificationJson.getString("sku");
     int notificationType = oneTimeProductNotificationJson.getInt("notificationType");

     if (notificationType == 1) {
       // ONE_TIME_PRODUCT_PURCHASED - A one-time product was successfully purchased by a user.
       // Verify that the purchaseToken value does not match any previous purchaseToken values in
       // your backend system to avoid duplicate processing.
       ......
       // Fetch the ProductPurchase from Purchases.products.get endpoint
       ProductPurchase productPurchase =
         AndroidPublisherHelper.executeProductPurchasesGet(packageName, sku, purchaseToken);
       if (productPurchase != null && productPurchase.getPurchaseState() == 0) {
         // The purchase is valid and in PURCHASED state.

         // The account Id set in the App when launching the billing flow.
         String obfuscatedExternalAccountId = productPurchase.getObfuscatedExternalAccountId();
         // Grant the entitlement to the correct account for obfuscatedExternalAccountId in your
         // system.
       ......
       }
     }
     // Process subscriptionNotification in the message.
     JSONObject subscriptionNotificationJson = messageJson.getJSONObject("subscriptionNotification");
     if (subscriptionNotificationJson != null) {
       ......
     }
     // Process other notification data in the message as needed.
     ......
   }

   // Acknowledge the message to avoid repeated delivery.
   consumer.ack();
 }

7. Google benachrichtigen, dass der Kauf bearbeitet wurde

Nachdem die Berechtigung erteilt wurde, sollten Sie Google benachrichtigen, dass der Kauf verarbeitet wurde. Rufen Sie dazu auf Ihrem sicheren Backend-Server die Endpunkte purchases.products:consume oder purchases.products:acknowledge in der Play Developer API auf, um ein Verbrauchsprodukt zu verbrauchen oder ein nicht verbrauchbares Produkt zu bestätigen.

Verwende den Endpunkt purchases.subscriptions:acknowledge in der Google Play Developer API, um Abos zu bestätigen.

Fügen Sie in AndroidPublisherHelper die folgenden Methoden hinzu, um purchases.products:consume oder purchases.products:acknowledge in der Google Play Developer API aufzurufen.

 /* Consume the one-time product purchase by calling
  * Purchases.products.consume endpoint in the Google Play Developer API
  */
 public static void executeProductPurchasesConsume(
     String packageName, String sku, String purchaseToken) {
   try {
     ANDROID_PUBLISHER
       .purchases().products().consume(packageName, sku, purchaseToken).execute();
   } catch (IOException ex) {
     log.error("Exception was thrown while consuming a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to ensure the purchase is correctly consumed in case of transient failures.
   }
 }

 /* Acknowledge the one-time product purchase by calling
  * Purchases.products.acknowledge endpoint in the Google Play Developer API
  */
 public static void executeProductPurchasesAcknowledge(
     String packageName, String sku, String purchaseToken) {
   try {
     ANDROID_PUBLISHER
       .purchases().products().acknowledge(packageName, sku, purchaseToken, new ProductPurchasesAcknowledgeRequest()).execute();
   } catch (IOException ex) {
     log.error("Exception was thrown while acknowledging a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to ensure the purchase is correctly acknowledged in case of transient failures.
   }
 }

Verbrauche in NotificationMessageReceiver den Kauf des verbrauchbaren Produkts oder bestätige den Kauf des nicht verbrauchbaren Produkts, nachdem du die Berechtigung auf deinem Backend-Server erteilt hast.

 @Override
 public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
   ......
       String obfuscatedExternalAccountId = productPurchase.getObfuscatedExternalAccountId();
       // Grant the entitlement to the correct account for obfuscatedExternalAccountId in your
       // system.
       ......
       // If the product is a consumable product, consume the purchase.
       AndroidPublisherHelper.executeProductPurchasesConsume(packageName, sku, purchaseToken);
       // Or if the product is a non-consumable product, acknowledge the purchase.
       // AndroidPublisherHelper.executeProductPurchasesAcknowledge(packageName, sku, purchaseToken);
  ......

 }

Die Bestätigung ist erforderlich, da Google Play dadurch darüber informiert wird, dass dem Nutzer die Berechtigung für den Kauf gewährt wurde. Sie sollten den Kauf sofort nach der Erteilung der Berechtigung bestätigen.

Gut gemacht! Sie haben die Integration mit Entwicklerbenachrichtigungen in Echtzeit erfolgreich abgeschlossen und können Käufe zuverlässig verarbeiten, wie in diesem Codelab gezeigt. Damit alles reibungslos funktioniert, sehen wir uns nun das Play Billing Lab an. Dieses nutzerfreundliche Tool wurde entwickelt, um Ihnen beim Testen Ihrer Play Billing-Einbindung zu helfen.

8. Mit Play Billing Lab testen

Damit Sie Ihre Integration mit Zuversicht starten können, sollten Sie sie während der gesamten Entwicklung testen. Play Billing Lab ist eine kostenlose Android-App, mit der Entwickler ihre Integration in das Abrechnungssystem von Google Play testen können. Sie bietet eine einfache und bequeme Möglichkeit, Play Billing-Funktionen zu testen, schneller zu integrieren und einfacher zu launchen.

Das Play Billing Lab bietet verschiedene Testfunktionen, mit denen Sie unterschiedliche Szenarien testen können, darunter:

• Ändern Sie das Play-Land in Play Billing Lab und wenden Sie die Einstellungen auf Ihren Test an. So können Sie benutzerdefinierte Funktionen in verschiedenen Ländern/Regionen testen, unabhängig davon, wo sich der Tester befindet.
• Testzeiträume oder Einführungsangebote wiederholt mit demselben Konto testen
• Preisänderungen für Abos testen, ohne dass dies Auswirkungen auf andere aktive Abonnenten hat
• Play Billing Library-Antwortcode simulieren, um in verschiedenen Fehlerszenarien zu testen
• Aboverlängerungen beschleunigen, um Tests zu beschleunigen
• Mit echten Zahlungsmethoden testen, um bestimmte Risikosignale für den Kaufvorgang zu umgehen

Wir fügen der Play Billing Lab-App kontinuierlich neue Testfunktionen hinzu. Sie können Play Billing Lab im Play Store herunterladen und installieren. Weitere Informationen zum Testen mit Play Billing Lab finden Sie unter Einbindung testen.

BillingResponseCode mit Play Billing Lab testen

Es ist oft schwierig, alle BillingResponseCode-Abläufe zu testen, wenn Sie Ihre App in die Play Billing Library einbinden, da Sie nur wenig Kontrolle über die Kommunikation zwischen dem Play Store und dem Play-Backend haben. Mit der Funktion Antwortsimulator in der Play Billing Lab App können Sie Fehlercode-Antworten für die Play Billing Library konfigurieren, um verschiedene komplexe Fehlerszenarien zu testen.

Sie haben beispielsweise die Logik in Ihrer App implementiert, um den Kauf zu verarbeiten, nachdem Ihre App den erfolgreichen Kauf erkannt hat. Sie möchten das Szenario testen, in dem Ihre App den Kauf aufgrund eines Netzwerkfehlers nicht verarbeiten konnte und der RTDN-Empfänger auf Ihrem Backend-Server die Nachricht empfängt und den Kauf korrekt verarbeitet. Mit dem Response Simulator können Sie das Szenario für Ihre Tests simulieren. Im Folgenden wird beschrieben, wie Sie mit dem Response Simulator des Play Billing Lab testen.

Mit dem Antwortsimulator testen

Wenn Sie mit dem Antwortsimulator testen, kommuniziert Ihre App mit dem Play Billing Lab, um den Antwortcode abzurufen, den Sie im Antwortsimulator des Play Billing Lab konfiguriert haben.

Testen von Abrechnungsüberschreibungen für die Play Billing Library aktivieren

Damit der Response Simulator und Ihre App miteinander kommunizieren können, müssen Sie zuerst das Testen von Abrechnungsüberschreibungen für die Play Billing Library in Ihrer App aktivieren. Fügen Sie dazu die folgenden Metadaten-Tags in die Datei AndroidManifest.xml Ihrer App ein.

<manifest ... >
  <application ... >
    ...
     <meta-data
      android:name="com.google.android.play.largest_release_audience.NONPRODUCTION"
      android:value="" />
    <meta-data
      android:name="com.google.android.play.billingclient.enableBillingOverridesTesting"
      android:value="true" />
  </application>
</manifest>

Erstellen Sie Ihre App mit der aktualisierten Datei AndroidManifest.xml. Ihre App ist jetzt für den Antwortsimulator von Play Billing Lab bereit.

Auch wenn es ausreicht, nur das enableBillingOverridesTesting-Tag hinzuzufügen und auf true zu setzen, um das Testen von Abrechnungsüberschreibungen für Ihre App zu aktivieren, wird empfohlen, auch das NONPRODUCTION-Tag hinzuzufügen. Das Tag NONPRODUCTION verhindert die versehentliche Bereitstellung Ihrer App in der Produktionsumgebung, wenn das Testen von Abrechnungsüberschreibungen aktiviert ist.

Wenn Sie Ihre App nach dem Testen in der Produktionsumgebung bereitstellen, sollten Sie entweder eine separate AndroidManifest.xml-Datei verwenden, die diese Metadaten-Tags nicht enthält, oder dafür sorgen, dass Sie diese Tags aus der AndroidManifest.xml-Datei entfernt haben.

Fehler der Play Billing Library simulieren

Wenn Sie Fehler mit simulierten Play Billing Library-Fehlern testen möchten, konfigurieren Sie zuerst den Antwortcode in der Play Billing Lab-App und führen Sie dann den Test in Ihrer App aus.

Antwortcode konfigurieren

1. Melden Sie sich in der Play Billing Lab App mit einem Lizenztesterkonto für Ihre App an. Das folgende Bild zeigt das Dashboard von Play Billing Lab,einschließlich der Karte Antwortsimulator.

2. Klicken Sie auf der Karte „Antwortsimulator“ auf Verwalten, um zum Bildschirm „Antwortsimulator“ zu gelangen.
3. Lassen Sie Benachrichtigungen von Play Billing Lab zu, um den Verbindungsstatus Ihrer App zu sehen.
4. Aktivieren Sie den Schalter „Simulierung mit Play Billing Library-Antworten“, falls er noch nicht aktiviert ist.

5. Wählen Sie einen Antwortcode für die Play Billing Library-APIs aus, die Sie testen möchten. Um den Fehler für den Kauf zu simulieren, wählen Sie einen Fehlercode für die consumeAsync API aus. Ihre Auswahl wird automatisch gespeichert. Die Antwortsimulation ist jetzt bereit, die ausgewählten Antwortcodes an Ihre App zu senden.

App testen

Jetzt können Sie Ihre App testen, um zu prüfen, ob alles wie erwartet funktioniert. Öffnen Sie Ihre App und rufen Sie die Play Billing Library API-Methode auf. Wenn Ihre App den consumeAsync-Aufruf zum Einlösen des Kaufs ausführt, erhält sie den gerade konfigurierten Fehlercode. Anhand des Fehlercodes können Sie prüfen, ob Ihre App richtig funktioniert und Ihr Back-End-Server den Kauf korrekt verarbeitet.

Wenn Sie mit dem Testen fertig sind, schalten Sie einfach den Schalter „Play Billing Library-Antwort simulieren“ aus, um die Simulation der Antwort zu beenden.

Weitere Informationen zum Testen mit Play Billing Lab und zur In-App-Abrechnung mit Lizenztestern finden Sie in der Hilfe.

9. Glückwunsch!

Sie haben dieses Codelab abgeschlossen und können jetzt Ihre App-Monetarisierung strategisch optimieren, um die Nutzerfreundlichkeit zu verbessern und so die Nutzerzufriedenheit, Kauf-Conversions und Abonnentenabwanderung zu steigern.

Mit Entwicklerbenachrichtigungen in Echtzeit und der Begleit-App Play Billing Lab können Sie proaktiv auf Ereignisse im Kauflebenszyklus für Einmalkäufe und Abos reagieren.

Mit diesen Tools können Sie effektive Reaktivierungsstrategien implementieren, Integrationsprobleme schnell beheben und letztendlich die Nutzerfreundlichkeit und die Einnahmequellen verbessern, um Ihre App oder Ihr Spiel mit Zuversicht zu starten.

Nach Abschluss dieses Codelabs verfügen Sie über die erforderlichen Kenntnisse, um den gesamten Kaufprozess zu verwalten und Ihre Implementierung im Play-Abrechnungslab gründlich zu testen. So können Sie für eine nahtlose Nutzererfahrung sorgen und Ihr Monetarisierungspotenzial bei Google Play maximieren.