Maksymalizowanie integracji z płatnościami w Google Play

1. Przegląd

Zoptymalizuj źródła przychodów i wprowadź aplikację na rynek bez obaw dzięki temu laboratorium programowania dotyczącemu integracji Biblioteki płatności w Play w Google Play. Ten uporządkowany samouczek przeprowadzi Cię przez proces konfigurowania, testowania i wdrażania niezawodnego przetwarzania płatności, co pomoże Ci osiągnąć cele związane z zarabianiem i zapewnić użytkownikom większą wygodę.

Pomożemy Ci skonfigurować powiadomienia w czasie rzeczywistym dla deweloperów (RTDN) i Play Billing Lab w przypadku subskrypcji i produktów kupowanych raz w Twoich aplikacjach i grach. Dowiesz się, jak ograniczyć rezygnacje z subskrypcji, chronić się przed oszustwami i nadużyciami, testować przypadki brzegowe, symulować, odtwarzać i rozwiązywać potencjalne problemy oraz eksperymentować z ofertami i zmianami cen bez wpływu na użytkowników.

Na koniec będziesz mieć gotowość do wdrażania strategii odzyskiwania klientów, szybkiego rozwiązywania problemów z integracją, zwiększania zwrotu z inwestycji, zapewniania najwyższej jakości obsługi oraz pewnego wdrażania aplikacji i aktualizacji.

Wymagania wstępne

Znajomość podstawowej integracji z Biblioteką płatności w Play
znajomość programowania aplikacji na Androida (Java);

Czego się nauczysz

Jak prawidłowo zarządzać cyklami życia zakupu, aby optymalizować wzrost za pomocą technik zwiększających liczbę konwersji polegających na zakupie i utrzymanie 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 zachęcających do powrotu i innych strategii zarządzania cyklem życia
Jak skonfigurować odbiornik na serwerze backendu, aby bezpiecznie obsługiwać powiadomienia z dokładnym śledzeniem i uprawnieniami, co pozwoli zmniejszyć ryzyko niezamierzonych zwrotów środków oraz oszustw i nadużyć
Jak testować integrację i symulować błędy za pomocą aplikacji Play Billing Lab, aby zwiększyć wygodę użytkowników i obniżyć koszty programowania

Czego potrzebujesz

Dostęp do konta dewelopera Google Play w Konsoli Google Play w przypadku Twojej aplikacji.
Dostęp do projektu Google Cloud Platform z włączonym interfejsem Google Play Developer API
serwer backendu do obsługi kont i uprawnień w aplikacji na Androida;
Testerzy licencji zarejestrowani w Konsoli Play w przypadku Twojej aplikacji.
aplikacja Play Billing Lab zainstalowana na urządzeniu testowym;

2. Strategie zarabiania na subskrypcjach i zakupach jednorazowych

Jeśli sprzedajesz produkty cyfrowe w aplikacji, skuteczna strategia monetyzacji musi uwzględniać całe doświadczenie użytkownika, zarówno w przypadku zakupów jednorazowych, jak i subskrypcji. Płynne działanie może zwiększyć gotowość do zakupu i zmniejszyć rezygnację.

Typowy proces zakupu jednorazowego zakupu lub subskrypcji obejmuje kilka etapów:

Użytkownik przegląda produkty, które chce kupić.
Uruchom proces zakupu, aby użytkownik mógł dokończyć zakup i płatność.
Powiadamianie serwera o zakończonym zakupie
Zweryfikuj zakup na serwerze.
Przekaż użytkownikowi treści.
Potwierdź dostarczenie treści. W przypadku produktów konsumpcyjnych wykorzystaj zakup w odpowiednim momencie, aby użytkownik mógł ponownie kupić produkt.

Integracja w aplikacji umożliwia uruchamianie procesów zakupu i zarządzanie wygodą użytkowników, ale ważne jest, aby backend był na bieżąco informowany o uprawnieniach kupowanych przez użytkowników. Jest to ważne w przypadku śledzenia zakupów i zarządzania innymi aspektami związanymi z wrażeniami użytkownika, takimi jak uprawnienia na wielu platformach.

