Tutorial

Siga as etapas neste tutorial para integrar seu aplicativo Android distribuído por meio da Google Play Store com a API Google Pay e configurá-lo para aceitar cartões de pagamento.

    Etapa 1: definir a versão da API Google Pay

    Declare a versão da API Google Pay que o aplicativo usa. As versões principal e secundária afetam os campos esperados em cada objeto passado e são incluídas na resposta.

    Crie um objeto de solicitação básico que contenha as propriedades que estão presentes em todos os outros objetos de solicitação.

    
          private static JSONObject getBaseRequest() throws JSONException {
            return new JSONObject().put("apiVersion", 2).put("apiVersionMinor", 0);
          }
        

    Etapa 2: escolher um método de tokenização de pagamento

    O Google criptografa informações sobre o cartão selecionado de um pagador para processamento seguro pelo gateway compatível ou diretamente nos servidores seguros de um comerciante. Veja a seguir exemplos para as duas opções.

    Gateway

    
          private static JSONObject getGatewayTokenizationSpecification() throws JSONException {
            return new JSONObject(){{          put("type", "PAYMENT_GATEWAY");
              put("parameters", new JSONObject(){{            put("gateway", "example");
                put("gatewayMerchantId", "exampleGatewayMerchantId");
                }
              });
            }};
          }
        

    Substitua example por um identificador de gateway de um gateway com suporte do Google e exampleGatewayMerchantId por um identificador do comerciante exclusivo fornecido pelo seu gateway.

    Consulte a documentação de tokenização do gateway para mais informações sobre quais são compatíveis e sobre identificadores exclusivos. O tipo de tokenização de PAYMENT_GATEWAY é a implementação de comerciante mais comum da forma de pagamento com cartão na API Google Pay.

    Direct

    
          private static JSONObject getDirectTokenizationSpecification()
              throws JSONException, RuntimeException {
            if (Constants.DIRECT_TOKENIZATION_PARAMETERS.isEmpty()
                || Constants.DIRECT_TOKENIZATION_PUBLIC_KEY.isEmpty()
                || Constants.DIRECT_TOKENIZATION_PUBLIC_KEY == null
                || Constants.DIRECT_TOKENIZATION_PUBLIC_KEY == "REPLACE_ME") {
              throw new RuntimeException(
                  "Please edit the Constants.java file to add protocol version & public key.");
            }
            JSONObject tokenizationSpecification = new JSONObject();
    
            tokenizationSpecification.put("type", "DIRECT");
            JSONObject parameters = new JSONObject(Constants.DIRECT_TOKENIZATION_PARAMETERS);
            tokenizationSpecification.put("parameters", parameters);
    
            return tokenizationSpecification;
          }
        

    Substitua o valor abreviado de publicKey por uma chave pública que você forneceu no seu Perfil do desenvolvedor do Google Pay para receber informações de pagamento criptografadas com essa chave. Consulte nossa documentação sobre criptografia de dados de pagamento para informações sobre como configurar chaves de criptografia adequadas para a API Google Pay.

    Etapa 3: definir as redes de cartões de pagamento compatíveis

    Defina as redes de cartões que seu aplicativo aceita.

        private static JSONArray getAllowedCardNetworks() {
          return new JSONArray()
              .put("AMEX")
              .put("DISCOVER")
              .put("INTERAC");
              .put("JCB")
              .put("MASTERCARD")
              .put("VISA");
        }

    A API Google Pay pode retornar cartões registrados em arquivo no Google.com.br (PAN_ONLY) e/ou um token de dispositivo em um dispositivo Android autenticado com um criptograma 3-D Secure (CRYPTOGRAM_3DS).

        private static JSONArray getAllowedCardAuthMethods() {
          return new JSONArray()
              .put("PAN_ONLY")
              .put("CRYPTOGRAM_3DS");
        }

    Consulte CardParameters em nossa referência de objeto JSON para mais informações. Verifique com o gateway ou processador quais as redes de cartões compatíveis e se há suporte para tokens de dispositivos Android.

    Etapa 4: descrever as formas de pagamento permitidas

    Combine os métodos de autenticação e as redes de cartões compatíveis para descrever o suporte do aplicativo para a forma de pagamento CARD.

    
          private static JSONObject getBaseCardPaymentMethod() throws JSONException {
            JSONObject cardPaymentMethod = new JSONObject();
            cardPaymentMethod.put("type", "CARD");
    
            JSONObject parameters = new JSONObject();
            parameters.put("allowedAuthMethods", getAllowedCardAuthMethods());
            parameters.put("allowedCardNetworks", getAllowedCardNetworks());
            // Optionally, you can add billing address/phone number associated with a CARD payment method.
            parameters.put("billingAddressRequired", true);
    
            JSONObject billingAddressParameters = new JSONObject();
            billingAddressParameters.put("format", "FULL");
    
            parameters.put("billingAddressParameters", billingAddressParameters);
    
            cardPaymentMethod.put("parameters", parameters);
    
            return cardPaymentMethod;
          }
        

    Estenda o objeto da forma de pagamento por cartão base para descrever as informações que precisam ser devolvidas ao aplicativo, incluindo dados de pagamento simbólicos.

    
          private static JSONObject getCardPaymentMethod() throws JSONException {
            JSONObject cardPaymentMethod = getBaseCardPaymentMethod();
            cardPaymentMethod.put("tokenizationSpecification", getGatewayTokenizationSpecification());
    
            return cardPaymentMethod;
          }
        

    Consulte CardParameters em nossa referência de objeto JSON para mais informações sobre os parameters compatíveis.

    Além de "CARD", o Google Pay também é compatível com a forma de pagamento "PAYPAL". Para mais detalhes sobre como adicionar "PAYPAL" como forma de pagamento ao Google Pay, consulte a documentação do desenvolvedor do PayPal.

    Etapa 5: criar uma instância do PaymentsClient

    Crie uma instância de PaymentsClient no método onCreate na sua Activity. O PaymentsClient é usado para interação com a API Google Pay.

    
          public static PaymentsClient createPaymentsClient(Activity activity) {
            Wallet.WalletOptions walletOptions =
                new Wallet.WalletOptions.Builder().setEnvironment(Constants.PAYMENTS_ENVIRONMENT).build();
            return Wallet.getPaymentsClient(activity, walletOptions);
          }
        

    Etapa 6: determinar a disponibilidade para pagar com a API Google Pay

    Adicione as formas de pagamento permitidas ao objeto de solicitação básico com o seguinte snippet de código:

    
          public static Optional<JSONObject> getIsReadyToPayRequest() {
            try {
              JSONObject isReadyToPayRequest = getBaseRequest();
              isReadyToPayRequest.put(
                  "allowedPaymentMethods", new JSONArray().put(getBaseCardPaymentMethod()));
    
              return Optional.of(isReadyToPayRequest);
            } catch (JSONException e) {
              return Optional.empty();
            }
          }
        

    Antes de exibir o botão Google Pay, chame a API isReadyToPay para determinar se o usuário pode fazer pagamentos com a API Google Pay. Consulte a documentação do objeto JSON IsReadyToPayRequest para uma lista completa das propriedades de configuração.

    
          private void possiblyShowGooglePayButton() {
            final Optional<JSONObject> isReadyToPayJson = PaymentsUtil.getIsReadyToPayRequest();
            if (!isReadyToPayJson.isPresent()) {
              return;
            }
            IsReadyToPayRequest request = IsReadyToPayRequest.fromJson(isReadyToPayJson.get().toString());
            if (request == null) {
              return;
            }
    
            // The call to isReadyToPay is asynchronous and returns a Task. We need to provide an
            // OnCompleteListener to be triggered when the result of the call is known.
            Task<Boolean> task = mPaymentsClient.isReadyToPay(request);
            task.addOnCompleteListener(this,
                new OnCompleteListener<Boolean>() {
                  @Override
                  public void onComplete(@NonNull Task<Boolean> task) {
                    if (task.isSuccessful()) {
                      setGooglePayAvailable(task.getResult());
                    } else {
                      Log.w("isReadyToPay failed", task.getException());
                    }
                  }
                });
          }
        

    Como neste exemplo, o Google Pay deve ser apresentado como uma opção de pagamento somente depois que você receber um resultado bem-sucedido da função isReadyToPay. É mais comum exibir um botão de pagamento do Google Pay por meio de um layout include ao implementar uma opção de pagamento. Consulte as diretrizes da promoção da marca para mais informações sobre os botões de pagamento, logotipos e marcas do Google Pay disponíveis para uso no aplicativo.

    Etapa 7: criar um objeto PaymentDataRequest

    Um objeto JSON PaymentDataRequest descreve as informações que você quer solicitar de um pagador na página de pagamento do Google Pay.

    Forneça informações sobre o preço da transação e o status do preço fornecido. Consulte a documentação do objeto JSON TransactionInfo para mais informações.

    O exemplo a seguir mostra como receber informações da transação, especificamente preço, status do preço e moeda.

    
          private static JSONObject getTransactionInfo(String price) throws JSONException {
            JSONObject transactionInfo = new JSONObject();
            transactionInfo.put("totalPrice", price);
            transactionInfo.put("totalPriceStatus", "FINAL");
            transactionInfo.put("countryCode", Constants.COUNTRY_CODE);
            transactionInfo.put("currencyCode", Constants.CURRENCY_CODE);
    
            return transactionInfo;
          }
        

    Forneça um nome de comerciante visível ao usuário. Consulte a documentação do objeto JSON MerchantInfo para mais informações.

    O exemplo a seguir mostra como conseguir o nome do comerciante:

    
          private static JSONObject getMerchantInfo() throws JSONException {
            return new JSONObject().put("merchantName", "Example Merchant");
          }
        

    Atribua seu objeto de solicitação básico a um novo objeto JSON PaymentDataRequest. Em seguida, adicione as formas de pagamento compatíveis com seu aplicativo, como qualquer configuração de dados adicionais esperados na resposta. Por fim, adicione informações sobre a transação e o comerciante que faz a solicitação.

    O exemplo a seguir mostra como solicitar dados de pagamento:

    
          public static Optional<JSONObject> getPaymentDataRequest(String price) {
            try {
              JSONObject paymentDataRequest = PaymentsUtil.getBaseRequest();
              paymentDataRequest.put(
                  "allowedPaymentMethods", new JSONArray().put(PaymentsUtil.getCardPaymentMethod()));
              paymentDataRequest.put("transactionInfo", PaymentsUtil.getTransactionInfo(price));
              paymentDataRequest.put("merchantInfo", PaymentsUtil.getMerchantInfo());
    
              /* An optional shipping address requirement is a top-level property of the PaymentDataRequest
              JSON object. */
              paymentDataRequest.put("shippingAddressRequired", true);
    
              JSONObject shippingAddressParameters = new JSONObject();
              shippingAddressParameters.put("phoneNumberRequired", false);
    
              JSONArray allowedCountryCodes = new JSONArray(Constants.SHIPPING_SUPPORTED_COUNTRIES);
    
              shippingAddressParameters.put("allowedCountryCodes", allowedCountryCodes);
              paymentDataRequest.put("shippingAddressParameters", shippingAddressParameters);
              return Optional.of(paymentDataRequest);
            } catch (JSONException e) {
              return Optional.empty();
            }
          }
        

    Consulte a documentação do objeto JSON PaymentDataRequest para mais informações.

    Etapa 8: registrar o manipulador de eventos para o gesto do usuário

    Defina um OnClickListener para solicitar a exibição de uma página de pagamento do Google Pay após a ativação de um botão de pagamento do Google Pay pelo usuário.

    
            mGooglePayButton.setOnClickListener(
                new View.OnClickListener() {
                  @Override
                  public void onClick(View view) {
                    requestPayment(view);
                  }
                });
        

    O objeto PaymentDataRequest é um Parcelable que representa uma solicitação de dados de pagamento e fornece as informações necessárias para aceitar um pagamento. Use a classe AutoResolveHelper para resolver automaticamente a Task e, em seguida, processe o resultado no método onActivityResult da classe Activity.

    Etapa 9: processar o objeto de resposta

    Um objeto PaymentData é retornado para onActivityResult após um pagador fornecer com êxito as informações solicitadas na página de pagamento do Google Pay.

    Converta uma resposta bem-sucedida em JSON para passar as informações de pagamento para o processador e apresentar uma confirmação de compra ao usuário. Se o transactionInfo.totalPriceStatus passado para PaymentDataRequest for ESTIMATED, será necessário mostrar um preço final antes de cobrar a forma de pagamento retornada.

    Extraia o token de pagamento da resposta paymentData. Se você implementar uma integração de gateway, passe esse token para o gateway sem nenhuma modificação.

    
          public void onActivityResult(int requestCode, int resultCode, Intent data) {
            switch (requestCode) {
                // value passed in AutoResolveHelper
              case LOAD_PAYMENT_DATA_REQUEST_CODE:
                switch (resultCode) {
                  case Activity.RESULT_OK:
                    PaymentData paymentData = PaymentData.getFromIntent(data);
                    handlePaymentSuccess(paymentData);
                    break;
                  case Activity.RESULT_CANCELED:
                    // Nothing to here normally - the user simply cancelled without selecting a
                    // payment method.
                    break;
                  case AutoResolveHelper.RESULT_ERROR:
                    Status status = AutoResolveHelper.getStatusFromIntent(data);
                    handleError(status.getStatusCode());
                    break;
                  default:
                    // Do nothing.
                }
    
                // Re-enables the Google Pay payment button.
                mGooglePayButton.setClickable(true);
                break;
            }
          }
        

    Consulte a referência de objeto JSON PaymentData para receber mais informações sobre o conteúdo e a estrutura da resposta.

    Reunir todas as informações

    O exemplo a seguir mostra um exemplo completo para um projeto configurado corretamente. Consulte os passos da configuração no nível do projeto na seção "Configurar seu projeto" em Configurar a API Google Pay.

    CheckoutActivity.java

    Esta Activity de exemplo supõe a existência de um botão de pagamento do Google Pay com um atributo ID de googlepay_button no seu layout.

        /*
         * Copyright 2017 Google Inc.
         *
         * Licensed under the Apache License, Version 2.0 (the "License");
         * you may not use this file except in compliance with the License.
         * You may obtain a copy of the License at
         *
         *     http://www.apache.org/licenses/LICENSE-2.0
         *
         * Unless required by applicable law or agreed to in writing, software
         * distributed under the License is distributed on an "AS IS" BASIS,
         * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
         * See the License for the specific language governing permissions and
         * limitations under the License.
         */
    
        package com.google.android.gms.samples.wallet;
    
        import android.app.Activity;
        import android.app.AlertDialog;
        import android.content.Intent;
        import android.os.Bundle;
        import android.support.annotation.NonNull;
        import android.util.Log;
        import android.view.View;
        import android.widget.ImageView;
        import android.widget.TextView;
        import android.widget.Toast;
        import com.google.android.gms.common.api.ApiException;
        import com.google.android.gms.common.api.Status;
        import com.google.android.gms.tasks.OnCompleteListener;
        import com.google.android.gms.tasks.Task;
        import com.google.android.gms.wallet.AutoResolveHelper;
        import com.google.android.gms.wallet.IsReadyToPayRequest;
        import com.google.android.gms.wallet.PaymentData;
        import com.google.android.gms.wallet.PaymentDataRequest;
        import com.google.android.gms.wallet.PaymentsClient;
        import java.util.Optional;
        import org.json.JSONException;
        import org.json.JSONObject;
    
        /**
         * Checkout implementation for the app
         */
        public class CheckoutActivity extends Activity {
          /**
           * A client for interacting with the Google Pay API.
           *
           * @see <a
           *     href="https://developers.google.com/android/reference/com/google/android/gms/wallet/PaymentsClient">PaymentsClient</a>
           */
          private PaymentsClient mPaymentsClient;
    
          /**
           * A Google Pay payment button presented to the viewer for interaction.
           *
           * @see <a href="https://developers.google.com/pay/api/android/guides/brand-guidelines">Google Pay
           *     payment button brand guidelines</a>
           */
          private View mGooglePayButton;
    
          /**
           * Arbitrarily-picked constant integer you define to track a request for payment data activity.
           *
           * @value #LOAD_PAYMENT_DATA_REQUEST_CODE
           */
          private static final int LOAD_PAYMENT_DATA_REQUEST_CODE = 991;
    
          private TextView mGooglePayStatusText;
    
          private ItemInfo mBikeItem = new ItemInfo("Simple Bike", 300 * 1000000, R.drawable.bike);
          private long mShippingCost = 90 * 1000000;
          /**
           * Initialize the Google Pay API on creation of the activity
           *
           * @see Activity#onCreate(android.os.Bundle)
           */
          @Override
          protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_checkout);
    
            // Set up the mock information for our item in the UI.
            initItemUI();
    
            mGooglePayButton = findViewById(R.id.googlepay_button);
            mGooglePayStatusText = findViewById(R.id.googlepay_status);
    
            // Initialize a Google Pay API client for an environment suitable for testing.
            // It's recommended to create the PaymentsClient object inside of the onCreate method.
            mPaymentsClient = PaymentsUtil.createPaymentsClient(this);
            possiblyShowGooglePayButton();
    
            mGooglePayButton.setOnClickListener(
                new View.OnClickListener() {
                  @Override
                  public void onClick(View view) {
                    requestPayment(view);
                  }
                });
          }
    
          /**
           * Determine the viewer's ability to pay with a payment method supported by your app and display a
           * Google Pay payment button.
           *
           * @see <a href=
           *     "https://developers.google.com/android/reference/com/google/android/gms/wallet/PaymentsClient.html#isReadyToPay(com.google.android.gms.wallet.IsReadyToPayRequest)">PaymentsClient#IsReadyToPay</a>
           */
          private void possiblyShowGooglePayButton() {
            final Optional<JSONObject> isReadyToPayJson = PaymentsUtil.getIsReadyToPayRequest();
            if (!isReadyToPayJson.isPresent()) {
              return;
            }
            IsReadyToPayRequest request = IsReadyToPayRequest.fromJson(isReadyToPayJson.get().toString());
            if (request == null) {
              return;
            }
    
            // The call to isReadyToPay is asynchronous and returns a Task. We need to provide an
            // OnCompleteListener to be triggered when the result of the call is known.
            Task<Boolean> task = mPaymentsClient.isReadyToPay(request);
            task.addOnCompleteListener(this,
                new OnCompleteListener<Boolean>() {
                  @Override
                  public void onComplete(@NonNull Task<Boolean> task) {
                    if (task.isSuccessful()) {
                      setGooglePayAvailable(task.getResult());
                    } else {
                      Log.w("isReadyToPay failed", task.getException());
                    }
                  }
                });
          }
    
          /**
           * If isReadyToPay returned {@code true}, show the button and hide the "checking" text. Otherwise,
           * notify the user that Google Pay is not available. Please adjust to fit in with your current
           * user flow. You are not required to explicitly let the user know if isReadyToPay returns {@code
           * false}.
           *
           * @param available isReadyToPay API response.
           */
          private void setGooglePayAvailable(boolean available) {
            if (available) {
              mGooglePayStatusText.setVisibility(View.GONE);
              mGooglePayButton.setVisibility(View.VISIBLE);
            } else {
              mGooglePayStatusText.setText(R.string.googlepay_status_unavailable);
            }
          }
    
          /**
           * Handle a resolved activity from the Google Pay payment sheet.
           *
           * @param requestCode Request code originally supplied to AutoResolveHelper in requestPayment().
           * @param resultCode Result code returned by the Google Pay API.
           * @param data Intent from the Google Pay API containing payment or error data.
           * @see <a href="https://developer.android.com/training/basics/intents/result">Getting a result
           *     from an Activity</a>
           */
          @Override
          public void onActivityResult(int requestCode, int resultCode, Intent data) {
            switch (requestCode) {
                // value passed in AutoResolveHelper
              case LOAD_PAYMENT_DATA_REQUEST_CODE:
                switch (resultCode) {
                  case Activity.RESULT_OK:
                    PaymentData paymentData = PaymentData.getFromIntent(data);
                    handlePaymentSuccess(paymentData);
                    break;
                  case Activity.RESULT_CANCELED:
                    // Nothing to here normally - the user simply cancelled without selecting a
                    // payment method.
                    break;
                  case AutoResolveHelper.RESULT_ERROR:
                    Status status = AutoResolveHelper.getStatusFromIntent(data);
                    handleError(status.getStatusCode());
                    break;
                  default:
                    // Do nothing.
                }
    
                // Re-enables the Google Pay payment button.
                mGooglePayButton.setClickable(true);
                break;
            }
          }
    
          /**
           * PaymentData response object contains the payment information, as well as any additional
           * requested information, such as billing and shipping address.
           *
           * @param paymentData A response object returned by Google after a payer approves payment.
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#PaymentData">Payment
           *     Data</a>
           */
          private void handlePaymentSuccess(PaymentData paymentData) {
            String paymentInformation = paymentData.toJson();
    
            // Token will be null if PaymentDataRequest was not constructed using fromJson(String).
            if (paymentInformation == null) {
              return;
            }
            JSONObject paymentMethodData;
    
            try {
              paymentMethodData = new JSONObject(paymentInformation).getJSONObject("paymentMethodData");
              // If the gateway is set to "example", no payment information is returned - instead, the
              // token will only consist of "examplePaymentMethodToken".
              if (paymentMethodData
                      .getJSONObject("tokenizationData")
                      .getString("type")
                      .equals("PAYMENT_GATEWAY")
                  && paymentMethodData
                      .getJSONObject("tokenizationData")
                      .getString("token")
                      .equals("examplePaymentMethodToken")) {
                AlertDialog alertDialog =
                    new AlertDialog.Builder(this)
                        .setTitle("Warning")
                        .setMessage(
                            "Gateway name set to \"example\" - please modify "
                                + "Constants.java and replace it with your own gateway.")
                        .setPositiveButton("OK", null)
                        .create();
                alertDialog.show();
              }
    
              String billingName =
                  paymentMethodData.getJSONObject("info").getJSONObject("billingAddress").getString("name");
              Log.d("BillingName", billingName);
              Toast.makeText(this, getString(R.string.payments_show_name, billingName), Toast.LENGTH_LONG)
                  .show();
    
              // Logging token string.
              Log.d("GooglePaymentToken", paymentMethodData.getJSONObject("tokenizationData").getString("token"));
            } catch (JSONException e) {
              Log.e("handlePaymentSuccess", "Error: " + e.toString());
              return;
            }
          }
    
          /**
           * At this stage, the user has already seen a popup informing them an error occurred. Normally,
           * only logging is required.
           *
           * @param statusCode will hold the value of any constant from CommonStatusCode or one of the
           *     WalletConstants.ERROR_CODE_* constants.
           * @see <a
           *     href="https://developers.google.com/android/reference/com/google/android/gms/wallet/WalletConstants#constant-summary">
           *     Wallet Constants Library</a>
           */
          private void handleError(int statusCode) {
            Log.w("loadPaymentData failed", String.format("Error code: %d", statusCode));
          }
    
          // This method is called when the Pay with Google button is clicked.
          public void requestPayment(View view) {
            // Disables the button to prevent multiple clicks.
            mGooglePayButton.setClickable(false);
    
            // The price provided to the API should include taxes and shipping.
            // This price is not displayed to the user.
            String price = PaymentsUtil.microsToString(mBikeItem.getPriceMicros() + mShippingCost);
    
            // TransactionInfo transaction = PaymentsUtil.createTransaction(price);
            Optional<JSONObject> paymentDataRequestJson = PaymentsUtil.getPaymentDataRequest(price);
            if (!paymentDataRequestJson.isPresent()) {
              return;
            }
            PaymentDataRequest request =
                PaymentDataRequest.fromJson(paymentDataRequestJson.get().toString());
    
            // Since loadPaymentData may show the UI asking the user to select a payment method, we use
            // AutoResolveHelper to wait for the user interacting with it. Once completed,
            // onActivityResult will be called with the result.
            if (request != null) {
              AutoResolveHelper.resolveTask(
                  mPaymentsClient.loadPaymentData(request), this, LOAD_PAYMENT_DATA_REQUEST_CODE);
            }
          }
    
          private void initItemUI() {
            TextView itemName = findViewById(R.id.text_item_name);
            ImageView itemImage = findViewById(R.id.image_item_image);
            TextView itemPrice = findViewById(R.id.text_item_price);
    
            itemName.setText(mBikeItem.getName());
            itemImage.setImageResource(mBikeItem.getImageResourceId());
            itemPrice.setText(PaymentsUtil.microsToString(mBikeItem.getPriceMicros()));
          }
        }
        
        

    PaymentsUtil.java

    Este arquivo de exemplo cria objetos JSON adequados para criar um IsReadyToPayRequest ou um PaymentDataRequest.

        /*
         * Copyright 2017 Google Inc.
         *
         * Licensed under the Apache License, Version 2.0 (the "License");
         * you may not use this file except in compliance with the License.
         * You may obtain a copy of the License at
         *
         *     http://www.apache.org/licenses/LICENSE-2.0
         *
         * Unless required by applicable law or agreed to in writing, software
         * distributed under the License is distributed on an "AS IS" BASIS,
         * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
         * See the License for the specific language governing permissions and
         * limitations under the License.
         */
    
        package com.google.android.gms.samples.wallet;
    
        import android.app.Activity;
        import com.google.android.gms.wallet.PaymentsClient;
        import com.google.android.gms.wallet.Wallet;
        import java.math.BigDecimal;
        import java.math.RoundingMode;
        import java.util.HashMap;
        import java.util.Optional;
        import org.json.JSONArray;
        import org.json.JSONException;
        import org.json.JSONObject;
    
        /**
         * Contains helper static methods for dealing with the Payments API.
         *
         * <p>Many of the parameters used in the code are optional and are set here merely to call out their
         * existence. Please consult the documentation to learn more and feel free to remove ones not
         * relevant to your implementation.
         */
        public class PaymentsUtil {
          private static final BigDecimal MICROS = new BigDecimal(1000000d);
    
          private PaymentsUtil() {}
    
          /**
           * Create a Google Pay API base request object with properties used in all requests.
           *
           * @return Google Pay API base request object.
           * @throws JSONException
           */
          private static JSONObject getBaseRequest() throws JSONException {
            return new JSONObject().put("apiVersion", 2).put("apiVersionMinor", 0);
          }
    
          /**
           * Creates an instance of {@link PaymentsClient} for use in an {@link Activity} using the
           * environment and theme set in {@link Constants}.
           *
           * @param activity is the caller's activity.
           */
          public static PaymentsClient createPaymentsClient(Activity activity) {
            Wallet.WalletOptions walletOptions =
                new Wallet.WalletOptions.Builder().setEnvironment(Constants.PAYMENTS_ENVIRONMENT).build();
            return Wallet.getPaymentsClient(activity, walletOptions);
          }
    
          /**
           * Gateway Integration: Identify your gateway and your app's gateway merchant identifier.
           *
           * <p>The Google Pay API response will return an encrypted payment method capable of being charged
           * by a supported gateway after payer authorization.
           *
           * <p>TODO: Check with your gateway on the parameters to pass and modify them in Constants.java.
           *
           * @return Payment data tokenization for the CARD payment method.
           * @throws JSONException
           * @see <a href=
           *     "https://developers.google.com/pay/api/android/reference/object#PaymentMethodTokenizationSpecification">PaymentMethodTokenizationSpecification</a>
           */
          private static JSONObject getGatewayTokenizationSpecification() throws JSONException {
            return new JSONObject(){{          put("type", "PAYMENT_GATEWAY");
              put("parameters", new JSONObject(){{            put("gateway", "example");
                put("gatewayMerchantId", "exampleGatewayMerchantId");
                }
              });
            }};
          }
    
          /**
           * {@code DIRECT} Integration: Decrypt a response directly on your servers. This configuration has
           * additional data security requirements from Google and additional PCI DSS compliance complexity.
           *
           * <p>Please refer to the documentation for more information about {@code DIRECT} integration. The
           * type of integration you use depends on your payment processor.
           *
           * @return Payment data tokenization for the CARD payment method.
           * @throws JSONException
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#PaymentMethodTokenizationSpecification">PaymentMethodTokenizationSpecification</a>
           */
          private static JSONObject getDirectTokenizationSpecification()
              throws JSONException, RuntimeException {
            if (Constants.DIRECT_TOKENIZATION_PARAMETERS.isEmpty()
                || Constants.DIRECT_TOKENIZATION_PUBLIC_KEY.isEmpty()
                || Constants.DIRECT_TOKENIZATION_PUBLIC_KEY == null
                || Constants.DIRECT_TOKENIZATION_PUBLIC_KEY == "REPLACE_ME") {
              throw new RuntimeException(
                  "Please edit the Constants.java file to add protocol version & public key.");
            }
            JSONObject tokenizationSpecification = new JSONObject();
    
            tokenizationSpecification.put("type", "DIRECT");
            JSONObject parameters = new JSONObject(Constants.DIRECT_TOKENIZATION_PARAMETERS);
            tokenizationSpecification.put("parameters", parameters);
    
            return tokenizationSpecification;
          }
    
          /**
           * Card networks supported by your app and your gateway.
           *
           * <p>TODO: Confirm card networks supported by your app and gateway & update in Constants.java.
           *
           * @return Allowed card networks
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#CardParameters">CardParameters</a>
           */
          private static JSONArray getAllowedCardNetworks() {
            return new JSONArray(Constants.SUPPORTED_NETWORKS);
          }
    
          /**
           * Card authentication methods supported by your app and your gateway.
           *
           * <p>TODO: Confirm your processor supports Android device tokens on your supported card networks
           * and make updates in Constants.java.
           *
           * @return Allowed card authentication methods.
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#CardParameters">CardParameters</a>
           */
          private static JSONArray getAllowedCardAuthMethods() {
            return new JSONArray(Constants.SUPPORTED_METHODS);
          }
    
          /**
           * Describe your app's support for the CARD payment method.
           *
           * <p>The provided properties are applicable to both an IsReadyToPayRequest and a
           * PaymentDataRequest.
           *
           * @return A CARD PaymentMethod object describing accepted cards.
           * @throws JSONException
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#PaymentMethod">PaymentMethod</a>
           */
          private static JSONObject getBaseCardPaymentMethod() throws JSONException {
            JSONObject cardPaymentMethod = new JSONObject();
            cardPaymentMethod.put("type", "CARD");
    
            JSONObject parameters = new JSONObject();
            parameters.put("allowedAuthMethods", getAllowedCardAuthMethods());
            parameters.put("allowedCardNetworks", getAllowedCardNetworks());
            // Optionally, you can add billing address/phone number associated with a CARD payment method.
            parameters.put("billingAddressRequired", true);
    
            JSONObject billingAddressParameters = new JSONObject();
            billingAddressParameters.put("format", "FULL");
    
            parameters.put("billingAddressParameters", billingAddressParameters);
    
            cardPaymentMethod.put("parameters", parameters);
    
            return cardPaymentMethod;
          }
    
          /**
           * Describe the expected returned payment data for the CARD payment method
           *
           * @return A CARD PaymentMethod describing accepted cards and optional fields.
           * @throws JSONException
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#PaymentMethod">PaymentMethod</a>
           */
          private static JSONObject getCardPaymentMethod() throws JSONException {
            JSONObject cardPaymentMethod = getBaseCardPaymentMethod();
            cardPaymentMethod.put("tokenizationSpecification", getGatewayTokenizationSpecification());
    
            return cardPaymentMethod;
          }
    
          /**
           * An object describing accepted forms of payment by your app, used to determine a viewer's
           * readiness to pay.
           *
           * @return API version and payment methods supported by the app.
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#IsReadyToPayRequest">IsReadyToPayRequest</a>
           */
          public static Optional<JSONObject> getIsReadyToPayRequest() {
            try {
              JSONObject isReadyToPayRequest = getBaseRequest();
              isReadyToPayRequest.put(
                  "allowedPaymentMethods", new JSONArray().put(getBaseCardPaymentMethod()));
    
              return Optional.of(isReadyToPayRequest);
            } catch (JSONException e) {
              return Optional.empty();
            }
          }
    
          /**
           * Provide Google Pay API with a payment amount, currency, and amount status.
           *
           * @return information about the requested payment.
           * @throws JSONException
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#TransactionInfo">TransactionInfo</a>
           */
          private static JSONObject getTransactionInfo(String price) throws JSONException {
            JSONObject transactionInfo = new JSONObject();
            transactionInfo.put("totalPrice", price);
            transactionInfo.put("totalPriceStatus", "FINAL");
            transactionInfo.put("countryCode", Constants.COUNTRY_CODE);
            transactionInfo.put("currencyCode", Constants.CURRENCY_CODE);
    
            return transactionInfo;
          }
    
          /**
           * Information about the merchant requesting payment information
           *
           * @return Information about the merchant.
           * @throws JSONException
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#MerchantInfo">MerchantInfo</a>
           */
          private static JSONObject getMerchantInfo() throws JSONException {
            return new JSONObject().put("merchantName", "Example Merchant");
          }
    
          /**
           * An object describing information requested in a Google Pay payment sheet
           *
           * @return Payment data expected by your app.
           * @see <a
           *     href="https://developers.google.com/pay/api/android/reference/object#PaymentDataRequest">PaymentDataRequest</a>
           */
          public static Optional<JSONObject> getPaymentDataRequest(String price) {
            try {
              JSONObject paymentDataRequest = PaymentsUtil.getBaseRequest();
              paymentDataRequest.put(
                  "allowedPaymentMethods", new JSONArray().put(PaymentsUtil.getCardPaymentMethod()));
              paymentDataRequest.put("transactionInfo", PaymentsUtil.getTransactionInfo(price));
              paymentDataRequest.put("merchantInfo", PaymentsUtil.getMerchantInfo());
    
              /* An optional shipping address requirement is a top-level property of the PaymentDataRequest
              JSON object. */
              paymentDataRequest.put("shippingAddressRequired", true);
    
              JSONObject shippingAddressParameters = new JSONObject();
              shippingAddressParameters.put("phoneNumberRequired", false);
    
              JSONArray allowedCountryCodes = new JSONArray(Constants.SHIPPING_SUPPORTED_COUNTRIES);
    
              shippingAddressParameters.put("allowedCountryCodes", allowedCountryCodes);
              paymentDataRequest.put("shippingAddressParameters", shippingAddressParameters);
              return Optional.of(paymentDataRequest);
            } catch (JSONException e) {
              return Optional.empty();
            }
          }
    
          /**
           * Converts micros to a string format accepted by {@link PaymentsUtil#getPaymentDataRequest}.
           *
           * @param micros value of the price.
           */
          public static String microsToString(long micros) {
            return new BigDecimal(micros).divide(MICROS).setScale(2, RoundingMode.HALF_EVEN).toString();
          }
        }