Integrowanie Biblioteki płatności w Google Play z aplikacją

Z tego artykułu dowiesz się, jak zintegrować Bibliotekę płatności w Google Play aplikacji, aby zacząć sprzedawać produkty.

Cykl zakupu

Poniżej przedstawiamy typowy proces zakupu w przypadku zakupu jednorazowego lub subskrypcji.

1. Pokaż użytkownikowi, co może kupić.
2. Uruchom proces zakupu, aby użytkownik mógł go zaakceptować.
3. Zweryfikuj zakup na serwerze.
4. Udostępnij treści użytkownikowi.
5. Potwierdź przesłanie treści. W przypadku produktów zużywalnych zakupu, aby użytkownik mógł ponownie kupić produkt.

Subskrypcje odnawiają się automatycznie, dopóki nie zostaną anulowane. Subskrypcję można przez te stany:

• Aktywny:użytkownik ma dobrą opinię i ma dostęp do subskrypcji.
• Anulowano: użytkownik anulował dostęp, ale nadal ma dostęp do konta do wygaśnięcia.
• W okresie prolongaty:użytkownik napotkał problem z płatnością, ale nadal ma dostęp gdy Google próbuje ponownie użyć formy płatności.
• Wstrzymano: użytkownik napotkał problem z płatnością i nie ma już dostępu do konta Próbujemy ponownie użyć formy płatności.
• Wstrzymany: użytkownik wstrzymał swój dostęp i nie ma do niego dostępu, dopóki nie do swojego życiorysu zawodowego.
• Wygasła: użytkownik anulował subskrypcję i utracił do niej dostęp. w momencie wygaśnięcia dostępu do danych użytkownika zostanie uznany za rezygnowanego.

Inicjowanie połączenia z Google Play

Aby przeprowadzić integrację z systemem rozliczeniowym Google Play, najpierw dodaj z Biblioteką płatności w Google Play w aplikacji i zainicjować połączenie.

Dodaj zależność Biblioteki płatności w Google Play

Dodaj zależność Biblioteki płatności w Google Play do jej identyfikatora build.gradle jak pokazano poniżej:

dependencies {
    def billing_version = "7.0.0"

    implementation "com.android.billingclient:billing:$billing_version"
}

dependencies {
    val billing_version = "7.0.0"

    implementation("com.android.billingclient:billing:$billing_version")
}

Jeśli korzystasz z Kotlin, moduł KTX Biblioteki płatności w Google Play zawiera Obsługa rozszerzeń i współdziałań Kotlin, która umożliwia pisanie idiomatyczne Kotlin podczas korzystania z Biblioteki płatności w Google Play. Uwzględnianie tych wartości rozszerzeń w projekcie, dodaj tę zależność do build.gradle plik jak pokazano:

dependencies {
    def billing_version = "7.0.0"

    implementation "com.android.billingclient:billing-ktx:$billing_version"
}

dependencies {
    val billing_version = "7.0.0"

    implementation("com.android.billingclient:billing-ktx:$billing_version")
}

Inicjowanie klienta rozliczeniowego

Po dodaniu zależności od Biblioteki płatności w Google Play musisz aby zainicjować instancję BillingClient. BillingClient jest głównym elementem do komunikacji między Biblioteką płatności w Google Play a usługą reszta aplikacji. BillingClient zapewnia wygodne metody, obie synchroniczne i asynchronicznych na potrzeby wielu typowych operacji rozliczeniowych. Zdecydowanie zalecamy mieć jedno aktywne połączenie BillingClient otwarte w danym momencie, unikaj wielu wywołań zwrotnych PurchasesUpdatedListener dla jednego zdarzenia.

Aby utworzyć BillingClient, użyj newBuilder(). Możesz przekazać dowolny kontekst, do newBuilder(), a BillingClient używa go do uzyskania kontekstu aplikacji. Dzięki temu nie musisz się martwić o wycieki pamięci. Aby otrzymywać aktualizacje na temat: zakupów, musisz też wywołać setListener(), przekazując odniesienie do PurchasesUpdatedListener Ten odbiornik otrzymuje aktualizacje dotyczące wszystkich zakupów w aplikacji.

private val purchasesUpdatedListener =
   PurchasesUpdatedListener { billingResult, purchases ->
       // To be implemented in a later section.
   }

private var billingClient = BillingClient.newBuilder(context)
   .setListener(purchasesUpdatedListener)
   // Configure other settings.
   .build()

private PurchasesUpdatedListener purchasesUpdatedListener = new PurchasesUpdatedListener() {
    @Override
    public void onPurchasesUpdated(BillingResult billingResult, List<Purchase> purchases) {
        // To be implemented in a later section.
    }
};

