Maksymalizowanie integracji z płatnościami w Google Play

1. Przegląd

Zoptymalizuj swoje źródła przychodów i bez obaw publikuj aplikację dzięki temu samouczącemu laboratorium Google Play o integracji z Biblioteką płatności w Play. Ten uporządkowany przewodnik po Codelab pomoże Ci skonfigurować, przetestować i wdrożyć niezawodne przetwarzanie zakupów, co pozwoli Ci realizować cele związane z generowaniem przychodów i zapewniać użytkownikom większą wygodę.

Pomożemy Ci skonfigurować powiadomienia dla deweloperów w czasie rzeczywistym (RTDN) i Laboratorium płatności w Google Play w przypadku subskrypcji i produktów kupowanych raz w aplikacjach i grach. Dowiesz się, jak zmniejszyć utratę subskrybentów, chronić się przed oszustwem i nadużyciami, testować przypadki skrajne, symulować i powtarzać potencjalne problemy oraz rozwiązywać je, a także eksperymentować z ofertami i zmianami cen bez wpływu na użytkowników.

Na koniec będziesz gotowy do wdrażania strategii przywracania użytkowników, szybkiego rozwiązywania problemów z integracją, zwiększania ROI, zapewniania najwyższej jakości usług oraz wdrażania aplikacji i aktualizacji z pewną ręką.

Wymagania wstępne

Czego się nauczysz

  • Jak prawidłowo zarządzać cyklem zakupu, aby optymalizować wzrost dzięki technikom zwiększania liczby konwersji polegających na zakupie i zatrzymywania klientów
  • Jak skonfigurować powiadomienia dla deweloperów w czasie rzeczywistym (RTDN) za pomocą Google Cloud Pub/Sub, które można następnie wykorzystać do wdrażania kampanii przywracających użytkowników i innych strategii zarządzania cyklem życia
  • Jak skonfigurować na serwerze zaplecza odbiornik, aby bezpiecznie obsługiwać powiadomienia z dokładnym śledzeniem i uprawnieniami w celu zmniejszenia ryzyka nieumyślnych zwrotów środków lub oszustw i nadużyć
  • Jak przetestować integrację i symulować błędy za pomocą Play Billing Lab, aby poprawić wrażenia użytkowników i obniżyć koszty rozwoju

Czego potrzebujesz

2. Strategie monetyzacji w przypadku subskrypcji i jednorazowych zakupów

Jeśli sprzedajesz produkty cyfrowe w aplikacji, skuteczna strategia monetyzacji musi uwzględniać cały proces, w tym zakupy jednorazowe i subskrypcje. Bezproblemowe wrażenia mogą zwiększyć gotowość do zakupu i zmniejszyć odsyłki.

Typowy proces zakupu w przypadku jednorazowego zakupu lub subskrypcji składa się z kilku etapów:

  1. Użytkownik przegląda produkty do kupienia.
  2. Uruchom proces zakupu, aby użytkownik mógł dokonać zakupu i zapłaty.
  3. Powiadomienie serwera o dokonanym zakupie
  4. Potwierdź zakup na swoim serwerze.
  5. Przekazać użytkownikowi treści.
  6. Potwierdź dostarczenie treści. W przypadku produktów konsumpcyjnych zużyj zakup w odpowiednim momencie, aby użytkownik mógł kupić produkt ponownie.

Integracja w aplikacji umożliwia uruchamianie procesów zakupu i zarządzanie tymi funkcjami, ale ważne jest, aby backend był zawsze aktualny pod względem uprawnień kupowanych przez użytkowników. Jest to ważne z punktu widzenia śledzenia zakupów i zarządzania innymi aspektami wrażeń użytkowników, takimi jak uprawnienia na różnych platformach.

Powiadomienia w czasie rzeczywistym dla deweloperów są świetnym sposobem na rozpoznawanie różnych etapów cyklu zakupu. Można ich używać zarówno jako narzędzia do śledzenia skuteczności w czasie rzeczywistym, jak i do stosowania strategii przywracania subskrybentów.