Powiadomienia w czasie rzeczywistym dla deweloperów to świetny sposób na rozpoznawanie różnych etapów cyklu życia zakupu. Można ich skutecznie używać zarówno jako narzędzia do śledzenia skuteczności w czasie rzeczywistym, jak i do wdrażania strategii odzyskiwania 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 prolongaty. Dzięki odpowiedniemu RTDN możesz w czasie zbliżonym do rzeczywistego rozpoznać, że stan użytkownika się zmienił, i odpowiednio zareagować, np. zwiększając zaangażowanie użytkownika w zakupiony właśnie produkt lub wysyłając mu e-maile z przypomnieniem o zaktualizowaniu danych do płatności, aby mógł kontynuować subskrypcję.

RTDN to też świetny sposób na dodanie dodatkowych elementów sterujących po stronie serwera, które pomogą Ci zarządzać 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 utraciło połączenie sieciowe, zanim urządzenie i aplikacja otrzymały powiadomienie o zakupie za pomocą detektora zakupu. Dzięki RTDN otrzymasz niezależne powiadomienie za pośrednictwem serwera, 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 wszystkich typach RTDN, które są obecnie obsługiwane, znajdziesz tutaj. Każdy typ sygnału RTDN wskazuje inny stan zakupu. Aby zapewnić prawidłowe przetwarzanie w przypadkach użycia, konieczne jest wdrożenie odpowiednich mechanizmów obsługi. W tym samouczku znajdziesz przykład obsługi wiadomości RTDN na bezpiecznym serwerze backendu, w tym odbierania wiadomości, weryfikowania zakupu i przyznawania uprawnień odpowiedniemu użytkownikowi, gdy użytkownik dokona zakupu w aplikacji. Następnie pokażemy, jak skonfigurować RTDN w aplikacji.

3. Konfigurowanie powiadomień w czasie rzeczywistym dla deweloperów (RTDN)

Powiadomienia w czasie rzeczywistym dla deweloperów korzystają z usługi Google Cloud Pub/Sub, dzięki czemu możesz natychmiast reagować na zmiany stanu zakupu. Cloud Pub/Sub to usługa w pełni zarządzana 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 w tematach, które subskrybujesz.

Aby włączyć RTDN, musisz najpierw skonfigurować Cloud Pub/Sub za pomocą własnego projektu Google Cloud Platform (GCP), a następnie włączyć powiadomienia w aplikacji. Jeśli nie znasz GCP i Cloud Pub/Sub, zapoznaj się z przewodnikiem Szybki start.

Tworzenie tematu

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

Tworzenie subskrypcji Pub/Sub

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

Zapoznaj się z przewodnikiem po subskrybentach Cloud Pub/Sub, aby dowiedzieć się, jak skonfigurować subskrypcję jako subskrypcję push lub subskrypcję pull. W tym module nauczysz się korzystać z subskrypcji typu pull, która wymaga, aby bezpieczny serwer backendu inicjował żądania do serwera Cloud Pub/Sub w celu pobrania wiadomości.

Aby utworzyć subskrypcję, postępuj zgodnie z instrukcjami w artykule Dodawanie subskrypcji.

Przyznawanie praw do publikowania w temacie

Cloud Pub/Sub wymaga przyznania Google Play uprawnień do publikowania powiadomień w Twoim temacie.

Otwórz konsolę Google Cloud.
Wybierz projekt, a następnie na pasku wyszukiwania wpisz „Pub/Sub” i otwórz stronę konfiguracji Pub/Sub.
Znajdź temat i otwórz ustawienie uprawnień.
Kliknij DODAJ PODMIOT ZABEZPIECZEŃ, aby dodać konto usługi google-play-developer-notifications@system.gserviceaccount.com i przypisać mu rolę publikującego w Pub/Sub.
Aby zakończyć konfigurację zestawu tematów, kliknij Zapisz.