private BillingClient billingClient = BillingClient.newBuilder(context)
    .setListener(purchasesUpdatedListener)
    // Configure other settings.
    .build();

Połącz z Google Play

Po utworzeniu BillingClient musisz nawiązać połączenie z Google Play.

Aby połączyć się z Google Play, zadzwoń pod numer startConnection(). Połączenie proces jest asynchroniczny i musisz zaimplementować tag BillingClientStateListener, aby otrzymać oddzwonienie po skonfigurowaniu został zakończony i jest gotowy do przesyłania kolejnych żądań.

Musisz też wdrożyć mechanizm ponawiania prób w celu obsługi utraconych połączeń z Google Play. Aby wdrożyć logikę ponawiania prób, zastąp onBillingServiceDisconnected() i upewnij się, że BillingClient wywołuje metodę Metodę startConnection(), aby ponownie połączyć się z Google Play przed kolejnych próśb.

Poniższy przykład pokazuje, jak rozpocząć połączenie i sprawdzić, czy jest gotowe do użycia:

billingClient.startConnection(object : BillingClientStateListener {
    override fun onBillingSetupFinished(billingResult: BillingResult) {
        if (billingResult.responseCode ==  BillingResponseCode.OK) {
            // The BillingClient is ready. You can query purchases here.
        }
    }
    override fun onBillingServiceDisconnected() {
        // Try to restart the connection on the next request to
        // Google Play by calling the startConnection() method.
    }
})

billingClient.startConnection(new BillingClientStateListener() {
    @Override
    public void onBillingSetupFinished(BillingResult billingResult) {
        if (billingResult.getResponseCode() ==  BillingResponseCode.OK) {
            // The BillingClient is ready. You can query purchases here.
        }
    }
    @Override
    public void onBillingServiceDisconnected() {
        // Try to restart the connection on the next request to
        // Google Play by calling the startConnection() method.
    }
});

Pokaż produkty dostępne do kupienia

Po nawiązaniu połączenia z Google Play możesz wykonywać zapytania. Twoich dostępnych produktów i wyświetlać je użytkownikom.

Zapytanie o szczegóły produktu jest ważnym krokiem przed wyświetleniem produktów, ponieważ zwraca zlokalizowane informacje o nich. Dla: upewnij się, że Twoje produkty są zgodne ze wszystkimi zasadami Google Play.

Aby wysłać zapytanie o szczegóły produktu w aplikacji, zadzwoń pod numer queryProductDetailsAsync().

Aby obsługiwać wynik operacji asynchronicznej, musisz także określić detektor implementujący interfejs ProductDetailsResponseListener. Możesz wtedy zastąpić parametr onProductDetailsResponse(), aby wysyłać powiadomienia detektor po zakończeniu zapytania, jak w tym przykładzie:

val queryProductDetailsParams =
    QueryProductDetailsParams.newBuilder()
        .setProductList(
            ImmutableList.of(
                Product.newBuilder()
                    .setProductId("product_id_example")
                    .setProductType(ProductType.SUBS)
                    .build()))
        .build()

billingClient.queryProductDetailsAsync(queryProductDetailsParams) {
    billingResult,
    productDetailsList ->
      // check billingResult
      // process returned productDetailsList
}

QueryProductDetailsParams queryProductDetailsParams =
    QueryProductDetailsParams.newBuilder()
        .setProductList(
            ImmutableList.of(
                Product.newBuilder()
                    .setProductId("product_id_example")
                    .setProductType(ProductType.SUBS)
                    .build()))
        .build();

billingClient.queryProductDetailsAsync(
    queryProductDetailsParams,
    new ProductDetailsResponseListener() {
        public void onProductDetailsResponse(BillingResult billingResult,
                List<ProductDetails> productDetailsList) {
            // check billingResult
            // process returned productDetailsList
        }
    }
)

W przypadku zapytania o szczegóły produktu przekaż instancję QueryProductDetailsParams, która określa listę ciągów znaków z identyfikatorami produktów. utworzone w Konsoli Google Play wraz z elementem ProductType. ProductType może mieć wartość ProductType.INAPP w przypadku produktów kupowanych raz lub ProductType.SUBS za subskrypcje.

Wysyłanie zapytań z użyciem rozszerzeń Kotlin

Jeśli używasz rozszerzeń Kotlin, możesz wysyłać zapytania o produkty w aplikacji. szczegóły, wywołując funkcję rozszerzenia queryProductDetails().