Przykład: użytkownik właśnie kupił nowy produkt lub nie dokonał płatności, więc subskrypcja weszła w okres karencji. Dzięki odpowiednim RTDN możesz w prawie czasie rzeczywistym wykryć, że stan użytkownika się zmienił, i odpowiednio zareagować, np. zachęcić go do większego zaangażowania w zakupiony produkt lub wysłać e-maila z przypomnieniem, aby zaktualizował dane do płatności i kontynuował subskrypcję.

RTDN to też świetny sposób na dodanie dodatkowych opcji sterowania po stronie serwera, które ułatwiają zarządzanie zakupami nawet wtedy, gdy klient użytkownika ma problemy. Załóżmy, że użytkownik dokonał zakupu i otrzymał potwierdzenie od Google, ale jego urządzenie straciło łączność z internetem, zanim urządzenie i aplikacja otrzymały powiadomienie o zakupach za pomocą listenera zakupów. W przypadku RTDN otrzymasz niezależne powiadomienie przez serwer, co pozwoli Ci rozpoznać zakup i przyznać użytkownikowi uprawnienia niezależnie od problemu z klientem, zapewniając niezawodny proces zakupu.

Więcej informacji o współczesnych typach RTDN znajdziesz tutaj. Każdy typ RTDN sygnalizuje inny stan zakupu. Ważne jest wdrożenie odpowiednich mechanizmów obsługi, aby zapewnić prawidłowe przetwarzanie zgodnie z potrzebami w przypadku Twoich zastosowań. W tym laboratorium kodu pokażemy Ci przykładowy kod, który na bezpiecznym serwerze backendu obsługuje wiadomość RTDN, w tym odbieranie wiadomości, weryfikowanie zakupu i przyznawanie uprawnień odpowiedniemu użytkownikowi, gdy użytkownik dokona zakupu w aplikacji. Następnie pokażemy Ci, jak skonfigurować RTDN w aplikacji.

3. Konfigurowanie powiadomień w czasie rzeczywistym dla deweloperów

Powiadomienia w czasie rzeczywistym dla deweloperów (RTDN) korzystają z usługi Google Cloud Pub/Sub, aby umożliwić Ci natychmiastową reakcję na zmiany stanu zakupu. Cloud Pub/Sub to w pełni zarządzana usługa do przesyłania wiadomości w czasie rzeczywistym, która umożliwia wysyłanie i odbieranie wiadomości między niezależnymi aplikacjami. Google Play używa Cloud Pub/Sub do publikowania powiadomień push na tematy, które subskrybujesz.

Aby włączyć RTDN, musisz najpierw skonfigurować Cloud Pub/Sub w ramach własnego projektu Google Cloud Platform (GCP), a potem włączyć powiadomienia w aplikacji. Jeśli nie znasz jeszcze GCP ani Cloud Pub/Sub, zapoznaj się z przewodnikiem wdrożeniowym.

Tworzenie tematu

Aby zacząć otrzymywać powiadomienia, musisz utworzyć temat, w którym Google Play będzie publikować powiadomienia. Aby utworzyć temat, postępuj zgodnie z instrukcjami podanymi w sekcji Tworzenie tematu.

Tworzenie subskrypcji Pub/Sub

Aby otrzymywać wiadomości publikowane w danym temacie, musisz utworzyć subskrypcję Pub/Sub dla tego tematu. Aby utworzyć subskrypcję Pub/Sub:

  1. Aby dowiedzieć się, jak skonfigurować subskrypcję jako subskrypcję push lub subskrypcję pull, przeczytaj przewodnik dla subskrybentów Cloud Pub/Sub. W tym laboratorium kodu będziemy pracować z subskrypcją pull, która wymaga, aby bezpieczny serwer backendowy inicjował żądania do serwera Cloud Pub/Sub w celu pobierania wiadomości.
  1. Aby utworzyć subskrypcję, wykonaj instrukcje opisane w sekcji Dodawanie subskrypcji.

Przyznawanie praw do publikowania informacji na temat Twojego tematu