Włączanie RTDN w aplikacji

Dowiedz się, jak skonfigurować powiadomienia w czasie rzeczywistym dla deweloperów (RTDN), 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 poprawić ogólny zwrot z inwestycji.

RTDN zapewniają natychmiastowe aktualizacje typu serwer-serwer bezpośrednio z Google Play w przypadku kluczowych zdarzeń, takich jak odnowienia subskrypcji, nowe zakupy i problemy z płatnościami. Pomagają one systemom backendu automatycznie synchronizować się z rzeczywistym stanem uprawnień użytkowników, wykraczając poza ograniczenia po stronie klienta i umożliwiając natychmiastowe i odpowiednie reagowanie.

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

Otwórz Konsolę Google Play.
Wybierz swoją aplikację.
Kliknij Zarabianie w Google Play > Konfiguracja ustawień zarabiania.
Przewiń do sekcji Powiadomienia w czasie rzeczywistym dla deweloperów.
Zaznacz Włącz powiadomienia w czasie rzeczywistym.
W polu Nazwa tematu wpisz pełną nazwę tematu Cloud Pub/Sub, którą skonfigurowano wcześniej. Nazwa tematu powinna mieć format projects/{project_id}/topics/{topic_name}, gdzie project_id to unikalny identyfikator projektu, a topic_name to nazwa tematu utworzonego wcześniej.
Aby wysłać wiadomość testową, kliknij Wyślij wiadomość testową. Przeprowadzenie publikacji testowej pomaga upewnić się, że wszystko jest prawidłowo skonfigurowane. Jeśli testowe opublikowanie się powiedzie, pojawi się komunikat informujący o tym, że testowe opublikowanie zostało zakończone. Jeśli masz subskrypcję tego tematu, powinna do Ciebie dotrzeć wiadomość testowa. W przypadku subskrypcji typu pull otwórz subskrypcję w konsoli Cloud, kliknij Wyświetl wiadomości i pobierz wiadomości. Każdą pobraną wiadomość należy potwierdzić, aby uniknąć jej ponownego dostarczenia przez Cloud Pub/Sub. W przypadku subskrypcji push sprawdź, czy wiadomość testowa została dostarczona do punktu końcowego push. Kod odpowiedzi oznaczający powodzenie będzie służyć jako komunikat potwierdzający. Jeśli publikacja się nie powiedzie, pojawi się błąd. Sprawdź, czy nazwa tematu jest prawidłowa i czy konto usługi google-play-developer-notifications@system.gserviceaccount.com ma dostęp Publikujący w Pub/Sub do tematu.
Wybierz typy powiadomień, które 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 zakupach produktów kupowanych raz.
Otrzymuj wszystkie powiadomienia o subskrypcjach i produktach kupowanych raz – otrzymuj powiadomienia o wszystkich subskrypcjach i unieważnionych zakupach. Otrzymasz też zdarzenia związane z zakupem produktów kupowanych raz, takie jak ONE_TIME_PRODUCT_PURCHASED i ONE_TIME_PRODUCT_CANCELED. Więcej informacji o tych zdarzeniach zakupu znajdziesz w artykule Cykl życia zakupu jednorazowego.

Kliknij Zapisz zmiany.

W ten sposób zakończysz konfigurowanie powiadomień w czasie rzeczywistym dla deweloperów w swojej aplikacji. Dzięki temu będziesz mieć narzędzia do rozwiązywania typowych problemów, takich jak utrata użytkowników (możesz wysyłać im wiadomości zachęcające do powrotu) czy oszustwa i nadużycia. W następnej sekcji utworzymy subskrybenta na bezpiecznym serwerze backendu, 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, musisz dbać o to, aby serwer backendu był na bieżąco informowany o stanie zakupów. Jeśli na przykład użytkownik dokona zakupu za pomocą płatności w aplikacji, powinien jak najszybciej otrzymać treści na swoje konto.