queryProductDetails() wykorzystuje współrzędne Kotlin, dzięki czemu nie trzeba zdefiniować osobnego detektora. Zamiast tego funkcja zostaje zawieszona do momentu Następnie możesz przetworzyć wynik:

suspend fun processPurchases() {
    val productList = listOf(
        QueryProductDetailsParams.Product.newBuilder()
            .setProductId("product_id_example")
            .setProductType(BillingClient.ProductType.SUBS)
            .build()
    )
    val params = QueryProductDetailsParams.newBuilder()
    params.setProductList(productList)

    // leverage queryProductDetails Kotlin extension function
    val productDetailsResult = withContext(Dispatchers.IO) {
        billingClient.queryProductDetails(params.build())
    }

    // Process the result.
}

Rzadko niektóre urządzenia nie obsługują funkcji ProductDetails i queryProductDetailsAsync(), zwykle z powodu nieaktualnych wersji Google Play Usługi. Aby zapewnić sobie odpowiednie wsparcie w tym scenariuszu, naucz się używać funkcje zgodności wstecznej w migracji Biblioteki płatności w Play 5 .

Przetwarzanie wyniku

Biblioteka płatności w Google Play przechowuje wyniki zapytania w List: ProductDetails obiektów. Możesz następnie wywoływać różne metody w każdym ProductDetails obiekt na liście, aby wyświetlić istotne informacje o aplikacji w aplikacji. np. jego cenę lub opis. Aby wyświetlić dostępne szczegóły produktu informacje, zobacz listę metod w klasie ProductDetails.

Zanim zaoferujesz produkt na sprzedaż, sprawdź, czy użytkownik nie ma jeszcze elementu. Jeśli użytkownik ma nadal w bibliotece produktów zużywanych, muszą konsumować przedmiot, zanim będą mogli go ponownie kupić.

Zanim zaoferujesz subskrypcję, sprawdź, czy użytkownik jeszcze jej nie subskrybuje. Pamiętaj też o tych kwestiach:

• queryProductDetailsAsync() zwraca szczegóły produktu objętego subskrypcją oraz z maksymalnie 50 ofert na subskrypcję.
• queryProductDetailsAsync() zwraca tylko te oferty, w przypadku których użytkownik odpowiednie. Jeśli użytkownik spróbuje kupić ofertę, której dotyczy nieodpowiednie (na przykład jeśli aplikacja wyświetla nieaktualną listę adresów kwalifikujących się ofert), Google Play informuje użytkownika, że nie spełnia wymagań, użytkownik może zdecydować się na zakup abonamentu podstawowego.

Rozpoczynanie procesu zakupu

Aby wysłać prośbę o zakup z aplikacji, zadzwoń pod numer launchBillingFlow() z głównego wątku aplikacji. Ta metoda odwołuje się do BillingFlowParams obiekt zawierający odpowiedni Obiekt ProductDetails uzyskany z wywołania queryProductDetailsAsync(). Aby utworzyć obiekt BillingFlowParams, użyj klasę BillingFlowParams.Builder.

// An activity reference from which the billing flow will be launched.
val activity : Activity = ...;

val productDetailsParamsList = listOf(
    BillingFlowParams.ProductDetailsParams.newBuilder()
        // retrieve a value for "productDetails" by calling queryProductDetailsAsync()
        .setProductDetails(productDetails)
        // For One-time product, "setOfferToken" method shouldn't be called.
        // For subscriptions, to get an offer token, call ProductDetails.subscriptionOfferDetails()
        // for a list of offers that are available to the user
        .setOfferToken(selectedOfferToken)
        .build()
)

val billingFlowParams = BillingFlowParams.newBuilder()
    .setProductDetailsParamsList(productDetailsParamsList)
    .build()

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

// An activity reference from which the billing flow will be launched.
Activity activity = ...;

ImmutableList<ProductDetailsParams> productDetailsParamsList =
    ImmutableList.of(
        ProductDetailsParams.newBuilder()
             // retrieve a value for "productDetails" by calling queryProductDetailsAsync()
            .setProductDetails(productDetails)
            // For one-time products, "setOfferToken" method shouldn't be called.
            // For subscriptions, to get an offer token, call
            // ProductDetails.subscriptionOfferDetails() for a list of offers
            // that are available to the user.
            .setOfferToken(selectedOfferToken)
            .build()
    );

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

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

Metoda launchBillingFlow() zwraca jeden z kilku kodów odpowiedzi wymienionych w polu BillingClient.BillingResponseCode Sprawdź ten wynik do: upewnić się, że podczas rozpoczynania procesu zakupu nie wystąpiły żadne błędy. BillingResponseCode z OK oznacza udane uruchomienie.