Cloud Pub/Sub wymaga, aby przyznać Google Play uprawnienia do publikowania powiadomień w temacie.

  1. Otwórz konsolę Google Cloud.
  2. Wybierz projekt, a następnie na pasku wyszukiwania wyszukaj „Pub/Sub” i przejdź na stronę konfiguracji Pub/Sub. Przejdź na stronę konfiguracji Pub/Sub.
  3. Znajdź swój temat i otwórz ustawienia uprawnień. Otwórz ustawienia uprawnień.
  4. Kliknij DODAJ PODMIOT BEZPIECZEŃSTWA, aby dodać konto usługi google-play-developer-notifications@system.gserviceaccount.com i przypisać mu rolę Publikujący w Pub/Sub. Dodaj konto usługi google-play-developer-notifications@system.gserviceaccount.com i przypisz mu rolę publikującego w Pub/Sub.
  5. Aby zakończyć konfigurowanie tematu, kliknij Zapisz. Kliknij Zapisz, aby zakończyć konfigurowanie tematu.

Włączanie RTDN w aplikacji

Dowiedz się, jak skonfigurować powiadomienia dla deweloperów w czasie rzeczywistym, aby znacznie ulepszyć integrację z Płatnościami w Play. Możesz zwiększyć niezawodność zakupów dzięki spersonalizowanym wiadomościom, a także zapobiegać oszustwom i nadużyciom, aby zwiększyć ogólny zwrot z inwestycji.

RTDN zapewniają natychmiastowe aktualizacje na poziomie serwerów bezpośrednio z Google Play w przypadku kluczowych zdarzeń, takich jak odnowienia subskrypcji, nowe zakupy i problemy z płatnościami. Dzięki nim systemy backendowe mogą automatycznie synchronizować się z rzeczywistym stanem uprawnień użytkownika, co pozwala na ominięcie ograniczeń po stronie klienta i umożliwia natychmiastową reakcję.

Jak włączyć powiadomienia w czasie rzeczywistym dla deweloperów w przypadku aplikacji:

  1. Otwórz Konsolę Google Play.
  2. Wybierz swoją aplikację.
  3. Kliknij Zarabianie w Google Play > Konfiguracja zarabiania.
  4. Przewiń do sekcji Powiadomienia w czasie rzeczywistym dla deweloperów.
  5. Zaznacz pole Włącz powiadomienia w czasie rzeczywistym.
  6. W polu Nazwa tematu wpisz pełną nazwę tematu Cloud Pub/Sub skonfigurowaną wcześniej. Nazwa tematu powinna być w formacie projekty/{identyfikator_projektu}/tematy/{nazwa_tematu}, gdzie identyfikator_projektu to unikalny identyfikator projektu, a nazwa_tematu to nazwa utworzonego wcześniej tematu.
  7. Aby wysłać wiadomość testową, kliknij Wyślij wiadomość testową. Testowe opublikowanie pomaga sprawdzić, czy wszystko jest prawidłowo skonfigurowane. Jeśli testowe opublikowanie się powiedzie, wyświetli się komunikat o udanym testowym opublikowaniu. Jeśli masz subskrypcję tego tematu, powinna do Ciebie dotrzeć wiadomość testowa. W przypadku subskrypcji typu „pull” otwórz subskrypcję w Cloud Console, kliknij Wyświetl wiadomości i pobierz wiadomości. Aby uniknąć wielokrotnego dostarczania wiadomości przez Cloud Pub/Sub, należy potwierdzić każdą pobraną wiadomość. W przypadku subskrypcji powiadomień push sprawdź, czy wiadomość testowa została dostarczona do punktu końcowego powiadomień push. Kod odpowiedzi oznaczający powodzenie będzie służył jako wiadomość z potwierdzeniem. Jeśli publikacja się nie powiedzie, pojawi się komunikat o błędzie. Sprawdź, czy nazwa tematu jest prawidłowa i czy konto usługi google-play-developer-notifications@system.gserviceaccount.com ma dostęp do tematu jako Publikujący w Pub/Sub.
  8. Wybierz, jakiego typu powiadomienia chcesz otrzymywać.
  • Otrzymuj powiadomienia o subskrypcjach i wszystkich unieważnionych zakupach – otrzymuj powiadomienia w czasie rzeczywistym dla deweloperów dotyczące subskrypcji i unieważnionych zakupów. Nie będziesz otrzymywać powiadomień o produktach kupowanych raz.
  • Otrzymuj wszystkie powiadomienia o subskrypcjach i produktach kupowanych raz – otrzymuj powiadomienia o wszystkich zdarzeniach związanych z subskrypcją i unieważnionym zakupem. Otrzymasz też zdarzenia jednorazowego zakupu produktu, np. ONE_TIME_PRODUCT_PURCHASEDONE_TIME_PRODUCT_CANCELED. Więcej informacji o tych zdarzeniach zakupu znajdziesz w artykule Cykl życia jednorazowego zakupu.

