Как интегрировать библиотеку Google Play Платежей для нативных игр на ПК в приложение

Монетизируйте игру, продавая цифровые товары через Google Play Платежи. SDK предлагает API для показа доступных для покупки товаров, запуска процесса покупки и обработки покупок. Вызовы этих API выполняются с помощью аккаунта Google, который запустил игру в клиенте Google Play Игр, и не требуют дополнительных действий для входа.

Если вы интегрировали библиотеку Google Play Платежей для Android, то эти API должны быть вам знакомы. Любые серверные интеграции с Google Play Платежами можно использовать повторно в играх для ПК, поскольку они одинаковы для Android и ПК.

Требования

Шаг 1. Создайте BillingClient

Начиная с версии 26.3.312.0

Для SDK версии 26.3.312.0 и более поздних используйте BillingClientParameters, чтобы настроить и создать экземпляр BillingClient. Это позволяет включать определенные функции во время инициализации, например незавершенные покупки.

// Set up initialization parameters
BillingClientParams params;
params.enable_pending_purchases = true;

// Instantiate the BillingClient with parameters
BillingClient billing_client(params);

До версии 26.3.312.0

В версиях SDK до 26.3.312.0 BillingClient поддерживает создание экземпляров только с помощью конструктора по умолчанию. В этих версиях недоступны расширенные настройки. .

BillingClient billing_client;

Шаг 2. Запросите информацию о предыдущих покупках и покупках, совершенных за пределами приложения

При запуске приложения или его переходе в активный режим отправьте запрос на получение информации о покупках. Это необходимо, чтобы обнаруживать покупки, совершенные за пределами игры, или открывать доступ к покупкам, которые пользователь сделал ранее.

  1. Запросите информацию о покупках с помощью метода BillingClient::QueryPurchases.

  2. Обработайте покупки.

// Query for purchases when:
// - Application starts up
// - Application window re-enters the foreground
auto promise = std::make_shared<std::promise<QueryPurchasesResult>>();
billing_client.QueryPurchases([promise](QueryPurchasesResult result) {
   promise->set_value(std::move(result));
});

auto query_purchases_result = promise->get_future().get();
if (query_purchases_result.ok()) {
  auto purchases = query_purchases_result.value().product_purchase_details;
  // Process the purchases
} else {
  // Handle the error
}

Шаг 3. Покажите товары, доступные для покупки

Теперь вы можете запрашивать доступные товары и показывать их пользователям. Запрос информации о товарах – важный шаг перед показом товаров пользователям, поскольку он возвращает локализованную информацию о товарах.

Прежде чем предлагать товар, убедитесь, что пользователь его ещё не приобрел. Если у пользователя есть расходуемый контент, который все ещё находится в истории покупок, вы должны использовать этот контент, прежде чем пользователь сможет купить его снова.

  1. Запросите информацию о товарах с помощью BillingClient::QueryProductDetails. Передайте идентификаторы товаров, которые вы зарегистрировали в Google Play Console.
  2. Отобразите ProductDetails, который включает локализованное название товара и цену предложения.
  3. Сохраните ссылку на offer_token товара. Она используется для запуска процесса покупки специального предложения.
QueryProductDetailsParams params;
params.product_ids.push_back({"example_costmetic_1", ProductType::kTypeInApp});
params.product_ids.push_back({"example_costmetic_1", ProductType::kTypeInApp});
params.product_ids.push_back({"example_battle_pass", ProductType::kTypeInApp});

auto promise = std::make_shared<std::promise<QueryProductDetailsResult>>();
billing_client.QueryProductDetails(params, [promise](QueryProductDetailsResult result) {
   promise->set_value(std::move(result));
});

auto query_product_details_result = promise->get_future().get();
if (query_product_details_result.ok()) {
   auto product_details = query_product_details_result.value().product_details;
   // Display the available products and their offers to the user
} else {
   // Handle the error
}

Шаг 4. Запустите процесс покупки

Когда пользователь выражает намерение купить товар, который вы ему показали, вы готовы запустить процесс покупки.

Процесс покупки завершается в игре с помощью оверлея на основе WebView:

Интерфейс для оплаты покупок в игре
Процесс оформления заказа в игре
  1. Начните со звонка по номеру BillingClient::LaunchPurchaseFlow(). Передайте объект offer_token, полученный при запросе информации о товаре.
  2. После завершения покупки будет вызвана функция продолжения с результатом.
  3. Если запрос выполнен успешно, продолжение содержит ProductPurchaseDetails. Обработайте покупку.