Po udanym wywołaniu launchBillingFlow() system wyświetla Odtwórz ekran zakupu. Rysunek 1 przedstawia ekran zakupu subskrypcji:

Google Play łączy się z firmą onPurchasesUpdated(), by dostarczyć wynik zakupu do detektora, który implementuje PurchasesUpdatedListener za pomocą prostego interfejsu online. Detektor jest określany za pomocą metody setListener(), gdy zainicjował(a) klienta.

Aby obsługiwać możliwe kody odpowiedzi, musisz zaimplementować onPurchasesUpdated(). Z przykładu poniżej dowiesz się, jak zastąpić kolumnę onPurchasesUpdated():

override fun onPurchasesUpdated(billingResult: BillingResult, purchases: List<Purchase>?) {
   if (billingResult.responseCode == BillingResponseCode.OK && purchases != null) {
       for (purchase in purchases) {
           handlePurchase(purchase)
       }
   } else if (billingResult.responseCode == BillingResponseCode.USER_CANCELED) {
       // Handle an error caused by a user cancelling the purchase flow.
   } else {
       // Handle any other error codes.
   }
}

@Override
void onPurchasesUpdated(BillingResult billingResult, List<Purchase> purchases) {
    if (billingResult.getResponseCode() == BillingResponseCode.OK
        && purchases != null) {
        for (Purchase purchase : purchases) {
            handlePurchase(purchase);
        }
    } else if (billingResult.getResponseCode() == BillingResponseCode.USER_CANCELED) {
        // Handle an error caused by a user cancelling the purchase flow.
    } else {
        // Handle any other error codes.
    }
}

Pomyślny zakup generuje ekran z potwierdzeniem zakupu w Google Play podobny do tego, rys. 2.

Pomyślny zakup generuje też token zakupu, identyfikator reprezentujący użytkownika i identyfikator produktu w aplikacji zakupu. Aplikacje mogą przechowywać token zakupu lokalnie, zalecamy przekazanie tokena do bezpiecznego serwera backendu, zweryfikować zakup i zapewnić ochronę przed oszustwami. Procedura ta została szczegółowo opisana w następnej sekcji.

Użytkownik otrzyma też e-maila z potwierdzeniem transakcji, który zawiera identyfikator zamówienia lub unikalny identyfikator transakcji. Użytkownicy otrzymują e-maila z unikalnym identyfikatorem zamówienia za każdy jednorazowy zakup produktu, a także za pierwszą subskrypcję i kolejnych automatycznych odnowieniach. Możesz użyć identyfikatora zamówienia, do zarządzania zwrotami środków w Konsoli Google Play.

Pokazuj spersonalizowaną cenę

Jeśli Twoja aplikacja może być rozpowszechniana wśród użytkowników w Unii Europejskiej, użyj atrybutu setIsOfferPersonalized(), aby poinformować użytkowników, że cena produktu była i personalizację za pomocą automatycznego procesu decyzyjnego.

Należy skonsultować się z art. 6 ust. 1 (ea) CRD dyrektywy w sprawie praw konsumentów 2011/83/EU, aby ustalić, czy cena oferowana użytkownikom spersonalizowanej.

Funkcja setIsOfferPersonalized() stosuje wartości logiczne. Gdy true, interfejs Google Play zawiera oświadczenie. Gdy false, interfejs użytkownika pominie komunikat. Domyślny ma wartość false.

Więcej informacji znajdziesz w Centrum pomocy dla klientów indywidualnych.

Przetwarzam zakupy

Gdy użytkownik dokona zakupu, aplikacja musi go przetworzyć. W większości przypadków aplikacja jest powiadamiana o zakupach na PurchasesUpdatedListener Są jednak przypadki, gdy aplikacja powiadomił(a) o zakupach, dzwoniąc pod numer BillingClient.queryPurchasesAsync() jak opisano w sekcji Pobieranie zakupów.

Jeśli korzystasz z klienta powiadomień dla deweloperów w czasie rzeczywistym, do bezpiecznego backendu, możesz rejestrować nowe zakupy, odbierając subscriptionNotification lub oneTimeProductNotification ostrzega o nowy zakup. Po otrzymaniu takich powiadomień skontaktuj się z Developer API, aby uzyskać pełny stan i zaktualizować własny stan backendu.

Aplikacja powinna przetwarzać zakup w ten sposób:

1. Zweryfikuj zakup.
2. Przekaż treść użytkownikowi i potwierdź jej dostarczenie. Opcjonalnie oznacz produkt jako wykorzystany, by użytkownik mógł go kupić ponownie.