a266e5dec5c93cd8.png

  1. Kliknij Zapisz zmiany.

W tym artykule znajdziesz informacje o tym, jak skonfigurować powiadomienia w czasie rzeczywistym dla deweloperów Twojej aplikacji. Dzięki nim będziesz mieć narzędzia do rozwiązywania typowych problemów, takich jak odchodzenie użytkowników, które możesz ograniczyć, wysyłając im wiadomości z zachętą do powrotu, czy oszustwa i nadużycia. W następnej sekcji utworzymy na bezpiecznym serwerze backendu subskrybenta, który będzie pobierać wiadomości wysyłane do tematu Cloud Pub/Sub.

4. otrzymywanie powiadomień;

Aby zapewnić użytkownikom jak najlepsze wrażenia w aplikacji, ważne jest, aby serwer backendu był zawsze aktualny pod względem stanu zakupów. Gdy na przykład użytkownik dokona zakupu w aplikacji, treści powinny zostać jak najszybciej dostarczone na jego konto.

Wymaga to wykrycia i terminowego przetworzenia zakupu. Biblioteka płatności w Play oferuje wiele sposobów wykrywania zakupów w aplikacji. Po wykryciu zrealizowanego zakupu aplikacja musi powiadomić serwer backendowy o weryfikacji zakupu, przyznaniu treści odpowiedniemu użytkownikowi i powiadomieniu Google o przetworzeniu zakupu. Może się jednak zdarzyć, że z różnych powodów Twoja aplikacja nie wykryła zakupu w odpowiednim czasie. Użytkownik może na przykład dokonać zakupu i otrzymać potwierdzenie od Google, ale jego urządzenie traci łączność z internetem, zanim urządzenie i Twoja aplikacja otrzymają powiadomienie w interfejsie Biblioteki płatności w Google Play. RTDN udostępnia dodatkowe opcje po stronie serwera, które ułatwiają zarządzanie zakupami nawet wtedy, gdy klient użytkownika ma problemy. RTDN gwarantuje niezależne powiadomienia na serwer po zmianie stanu zakupu, co pozwala rozpoznać zmiany stanu zakupu niemal natychmiast na drugim szlaku niezależnie od potencjalnych problemów klienta i zapewnia bardziej niezawodny proces zakupu.

W tej sekcji utworzysz subskrybenta, który będzie odbierał wiadomości wysyłane do tematu Cloud Pub/Sub za pomocą bibliotek klienta Cloud Pub/Sub. Te biblioteki są dostępne w różnych językach. W kolejnych sekcjach dodamy subskrybenta, aby zweryfikować zakup, przyznać uprawnienia prawidłowemu użytkownikowi i potwierdzić zakup na serwerze. W tym ćwiczeniu używamy Javy.

Każda publikacja w temacie Cloud Pub/Sub zawiera jedno pole danych zakodowane w formacie base64.

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

Po dekodowaniu pola danych zakodowanego w formacie Base64 pole DeveloperNotification zawiera te pola:

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

Więcej informacji znajdziesz w dokumentacji dotyczącej powiadomień dla deweloperów w czasie rzeczywistym.

Poniżej znajduje się przykładowy kod klasy NotificationReceiver, która umożliwia bezpiecznemu serwerowi zaplecza przetwarzanie wiadomości Pub/Sub. Aby uwierzytelniać się w Security Command Center, skonfiguruj domyślne poświadczenia aplikacji. W tym celu zapoznaj się z artykułem Konfigurowanie uwierzytelniania w lokalnym środowisku programistycznym.

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();
   }
 }
}