LaunchPurchaseFlowParams params { product_offer.offer_token };

auto promise = std::make_shared<std::promise<LaunchPurchaseFlowResult>>();
billing_client.LaunchPurchaseFlow(params, [promise](LaunchPurchaseFlowResult result) {
   promise->set_value(std::move(result));
});
// The purchase flow has started and is now in progress.

auto launch_purchase_flow_result = promise->get_future().get();

// The purchase flow has now completed.
if (launch_purchase_flow_result.ok()) {
   auto purchase = launch_purchase_flow_result.value().product_purchase_details;
   // Process the purchase
} else if (launch_purchase_flow_result.code() == BillingError::kUserCanceled) {
   // Handle an error caused by the user canceling the purchase flow
} else {
   // Handle any other error codes
}

Шаг 5. Обработка покупки

Обработка с помощью бэкенд-сервера

Если у игры есть внутренний сервер, отправьте на него purchase_token. Завершите обработку с помощью серверных API Google Play Платежей. Эта серверная интеграция выполняется так же, как и для игры Android, интегрированной с Google Play Платежами.

void ProcessPurchasesWithServer(std::vector<ProductPurchaseDetails> purchases) {
   std::vector<std::string> purchase_tokens;
   for (const auto& purchase : purchases) {
      purchase_tokens.push_back(purchase.purchase_token);
   }

   // Send purchase tokens to backend server for processing
}

Обработка без бэкенд-сервера

  1. Убедитесь, что платеж пользователя не находится в статусе ожидания. Для этого проверьте, что значение ProductPurchaseDetails::purchase_state равно PurchaseState::kPurchaseStatePurchased. Если покупка находится в статусе ожидания, сообщите пользователю, что ему нужно выполнить дополнительные действия, чтобы получить приобретенный товар.

  2. Предоставьте пользователю доступ к купленному товару и обновите хранилище прав в игре.

  3. Для нерасходуемых товаров (которые можно купить только один раз) проверьте, было ли подтверждено приобретение, с помощью метода ProductPurchaseDetails::is_acknowledged.

    1. Если покупка не подтверждена, сообщите Google, что пользователь получает право на использование товара, вызвав метод BillingClient::AcknowledgePurchase.
  4. Для расходуемых покупок (товаров, которые можно приобрести несколько раз) сообщите Google, что пользователю предоставляется право на товар, вызвав BillingClient::ConsumePurchase.

void ProcessPurchasesWithoutServer(std::vector<ProductPurchaseDetails> purchases) {
   std::vector<std::string> entitled_product_ids;
   for (const auto& purchase : purchases) {
      auto was_successful = ProcessPurchasePurchaseWithoutServer(purchase);
      if (was_successful) {
         entitled_product_ids.push_back(purchase.product_id);
      }
   }

   // Note that non-consumable products that were previously purchased may have
   // been refunded. These purchases will stop being returned by
   // `QueryPurchases()`. If your game has given a user access to one of these
   // products storage they should be revoked.
   //
   // ...
}

bool ProcessPurchasePurchaseWithoutServer(ProductPurchaseDetails purchase) {
   auto is_purchase_completed =
      purchase.purchase_state == PurchaseState::kPurchaseStatePurchased;
   if (!is_purchase_completed) {
      // Notify the user that they need to take additional steps to complete
      // this purchase.
      return false;
   }

   // Determine if the product ID is associated with a consumable product.
   auto is_consumable = IsConsumableProductId(purchase.product_id);
   if (is_consumable) {
      // Grant an entitlement to the product to the user.
      // ...
      // Then, notify Google by consuming the purchase.

      ConsumePurchaseParams params { purchase.purchase_token };
      auto promise = std::make_shared<std::promise<ConsumePurchaseResult>>();
      billing_client.ConsumePurchase(params, [promise](ConsumePurchaseResult result) {
         promise->set_value(std::move(result));
      });

      auto consume_purchase_result = promise->get_future().get();
      if (!consume_purchase_result.ok()) {
         // Examine the failure code & message for more details & notify user
         // of failure.
         // ...
         return false;
      }

      return true;
   }

   // Otherwise the product is assumed to be a non-consumable.

   // Grant an entitlement to the product to the user.
   // ...
   // Then, notify Google by acknowledging the purchase (if not already done).

   if (purchase.is_acknowledged) {
      return true;
   }

   AcknowledgePurchaseParams params { purchase.purchase_token };
   auto promise = std::make_shared<std::promise<AcknowledgePurchaseResult>>();
   billing_client.AcknowledgePurchase(params, [promise](AcknowledgePurchaseResult result) {
      promise->set_value(std::move(result));
   });

   auto acknowledge_purchase_result = promise->get_future().get();
   if (!acknowledge_purchase_result.ok()) {
      // Examine the failure code & message for more details & notify user
      // of failure.
      // ...
      return false;
   }

   return true;
}