Wymaga to wykrycia i szybkiego przetworzenia zakupu. Biblioteka płatności w Play udostępnia kilka sposobów wykrywania zakupów w aplikacji. Po wykryciu zakończonego zakupu aplikacja musi powiadomić serwer backendu, aby zweryfikować zakup, przyznać treści odpowiedniemu użytkownikowi, a następnie powiadomić Google o przetworzeniu zakupu. Może się jednak zdarzyć, że aplikacja nie wykryje zakupu w odpowiednim czasie z różnych powodów. Na przykład użytkownik może dokonać zakupu i otrzymać potwierdzenie od Google, ale urządzenie utraci połączenie z siecią, zanim urządzenie i aplikacja otrzymają powiadomienie przez interfejs Biblioteki płatności w Play. RTDN zapewnia dodatkowe opcje sterowania po stronie serwera, które pomagają zarządzać zakupami nawet wtedy, gdy klient użytkownika ma problemy. RTDN gwarantuje niezależne powiadomienia na serwerze o zmianach stanu zakupu, dzięki czemu możesz niemal natychmiast rozpoznawać zmiany stanu zakupu za pomocą drugiej ścieżki niezależnej od potencjalnych problemów klienta, co 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. Biblioteki te są dostępne w wielu językach. W kolejnych sekcjach dodamy do subskrybenta funkcję weryfikacji zakupu, przyznawania uprawnień odpowiedniemu użytkownikowi oraz potwierdzania i wykorzystywania zakupu 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 zdekodowaniu 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 powiadomieniach w czasie rzeczywistym dla deweloperów.

Poniżej znajdziesz przykładowy kod NotificationReceiver, który umożliwia bezpiecznemu serwerowi backendu przetwarzanie wiadomości Pub/Sub. Aby uwierzytelnić się w Security Command Center, skonfiguruj domyślne uwierzytelnianie aplikacji. Więcej informacji znajdziesz w artykule 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();
   }
 }
}

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

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 ją przetworzyć, np. dostarczyć treści do właściwego użytkownika. Możesz to zrobić, dołączając do użytkownika dokonującego zakupu dowolne identyfikatory użytkownika za pomocą parametru obfuscatedAccountId podczas uruchamiania procesu zakupu w aplikacji. Przykładem identyfikatora może być zaciemniona wersja loginu użytkownika w Twoim systemie. Ustawienie tego parametru może pomóc Google w wykrywaniu oszustw. Może też pomóc w przypisywaniu zakupów do odpowiednich użytkowników, jak opisano w sekcji przyznawanie uprawnień użytkownikom.

Poniżej znajdziesz przykładowe kody dołączania 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 zostanie uwzględniony w zakupie i może być używany do przyznawania uprawnień odpowiedniemu użytkownikowi.

6. Weryfikowanie zakupów przed przyznaniem uprawnień

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

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

Przeanalizuj purchaseToken z wiadomości Pub/Sub. Powinieneś prowadzić rejestr wszystkich wartości purchaseToken dla wszystkich zakupów.
Sprawdź, czy purchaseToken w przypadku bieżącego zakupu nie pasuje do żadnej z poprzednich wartości purchaseToken. purchaseToken jest niepowtarzalny na całym świecie, więc możesz bezpiecznie używać tej wartości jako klucza podstawowego w bazie danych.
Użyj punktu końcowego purchases.products:get w interfejsie Google Play Developer API, aby zweryfikować z Google, że zakup jest legalny.

Jeśli zakup jest zgodny z prawem i nie był wcześniej używany, możesz bezpiecznie przyznać uprawnienia do produktu w aplikacji lub subskrypcji.
Uprawnienia należy przyznawać tylko wtedy, gdy stan zakupu to PURCHASED, i upewnić się, że zakupy PENDING są obsługiwane prawidłowo. Więcej informacji znajdziesz w artykule Obsługa transakcji oczekujących.