Teraz masz odbiornik powiadomień, który odbiera wiadomości wysyłane do tematu Cloud Pub/Sub na bezpiecznym serwerze zaplecza. W kolejnych sekcjach omówimy sprawdzone metody przetwarzania wiadomości RTDN na serwerze zaplecza.

5. Dołączanie identyfikatorów użytkowników w procesie zakupu w aplikacji

Gdy serwer otrzyma wiadomość RTDN o aktualizacji stanu zakupu, musi wiedzieć, który użytkownik dokonał zakupu, aby przetworzyć tę transakcję, np. dostarczyć treści odpowiedniemu użytkownikowi. Aby to zrobić, dołącz do zakupu dowolne identyfikatory użytkownika, który dokonał zakupu, używając obfuscatedAccountId podczas uruchamiania procesu zakupu w aplikacji. Przykładem identyfikatora może być zaciemniona wersja nazwy użytkownika w Twoim systemie. Ustawienie tego parametru może pomóc Google wykrywać oszustwa. Dodatkowo może Ci pomóc w przypisywaniu zakupów do właściwego użytkownika, zgodnie z informacjami zawartymi w artykule Przypisywanie uprawnień użytkownikom.

Poniżej znajdziesz przykładowe kody, które umożliwiają dołączenie identyfikatora użytkownika podczas uruchamiania procesu zakupu w aplikacji przez ustawienie parametru 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);

Jak zobaczysz w następnej sekcji, identyfikator użytkownika ustawiony w procesie zakupu będzie uwzględniony w transakcji i można go wykorzystać do przyznania uprawnień odpowiedniemu użytkownikowi.

6. Weryfikowanie zakupów przed przyznawaniem uprawnień

W tej sekcji omówimy sprawdzone metody weryfikacji zakupów przed przyznaniem uprawnień na bezpiecznym serwerze zaplecza.

Gdy użytkownik dokona jednorazowego zakupu produktu, subskrybent Pub/Sub na bezpiecznym serwerze zaplecza otrzyma wiadomość Pub/Sub. Na serwerze backendu wykonaj te czynności:

  1. Przeanalizuj element purchaseToken z wiadomości Pub/Sub. W przypadku wszystkich zakupów należy prowadzić rejestr wszystkich wartości purchaseToken.
  2. Sprawdź, czy wartość purchaseToken dla bieżącego zakupu nie jest taka sama jak żadna z poprzednich wartości purchaseToken. purchaseToken jest globalnie unikalny, więc możesz bezpiecznie używać tej wartości jako klucza podstawowego w bazie danych.
  3. Aby zweryfikować w Google, że zakup jest prawidłowy, użyj punktu końcowego purchases.products:get w interfejsie Google Play Developer API.
  1. Jeśli zakup jest uzasadniony i nie został wykorzystany w przeszłości, możesz bezpiecznie przyznać uprawnienia do zakupu w aplikacji lub subskrypcji.
  2. Uprawnienia należy przyznać tylko wtedy, gdy stan zakupu to PURCHASED, i należy poprawnie obsłużyć zakupy PENDING. Więcej informacji znajdziesz w artykule Zarządzanie transakcjami oczekującymi.

Podany niżej przykład kodu tworzy klienta interfejsu Google Play Developer API. Użyjemy go później do wywołania interfejsu API.

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);
   }
 }
}

Następnie dodajemy logikę, która umożliwia wywołanie interfejsu API, i modyfikujemy utworzonego wcześniej odbiornika, aby potwierdzić zakup i przyznać uprawnienia odpowiedniemu użytkownikowi.