Aby zweryfikować zakup, najpierw upewnij się, że stan zakupu to PURCHASED. Jeśli zakup to PENDING, musisz przetworzyć zakupu zgodnie z opisem w sekcji Obsługa transakcji oczekujących. Do zakupów otrzymanych od onPurchasesUpdated() lub queryPurchasesAsync(), Ty powinien dokładniej zweryfikować zakup, aby potwierdzić jego zasadność, zanim aplikacja ją zatwierdzi. zezwolenie. Więcej informacji o prawidłowej weryfikacji zakupu znajdziesz w sekcji Weryfikowanie zakupów przed przyznaniem uprawnień.

Po zweryfikowaniu zakupu aplikacja jest gotowa do przyznawania uprawnień aplikacji użytkownika. Konto użytkownika powiązane z zakupem można zidentyfikować za pomocą ProductPurchase.obfuscatedExternalAccountId zwrócone przez Purchases.products:get w przypadku zakupów produktów w aplikacji oraz SubscriptionPurchase.obfuscatedExternalAccountId zwrócone przez Purchases.subscriptions:get w przypadku subskrypcji po stronie serwera lub obfuscatedAccountId od Purchase.getAccountIdentifiers() na po stronie klienta, jeśli został ustawiony przy użyciu parametru setObfuscatedAccountId, gdy dokonał(a) zakupu.

Po przyznaniu uprawnień aplikacja musi potwierdzić zakup. Ten potwierdzasz, że informujesz Google Play, że przyznałeś(-aś) uprawnienia za zakup.

Proces przyznawania uprawnienia i potwierdzenia zakupu zależy od tego, czy zakup to przedmiot konsumpcyjny, nieużywany lub subskrypcja.

Produkty konsumpcyjne

W przypadku materiałów eksploatacyjnych, jeśli aplikacja ma bezpieczny backend, zalecamy użycie Purchases.products:consume, aby móc wygodnie korzystać z zakupów. Upewnij się, że parametr zakup nie został jeszcze wykorzystany, sprawdzając pole consumptionState na stronie w wyniku wywołania funkcji Purchases.products:get. Jeśli aplikacja jest przeznaczona tylko dla klientów bez backendu, użyj consumeAsync() z Biblioteka płatności w Google Play. Obie metody spełniają potwierdzenie wymaganie i wskaż, że aplikacja przyznała użytkownikowi odpowiednie uprawnienia. Dzięki tym metodom aplikacja może dostosować jednorazowy produkt do podany token zakupu, który można ponownie kupić. Z Tobą (consumeAsync()) musi też przekazywać obiekt, który implementuje interfejs ConsumeResponseListener za pomocą prostego interfejsu online. Ten obiekt obsługuje wynik operacji konsumpcji. Dostępne opcje zastępuje metodę onConsumeResponse(), która Po zakończeniu operacji wywołuje połączenie z Biblioteki płatności w Google Play.

Poniższy przykład pokazuje korzystanie z produktu z atrybutem Biblioteki płatności w Google Play przy użyciu powiązanego tokena zakupu:

suspend fun handlePurchase(purchase: Purchase) {
    // Purchase retrieved from BillingClient#queryPurchasesAsync or your PurchasesUpdatedListener.
    val purchase : Purchase = ...;

    // Verify the purchase.
    // Ensure entitlement was not already granted for this purchaseToken.
    // Grant entitlement to the user.

    val consumeParams =
        ConsumeParams.newBuilder()
            .setPurchaseToken(purchase.getPurchaseToken())
            .build()
    val consumeResult = withContext(Dispatchers.IO) {
        client.consumePurchase(consumeParams)
    }
}

void handlePurchase(Purchase purchase) {
    // Purchase retrieved from BillingClient#queryPurchasesAsync or your PurchasesUpdatedListener.
    Purchase purchase = ...;

    // Verify the purchase.
    // Ensure entitlement was not already granted for this purchaseToken.
    // Grant entitlement to the user.

    ConsumeParams consumeParams =
        ConsumeParams.newBuilder()
            .setPurchaseToken(purchase.getPurchaseToken())
            .build();

    ConsumeResponseListener listener = new ConsumeResponseListener() {
        @Override
        public void onConsumeResponse(BillingResult billingResult, String purchaseToken) {
            if (billingResult.getResponseCode() == BillingResponseCode.OK) {
                // Handle the success of the consume operation.
            }
        }
    };

    billingClient.consumeAsync(consumeParams, listener);
}

Produkty, które się nie zużywają

Aby potwierdzić zakupy, których nie można wykorzystać, jeśli aplikacja ma bezpieczny backend, zalecamy użycie Purchases.products:acknowledge, aby zakupów. Upewnij się, że sprzedawca nie potwierdził wcześniej zakupu sprawdzanie acknowledgementState w wyniku wywołania Purchases.products:get