Poniższy przykład kodu tworzy klienta interfejsu Google Play Developer API. Będzie on potrzebny później do wykonywania wywołań 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 dodamy logikę, która umożliwi wywołanie interfejsu API i zmodyfikujemy utworzony wcześniej odbiornik, aby zweryfikować zakup i przyznać uprawnienia odpowiedniemu użytkownikowi.

W 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 sprawdź zakup i przyznaj uprawnienia odpowiedniemu użytkownikowi w swoim systemie na podstawie danych zawartych w powiadomieniu. Aby uniknąć duplikowania przetwarzania, śledź parametr purchaseToken na serwerze.

 @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. Powiadamianie Google o zrealizowaniu zakupu

Po przyznaniu uprawnień powiadom Google, że zakup został przetworzony, wywołując punkty końcowe purchases.products:consume lub purchases.products:acknowledge w interfejsie Play Developer API z bezpiecznego serwera backendu, aby skonsumować produkt jednorazowy lub potwierdzić produkt niejednorazowy.

W 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.
   }
 }

W NotificationMessageReceiver wykorzystaj zakup produktu konsumpcyjnego lub potwierdź zakup produktu niekonsumpcyjnego po przyznaniu uprawnień na serwerze backendu.

 @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, że użytkownik ma uprawnienia do zakupionych treści. Potwierdzenie zakupu powinno nastąpić od razu po przyznaniu uprawnień.

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 upewnić się, że wszystko działa prawidłowo, przyjrzyjmy się aplikacji Play Billing Lab, czyli prostemu narzędziu, które pomoże Ci przetestować integrację z Płatnościami w Play.

8. Testowanie za pomocą aplikacji Play Billing Lab

Aby mieć pewność, że integracja działa prawidłowo, testuj ją na każdym etapie tworzenia. Play Billing Lab to bezpłatna aplikacja na Androida, która pomaga deweloperom testować integrację z systemem Płatności w Play. Umożliwia ona łatwe i wygodne testowanie funkcji Płatności w Play, szybszą integrację i wprowadzanie aplikacji na rynek z większym poczuciem pewności.

Play Billing Lab oferuje różne funkcje testowania, które pomagają testować różne scenariusze, w tym:

Zmień kraj w Google Play w aplikacji Play Billing Lab i zastosuj ustawienia do testu. Umożliwia to testowanie niestandardowych funkcji w różnych krajach lub regionach niezależnie od tego, gdzie tester przeprowadza testy.
wielokrotne testowanie okresów próbnych lub ofert dla nowych użytkowników na tym samym koncie;
Testowanie zmian cen subskrypcji bez wpływu na innych aktywnych subskrybentów
Symulowanie kodu odpowiedzi Biblioteki płatności w Play w celu testowania w różnych scenariuszach błędów.
Przyspiesz odnawianie subskrypcji, aby przyspieszyć testowanie.
Testowanie rzeczywistych form płatności w celu pominięcia niektórych sygnałów ryzyka w procesie zakupu.

Stale dodajemy do aplikacji Play Billing Lab nowe funkcje testowania. Możesz pobrać i zainstalować Play Billing Lab ze Sklepu Play. Więcej informacji o testowaniu za pomocą tej aplikacji znajdziesz w artykule Testowanie integracji.

Testowanie kodu BillingResponseCode za pomocą Play Billing Lab

Testowanie wszystkich przepływów BillingResponseCode podczas integrowania aplikacji z Biblioteką płatności w Google Play jest trudne, ponieważ nie masz dużej kontroli nad komunikacją między Sklepem Play a backendem Google Play. Funkcja Symulator odpowiedzi w aplikacji Play Billing Lab umożliwia konfigurowanie kodów błędów zwracanych przez Bibliotekę płatności w Play, aby testować różne złożone scenariusze błędów.