AndroidPublisherHelper dodaj tę metodę, aby pobrać ProductPurchase z punktu końcowego Purchases.products:get w interfejsie Google Play Developer API.

 /* 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;
   }
 }

W NotificationMessageReceiver zweryfikuj zakup i przyznaj uprawnienia odpowiedniemu użytkownikowi w Twoim systemie na podstawie danych zawartych w powiadomieniu. Aby uniknąć przetwarzania zduplikowanych danych, na serwerze musisz śledzić parametr purchaseToken.

 @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. Poinformuj Google o przetworzeniu zakupu

Po przyznaniu uprawnień należy poinformować Google o przetworzeniu zakupu, wywołując punkty końcowe purchases.products:consume lub purchases.products:acknowledge w interfejsie Play Developer API z bezpiecznego serwera zaplecza, aby wykorzystać produkt jednorazowy lub potwierdzić produkt niejednorazowy.

AndroidPublisherHelper dodaj te metody, aby wywołać purchases.products:consume lub purchases.products:acknowledge w interfejsie Google Play Developer API.

 /* 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.
   }
 }

NotificationMessageReceiver: zużyj produkt konsumpcyjny lub potwierdź zakup produktu niekonsumpcyjnego po przyznaniu uprawnień na serwerze zaplecza.

 @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);
  ......

 }

Potwierdzenie jest wymagane, ponieważ informuje Google Play o tym, że użytkownik ma uprawnienia do zakupionych treści. Po przyznaniu uprawnień należy potwierdzić zakup.

Brawo! Udało Ci się zintegrować powiadomienia w czasie rzeczywistym dla deweloperów, co umożliwia niezawodne przetwarzanie zakupów, jak pokazano w tym ćwiczeniu z programowania. Aby mieć pewność, że wszystko działa prawidłowo, sprawdź narzędzie Play Billing Lab – przyjazne dla użytkownika narzędzie do testowania integracji z systemem płatności w Google Play.

8. Testowanie za pomocą Laboratorium płatności w Play

Aby mieć pewność, że wszystko działa prawidłowo, testuj integrację na każdym etapie rozwoju. Play Billing Lab to bezpłatna aplikacja na Androida, która pomaga deweloperom testować integrację z systemem rozliczeniowym Google Play. Zapewnia ona łatwy i wygodny sposób testowania funkcji Płatności w Google Play, szybszego przeprowadzania integracji i uruchomienia aplikacji z większym poczuciem pewności.

Play Billing Lab oferuje różne funkcje testowania, które ułatwiają testowanie różnych scenariuszy, m.in.:

Stale dodajemy do aplikacji Play Billing Lab nowe możliwości testowania. Możesz ją pobrać i zainstalować ze Sklepu Play lub dowiedzieć się więcej o testowaniu za pomocą Play Billing Lab, korzystając z artykułu Testowanie integracji.

Testowanie BillingResponseCode za pomocą Laboratorium płatności w Play

Podczas integracji aplikacji z Biblioteką płatności w Google Play często trudno jest przetestować wszystkie przepływy danych BillingResponseCode, ponieważ nie masz dużej kontroli nad komunikacją między Sklepem Play a systemem zaplecza Google Play. Funkcja Symulator odpowiedzi w aplikacji Play Billing Lab umożliwia konfigurowanie odpowiedzi na kody błędów w Bibliotece płatności w Play, aby testować różne złożone scenariusze błędów.

Na przykład w aplikacji została zaimplementowana logika, która po wykryciu udanego zakupu powoduje wykorzystanie zakupu. Chcesz przetestować scenariusz, w którym Twoja aplikacja nie może zrealizować zakupu z powodu awarii sieci, a odbiornik RTDN na serwerze zaplecza odbiera wiadomość i prawidłowo obsługuje zakup. Możesz użyć symulatora odpowiedzi, aby symulować scenariusz testowania. Poniżej znajdziesz instrukcje testowania za pomocą symulatora odpowiedzi Play Billing Lab.

Testowanie za pomocą symulatora odpowiedzi

Podczas testowania za pomocą symulatora odpowiedzi aplikacja będzie się komunikować z Laboratorium Płatności w Play, aby uzyskać kod odpowiedzi skonfigurowany w symulatorze odpowiedzi Laboratorium Płatności w Play.

Włącz testowanie zastępowania płatności w Bibliotece płatności w Play

Aby umożliwić komunikację między symulatorem odpowiedzi a aplikacją, musisz najpierw włączyć testowanie zastąpienia płatności w Bibliotece płatności w Google Play z poziomu aplikacji. W tym celu dodaj do pliku AndroidManifest.xml aplikacji te tagi metadanych.

<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>

Utwórz aplikację, korzystając z zaktualizowanego pliku AndroidManifest.xml. Twoja aplikacja jest teraz gotowa do użycia symulatora odpowiedzi w Laboratorium Płatności w Play.

Po zakończeniu testów, gdy wdrażasz aplikację w środowisku produkcyjnym, użyj osobnego pliku AndroidManifest.xml, który nie zawiera tych tagów metadanych, lub usuń te tagi z pliku AndroidManifest.xml.

Symulowanie błędów Biblioteki płatności w Play

Aby przetestować symulowane błędy Biblioteki płatności w Play, najpierw skonfiguruj kod odpowiedzi w aplikacji Play Billing Lab, a potem przeprowadź test w swojej aplikacji.

Konfigurowanie kodu odpowiedzi

  1. Zaloguj się w aplikacji Laboratorium Płatności w Play za pomocą konta testującego dla swojej aplikacji. Na poniższym obrazku widać panel Laboratorium Płatności w Play,w tym kartę Symulator odpowiedzi.

Panel rozliczeń w Laboratorium płatności w Play z Symulatorem odpowiedzi

  1. Na karcie Symulator odpowiedzi kliknij Zarządzaj, aby przejść do ekranu Symulator odpowiedzi.
  2. Gdy pojawi się odpowiedni komunikat, zezwól na powiadomienia z Laboratorium Płatności w Play, aby sprawdzić stan połączenia aplikacji.
  3. Włącz przełącznik Symuluj odpowiedź Biblioteki płatności w Play, jeśli nie jest jeszcze włączony.

c841baa4c96bf306.png

  1. Wybierz kod odpowiedzi interfejsu API Biblioteki płatności Google Play, który chcesz przetestować. Aby symulować błąd w przypadku zakupu, wybierz kod błędu dla interfejsu API consumeAsync. Wybrane opcje są zapisywane automatycznie. Teraz symulator odpowiedzi jest gotowy do wysłania wybranych kodów odpowiedzi do Twojej aplikacji.

Testowanie aplikacji

Teraz możesz przetestować aplikację, aby sprawdzić, czy wszystko działa zgodnie z oczekiwaniami w skonfigurowanym scenariuszu błędu. Otwórz aplikację i wywołaj metodę interfejsu Play Billing Library API. Jeśli aplikacja wykona wywołanie consumeAsync, aby wykorzystać zakup, otrzyma kod błędu zgodnie z niedawno skonfigurowanymi ustawieniami. Po otrzymaniu kodu błędu możesz sprawdzić, czy aplikacja działa prawidłowo, i czy serwer backenda prawidłowo przetwarza zakup.

Po zakończeniu testowania wyłącz przełącznik Symuluj odpowiedź Biblioteki płatności w Play, aby przestać symulować odpowiedź.

Dowiedz się więcej o testowaniu za pomocą Laboratorium Płatności w Google Play lub odwiedź Centrum pomocy, aby dowiedzieć się więcej o testowaniu rozliczeń w aplikacji za pomocą testerów licencji.

9. Gratulacje!

Po ukończeniu tego ćwiczenia będziesz wiedzieć, jak strategicznie optymalizować zarabianie w aplikacji, aby zwiększyć wygodę użytkowników i poprawić ich zadowolenie, liczbę konwersji polegających na zakupie oraz zmniejszyć utratę subskrybentów.

Dzięki powiadomieniom w czasie rzeczywistym dla deweloperów i aplikacji towarzyszącej Play Billing Lab możesz aktywnie reagować na zdarzenia związane z cyklem życia zakupu zarówno w przypadku jednorazowych zakupów, jak i subskrypcji.

Dzięki tym narzędziom możesz skutecznie wdrażać atrakcyjne strategie przywracania użytkowników, szybko rozwiązywać problemy związane z integracją i w podstawowym zakresie zwiększać wygodę użytkowników oraz strumienie przychodów, aby móc pewnie wprowadzić na rynek aplikację lub grę.

Po ukończeniu tego ćwiczenia będziesz mieć umiejętności potrzebne do zarządzania całą ścieżką zakupu i dokładnego testowania implementacji za pomocą Play Billing Lab. Dzięki temu zapewnisz płynne wrażenia użytkownika i zmaksymalizujesz potencjał generowania przychodów w Google Play.