Jeśli Twoja aplikacja jest przeznaczona tylko dla klientów, użyj BillingClient.acknowledgePurchase() z z Biblioteki płatności w Google Play w aplikacji. Przed potwierdzeniem aplikacji, aplikacja powinna sprawdzić, czy została już potwierdzony, korzystając z isAcknowledged() w Bibliotece płatności w Google Play.

Poniższy przykład pokazuje, jak potwierdzić zakup za pomocą Biblioteka płatności w Google Play:

val client: BillingClient = ...
val acknowledgePurchaseResponseListener: AcknowledgePurchaseResponseListener = ...

suspend fun handlePurchase() {
    if (purchase.purchaseState === PurchaseState.PURCHASED) {
        if (!purchase.isAcknowledged) {
            val acknowledgePurchaseParams = AcknowledgePurchaseParams.newBuilder()
                    .setPurchaseToken(purchase.purchaseToken)
            val ackPurchaseResult = withContext(Dispatchers.IO) {
               client.acknowledgePurchase(acknowledgePurchaseParams.build())
            }
        }
     }
}

BillingClient client = ...
AcknowledgePurchaseResponseListener acknowledgePurchaseResponseListener = ...

void handlePurchase(Purchase purchase) {
    if (purchase.getPurchaseState() == PurchaseState.PURCHASED) {
        if (!purchase.isAcknowledged()) {
            AcknowledgePurchaseParams acknowledgePurchaseParams =
                AcknowledgePurchaseParams.newBuilder()
                    .setPurchaseToken(purchase.getPurchaseToken())
                    .build();
            client.acknowledgePurchase(acknowledgePurchaseParams, acknowledgePurchaseResponseListener);
        }
    }
}

Subskrypcje

Subskrypcje są obsługiwane podobnie jak materiały niewykorzystane. Jeśli to możliwe, użyj funkcji Purchases.subscriptions.acknowledge z interfejsu Google Play Developer API, aby potwierdzić zakup bezpiecznego backendu. Sprawdź, czy zakup nie został wcześniej potwierdzony przez sprawdzając acknowledgementState w zasobach dotyczących zakupu Purchases.subscriptions:get W przeciwnym razie możesz potwierdzić subskrypcja za pomocą BillingClient.acknowledgePurchase() z Biblioteka płatności w Google Play po sprawdzeniu isAcknowledged(). Wszystkie należy potwierdzić zakup początkowych subskrypcji. Odnawianie subskrypcji nie wymagają potwierdzenia. Więcej informacji o tym, kiedy subskrypcje wymagają potwierdzenia, przeczytaj temat Sprzedaż subskrypcji.

Pobieranie zakupów

Odsłuchiwanie powiadomień o zakupach za pomocą PurchasesUpdatedListener nie jest wystarcza do przetworzenia wszystkich zakupów przez aplikację. Możliwe, że aplikacja może nie wiedzieć o wszystkich zakupach użytkownika. Oto kilka sytuacje, w których aplikacja może utracić śledzenie zakupów lub nie być świadoma zakupów:

• Problemy z siecią podczas zakupu: użytkownik dokonuje zakupu. i otrzymuje potwierdzenie od Google, ale urządzenie traci sieć urządzenie, zanim urządzenie otrzyma powiadomienie o zakupie. przez PurchasesUpdatedListener.
• Wiele urządzeń: użytkownik kupuje produkt na jednym urządzeniu, a następnie oczekuje, zobaczą go, gdy zmieni urządzenie.
• Obsługa zakupów dokonanych poza aplikacją: niektóre zakupy, takie jak z promocji można dokonywać poza aplikacją.

Aby rozwiązać te problemy, upewnij się, że aplikacja wywołuje BillingClient.queryPurchasesAsync() w metodzie onResume() do należy się upewnić, że wszystkie zakupy zostaną przetworzone zgodnie z opisem w sekcji dotyczącej przetwarzania danych. zakupów.

Przykład poniżej pokazuje, jak pobrać informacje o zakupach subskrypcji użytkownika. Pamiętaj, że queryPurchasesAsync() zwraca tylko aktywne subskrypcje oraz niewymagających zakupów.

val params = QueryPurchasesParams.newBuilder()
               .setProductType(ProductType.SUBS)

// uses queryPurchasesAsync Kotlin extension function
val purchasesResult = billingClient.queryPurchasesAsync(params.build())

// check purchasesResult.billingResult
// process returned purchasesResult.purchasesList, e.g. display the plans user owns