Na przykład w aplikacji zaimplementowano logikę, która po wykryciu udanego zakupu zużywa go. Chcesz przetestować scenariusz, w którym aplikacja nie może skonsumować zakupu z powodu awarii sieci, a odbiornik RTDN na serwerze backendu odbiera wiadomość i prawidłowo obsługuje zakup. Aby zasymulować scenariusz na potrzeby testów, możesz użyć symulatora odpowiedzi. 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 komunikować się z aplikacją Play Billing Lab, aby uzyskać kod odpowiedzi skonfigurowany w symulatorze odpowiedzi Play Billing Lab.

Włączanie testowania zastąpień płatności w Bibliotece płatności w Play

Aby umożliwić komunikację między symulatorem odpowiedzi a aplikacją, musisz najpierw włączyć w aplikacji testowanie zastąpień rozliczeń w Bibliotece płatności w Play. Aby to zrobić, 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 ze zaktualizowanego pliku AndroidManifest.xml. Aplikacja jest teraz gotowa do użycia z symulatorem odpowiedzi w Laboratorium Płatności w Play.

Gdy po testach wdrożysz 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

Zaloguj się w aplikacji Play Billing Lab za pomocą konta testera licencji dla swojej aplikacji. Na ilustracji poniżej widać panel aplikacji Play Billing Lab,w tym kartę Symulator odpowiedzi.

Panel Laboratorium Płatności w Play z symulatorem odpowiedzi

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

Wybierz kod odpowiedzi interfejsów API Biblioteki płatności w Play, który chcesz przetestować. Aby zasymulować błąd w przypadku zakupu, wybierz kod błędu dla interfejsu consumeAsync. Wybrane opcje zostaną zapisane automatycznie. Symulator odpowiedzi jest teraz gotowy do wysłania wybranych kodów odpowiedzi do Twojej aplikacji.

Testowanie aplikacji

Teraz możesz przetestować aplikację, aby sprawdzić, czy w skonfigurowanym scenariuszu błędu wszystko działa zgodnie z oczekiwaniami. Otwórz aplikację i wywołaj metodę interfejsu Play Billing Library API. Jeśli aplikacja wywoła funkcję consumeAsync w celu wykorzystania zakupu, otrzyma kod błędu zgodnie z konfiguracją. Możesz sprawdzić, czy aplikacja działa prawidłowo, na podstawie kodu błędu i czy serwer backendu prawidłowo przetwarza zakup.

Po zakończeniu testowania wyłącz symulowanie odpowiedzi w Bibliotece płatności w Play, aby zatrzymać symulację.

Dowiedz się więcej o testowaniu za pomocą Play Billing Lab lub odwiedź Centrum pomocy, aby uzyskać więcej informacji o testowaniu rozliczeń w aplikacji za pomocą testerów licencji.

9. Gratulacje!

To już koniec tego laboratorium. Masz teraz wiedzę, która pozwoli Ci strategicznie optymalizować zarabianie na aplikacji, aby zwiększać komfort użytkowników i poprawiać ich zadowolenie, liczbę konwersji polegających na zakupie i odpływ subskrybentów.

Korzystając z powiadomień w czasie rzeczywistym dla deweloperów i aplikacji towarzyszącej Play Billing Lab, możesz proaktywnie reagować na zdarzenia związane z cyklem życia zakupu w przypadku zakupów jednorazowych i subskrypcji.

Dzięki tym narzędziom możesz skutecznie wdrażać angażujące strategie odzyskiwania użytkowników, szybko rozwiązywać problemy z integracją, a w rezultacie poprawiać wrażenia użytkowników i zwiększać strumienie przychodów, aby z pewnością wprowadzić na rynek aplikację lub grę.

Po ukończeniu tego samouczka masz już umiejętności zarządzania całym procesem zakupu i dokładnego testowania implementacji w Play Billing Lab. Dzięki temu możesz zapewnić użytkownikom bezproblemowe korzystanie z aplikacji i maksymalizować potencjał zarobkowy w Google Play.