Подтверждение покупок на стороне клиента

Клиентская проверка обеспечивает дополнительный уровень безопасности, проверяя подпись покупки непосредственно в клиенте игры:

Архитектура проверки подписи покупки на стороне клиента
Архитектура клиентского подтверждения покупок

Вы получаете signature от ProductPurchaseDetails. Поле signature подписывается вашим закрытым ключом с помощью алгоритма подписи SHA1withRSA. Для проверки с помощью открытого ключа выполните следующие действия:

#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>
#include <openssl/sha.h>

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

// Decodes a Base64 string into a vector of bytes using OpenSSL BIOs.
std::vector<unsigned char> base64_decode(const std::string& base64_string) {
    BIO *bio, *b64;
    b64 = BIO_new(BIO_f_base64());
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
    bio = BIO_new_mem_buf(base64_string.data(), base64_string.length());
    bio = BIO_push(b64, bio);

    std::vector<unsigned char> decoded_data;
    decoded_data.resize(base64_string.length());
    int length = BIO_read(bio, decoded_data.data(), decoded_data.size());
    if (length > 0) {
      decoded_data.resize(length);
    } else {
      decoded_data.clear();
    }
    BIO_free_all(bio);
    return decoded_data;
}

// Reads a PEM-encoded public key string and returns an EVP_PKEY object.
EVP_PKEY* createPublicKey(const std::string& publicKeyPem) {
  BIO* bio = BIO_new_mem_buf(publicKeyPem.data(), publicKeyPem.length());
  EVP_PKEY* pkey = PEM_read_bio_PUBKEY(bio, nullptr, nullptr, nullptr);
  BIO_free(bio);
  return pkey;
}

// Verifies the RSA-SHA1 signature of given data using a public key.
bool verifySignature(const std::string& publicKeyPem,
                     const std::string& originalData,
                     const std::string& signature_b64) {
  std::vector<unsigned char> signature = base64_decode(signature_b64);
  EVP_PKEY* pkey = createPublicKey(publicKeyPem);
  if (!pkey) {
    std::cerr << "Error loading public key." << std::endl;
    ERR_print_errors_fp(stderr);
    return false;
  }

  EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
  if (!mdctx) {
    std::cerr << "EVP_MD_CTX_new failed." << std::endl;
    EVP_PKEY_free(pkey);
    return false;
  }

  if (EVP_DigestVerifyInit(mdctx, nullptr, EVP_sha1(), nullptr, pkey) <= 0 ||
      EVP_DigestVerifyUpdate(mdctx, originalData.c_str(),
                             originalData.length()) <= 0) {
    EVP_MD_CTX_free(mdctx);
    EVP_PKEY_free(pkey);
    std::cerr << "Error during EVP_DigestVerifyInit or EVP_DigestVerifyUpdate."
              << std::endl;
    return false;
  }

  int result = EVP_DigestVerifyFinal(
      mdctx, reinterpret_cast<const unsigned char*>(signature.data()),
      signature.size());

  EVP_MD_CTX_free(mdctx);
  EVP_PKEY_free(pkey);

  if (result == 0) {
    std::cerr << "Signature verification failed." << std::endl;
    return false;
  } else if (result != 1) {
    std::cerr << "Error during signature verification." << std::endl;
    ERR_print_errors_fp(stderr);
    return false;
  }

  return true;
}

Шаг 6. Проверьте интеграцию

Теперь вы можете протестировать интеграцию с Google Play Платежами. Для тестирования на этапе разработки рекомендуем использовать тестировщиков лицензий. Тестировщики лицензий имеют доступ к тестовым платежам, которые позволяют не платить реальные деньги за покупки.

Инструкции по настройке тестировщиков лицензий и набор тестов, которые мы рекомендуем выполнить вручную, можно найти в документации по тестированию интеграции библиотеки Google Play Платежей.