billingClient.queryPurchasesAsync(
    QueryPurchasesParams.newBuilder()
      .setProductType(ProductType.SUBS)
      .build(),
    new PurchasesResponseListener() {
      public void onQueryPurchasesResponse(BillingResult billingResult, List<Purchase> purchases) {
        // check billingResult
        // process returned purchase list, e.g. display the plans user owns

      }
    }
);

Obsługa zakupów dokonanych poza aplikacją

Niektóre zakupy (np. wykorzystanie promocji) mogą odbywać się poza aplikacją. Gdy użytkownik dokona zakupu poza aplikacją, oczekuje, że wyświetli się ona poza aplikacją wiadomości w aplikacji lub skorzystać z jakiegoś mechanizmu powiadomień, aby umożliwić użytkownikowi będą wiedzieć, że aplikacja prawidłowo otrzymała i przetworzyła zakup. Średnio akceptowalne mechanizmy to:

• Pokaż wyskakujące okienko w aplikacji.
• Umieść wiadomość w polu wiadomości w aplikacji i wyraźnie o tym to nowa wiadomość w polu wiadomości w aplikacji.
• Użyj powiadomienia z systemu operacyjnego.

Pamiętaj, że aplikacja może być w dowolnym stanie, rozpozna zakup. Jest nawet możliwe, że aplikacja w ogóle nie będzie zainstalowano podczas dokonywania zakupu. Użytkownicy oczekują, że kupią produkt podczas wznawiania aplikacji, niezależnie od jej stanu.

Musisz wykrywać zakupy niezależnie od tego, w jakim stanie aplikacja została dokonał(a) zakupu. Istnieją jednak wyjątki, w których dopuszczalna jest akceptowalna aby nie powiadamiać użytkownika od razu o jego dostarczeniu. Na przykład:

• W trakcie czynności, w której wyświetlenie komunikatu może rozpraszać uwagę użytkownika. W takim przypadku należy powiadomić użytkownika o zakończeniu danego działania.
• W trakcie przerywników, w których pokazanie wiadomości może rozpraszać uwagę użytkownika. W tym Trzeba powiadomić użytkownika o jego zakończeniu.
• W trakcie początkowego samouczka i konfiguracji użytkownika w grze. Zalecamy powiadamiasz nowych użytkowników o nagrodzie natychmiast po tym, jak otworzą grę; podczas początkowej konfiguracji użytkownika. Można jednak poczekać, aż główna jest sekwencja gry, którą użytkownik może powiadomić.

Przy podejmowaniu decyzji, kiedy i w jaki sposób powiadamiać użytkowników o zakupów dokonanych poza aplikacją. Za każdym razem, gdy użytkownik nie otrzyma od razu powiadomienie, może się pomylić i przestać używać aplikacji, skontaktuj się z użytkownikiem wsparcia lub narzekania w mediach społecznościowych. Uwaga: Domena PurchasesUpdatedListener jest zarejestrowana w Twojej aplikacji kontekstu do obsługi aktualizacji zakupów, w tym zakupów zainicjowanych poza domenę Twojej aplikacji. Oznacza to, że jeżeli proces zgłaszania nie istnieje, Użytkownik PurchasesUpdatedListener nie zostanie powiadomiony. Dlatego aplikacja powinna wywołaj metodę BillingClient.queryPurchasesAsync() w metodzie onResume() jako wspomniane w artykule Pobieranie zakupów.

Obsługa oczekujących transakcji

Google Play obsługuje transakcje oczekujące, czyli takie, które wymagają jednej lub wykonanie dodatkowych czynności, które mogą wystąpić, gdy użytkownik zainicjuje zakup forma płatności została przetworzona. Aplikacja nie powinna przyznawać dostępu takich zakupów, dopóki Google nie powiadomi Cię, że forma płatności użytkownika została obciążona opłatą.

Na przykład użytkownik może zainicjować transakcję, wybierając sklep stacjonarny gdzie zapłaci później gotówką. Użytkownik otrzymuje kod przez powiadomienia i e-maila. Gdy użytkownik odwiedzi sklep stacjonarny, może wykorzystać kod u kasjera i zapłacić gotówką. Google powiadomi o tym i użytkownik, który otrzymał płatność, Aplikacja może wtedy przyznać uprawnienia uprawnienia użytkownika.

Wywołaj enablePendingPurchases() w ramach inicjowania BillingClient, by włączyć oczekujące transakcje dla Twojej aplikacji. Aplikacja musi: włączać i obsługiwać oczekujące transakcje w przypadku produktów kupowanych raz. Przed podczas dodawania pomocy, zapoznaj się z cyklem życia zakupów w przypadku transakcji.

Gdy aplikacja otrzyma nowy zakup, za pomocą PurchasesUpdatedListener lub w wyniku połączenia queryPurchasesAsync(), użyj metody getPurchaseState() do określić, czy stan zakupu to PURCHASED, czy PENDING. Zalecenia przyznawaj uprawnienia tylko wtedy, gdy stan to PURCHASED.

Jeśli aplikacja jest uruchomiona, gdy użytkownik finalizuje zakup, Pole PurchasesUpdatedListener jest wywoływane ponownie, a pole PurchaseState jest teraz wywoływane ponownie PURCHASED. Na tym etapie aplikacja może przetworzyć zakup przy użyciu do przetwarzania zakupów. Aplikacja powinna również wywołać funkcję queryPurchasesAsync() w metodzie onResume() aplikacji do obsługi zakupów które zostały przeniesione do stanu PURCHASED, gdy Twoja aplikacja nie była uruchomiona.

Po zmianie stanu zakupu z PENDING na PURCHASED, Twój klient powiadomień w czasie rzeczywistym dla deweloperów otrzyma wiadomość ONE_TIME_PRODUCT_PURCHASED lub SUBSCRIPTION_PURCHASED. Jeśli zakup zostanie anulowany, otrzymuje ONE_TIME_PRODUCT_CANCELED lub SUBSCRIPTION_PENDING_PURCHASE_CANCELED powiadomienie. Może się tak zdarzyć, jeśli klient nie ureguluje płatności w wymaganym terminie. Pamiętaj, że zawsze może użyć interfejsu Google Play Developer API, aby sprawdzić bieżący stan zakup.

Obsługa zakupu wielu sztuk tego samego produktu

Obsługiwane w Bibliotece płatności w Google Play w wersji 4.0 i nowszych. Google Play pozwala klientom kupować więcej niż jedną sztukę w aplikacji. produktu w jednej transakcji, określając ilość z koszyka. Twoje aplikacja powinna obsługiwać zakupy naraz i przyznawać uprawnienia na podstawie uprawnień w ramach określonej wielkości zakupu.

Aby można było korzystać z zakupów obejmujących kilka sztuk, logika obsługi administracyjnej aplikacji musi sprawdzić, za określoną liczbę produktów. Dostęp do pola quantity możesz uzyskać z poziomu jednej z następujące interfejsy API:

• getQuantity() z Biblioteki płatności w Google Play.
• Purchases.products.quantity z interfejsu Google Play Developer API.

Gdy dodasz już reguły do obsługi wielu zakupów jednocześnie, włącz funkcję wielu sztuk tego samego produktu w aplikacji stronie zarządzania usługami w Google Play Developer Console.

Zapytanie o konfigurację płatności użytkownika

getBillingConfigAsync() podaje kraj, z którego korzysta użytkownik Google Play.

Możesz przesłać zapytanie o konfigurację płatności użytkownika po tworząc element BillingClient. Poniższy fragment kodu opisuje Jak zadzwonić do: getBillingConfigAsync()? Przetwórz odpowiedź według zaimplementuję BillingConfigResponseListener. Ten detektor otrzymuje Aktualizacje dotyczące wszystkich zapytań dotyczących konfiguracji płatności zainicjowanych z Twojej aplikacji.

Jeśli zwrócona wartość BillingResult nie zawiera błędów, możesz sprawdzić countryCode w obiekcie BillingConfig, aby uzyskać wartość Play użytkownika Kraj.

// Use the default GetBillingConfigParams.
val getBillingConfigParams = GetBillingConfigParams.newBuilder().build()
billingClient.getBillingConfigAsync(getBillingConfigParams,
    object : BillingConfigResponseListener {
        override fun onBillingConfigResponse(
            billingResult: BillingResult,
            billingConfig: BillingConfig?
        ) {
            if (billingResult.responseCode == BillingResponseCode.OK
                && billingConfig != null) {
                val countryCode = billingConfig.countryCode
                ...
            } else {
                // TODO: Handle errors
            }
        }
    })

// Use the default GetBillingConfigParams.
GetBillingConfigParams getBillingConfigParams = GetBillingConfigParams.newBuilder().build();
billingClient.getBillingConfigAsync(getBillingConfigParams,
    new BillingConfigResponseListener() {
      public void onBillingConfigResponse(
          BillingResult billingResult, BillingConfig billingConfig) {
        if (billingResult.getResponseCode() == BillingResponseCode.OK
            && billingConfig != null) {
            String countryCode = billingConfig.getCountryCode();
            ...
         } else {
            // TODO: Handle errors
        }
      }
    });