PayPal Android: Akceptowanie płatności PayPal / kartą kredytową


Przykład

W tym samouczku dowiemy się, jak skonfigurować zestaw SDK systemu Android PayPal do przetwarzania prostej płatności za pośrednictwem płatności PayPal lub zakupu kartą kredytową. Na końcu tego przykładu powinieneś mieć prosty przycisk w aplikacji, który po kliknięciu przekieruje użytkownika do PayPal w celu potwierdzenia ustalonej płatności, a następnie wróci użytkownika do aplikacji i zaloguje potwierdzenie płatności.

Pełny kod aplikacji dla tego przykładu jest dostępny w repozytorium Github dla deweloperów PayPal .

Zacznijmy.

Pierwszym krokiem jest uzyskanie i dodanie zestawu SDK do projektu . Dodajemy odniesienie do naszych zależności build.gradle w następujący sposób:

dependencies {
    compile 'com.paypal.sdk:paypal-android-sdk:2.14.1'
    ...
}

Teraz przechodzimy do naszego pliku MainActivity.java (lub gdziekolwiek chcesz dodać integrację przycisku PayPal) i dodajemy obiekt config dla naszego identyfikatora klienta i środowiska (piaskownicy), którego będziemy używać.

private static PayPalConfiguration config = new PayPalConfiguration()
    .environment(PayPalConfiguration.ENVIRONMENT_SANDBOX)
    .clientId("YOUR CLIENT ID");

Teraz stworzymy przycisk w onCreate(...) , który umożliwi nam przetworzenie płatności za pośrednictwem PayPal po kliknięciu.

@Override
protected void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    final Button button = (Button) findViewById(R.id.paypal_button);
}

Teraz musimy zdefiniować funkcjonalność tego przycisku. W swoim res> layout> głównym pliku XML możesz dodać następującą definicję przycisku, która zdefiniuje tekst i moduł obsługi onClick dla przycisku z identyfikatorem przycisku paypal_button.

<Button android:id="@+id/paypal_button"
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:text="@string/paypal_button"
    android:onClick="beginPayment" />

Po kliknięciu przycisk wywoła beginPayment(...) . Następnie możemy dodać tekst przycisku do naszego pliku strings.xml, na przykład:

<string name="paypal_button">Pay with PayPal</string>

Po umieszczeniu przycisku musimy teraz obsługiwać kliknięcie przycisku, aby rozpocząć przetwarzanie płatności. Dodaj następującą beginPayment(...) poniżej naszej poprzedniej metody onCreate(...) .

public void beginPayment(View view){
    Intent serviceConfig = new Intent(this, PayPalService.class);
    serviceConfig.putExtra(PayPalService.EXTRA_PAYPAL_CONFIGURATION, config);
    startService(serviceConfig);

    PayPalPayment payment = new PayPalPayment(new BigDecimal("5.65"), 
        "USD", "My Awesome Item", PayPalPayment.PAYMENT_INTENT_SALE);

    Intent paymentConfig = new Intent(this, PaymentActivity.class);
    paymentConfig.putExtra(PayPalService.EXTRA_PAYPAL_CONFIGURATION, config);
    paymentConfig.putExtra(PaymentActivity.EXTRA_PAYMENT, payment);
    startActivityForResult(paymentConfig, 0);
}

To, co robimy tutaj, to najpierw ustawienie intencji usługi ( serviceConfig ), przy użyciu config , którą wcześniej zdefiniowaliśmy dla naszego identyfikatora klienta i środowiska piaskownicy. Następnie określamy obiekt płatności, który chcemy przetworzyć. Na potrzeby tego przykładu ustalamy cenę statyczną, walutę i opis. W końcowej aplikacji wartości te należy uzyskać z tego, co użytkownik próbuje kupić w aplikacji. Na koniec skonfigurowaliśmy paymentConfig , dodając zarówno obiekty config i payment , które wcześniej zdefiniowaliśmy, i rozpoczynamy działanie.

W tym momencie użytkownik zostanie wyświetlony z ekranami logowania i płatności PayPal, co pozwoli mu wybrać, czy zapłacić PayPal, czy kartą kredytową (poprzez ręczne wprowadzenie lub card.io, jeśli kamera jest dostępna). Ten ekran będzie wyglądał mniej więcej tak:

Ekran potwierdzenia płatności PayPal

Po zakończeniu tej czynności musimy przygotować program obsługi, gdy system PayPal przekieruje użytkownika z powrotem do aplikacji po potwierdzeniu płatności lub anulowaniu. W tym celu onActivityResult(...) .

@Override
protected void onActivityResult (int requestCode, int resultCode, Intent data){
    if (resultCode == Activity.RESULT_OK){
        PaymentConfirmation confirm = data.getParcelableExtra(
            PaymentActivity.EXTRA_RESULT_CONFIRMATION);
        if (confirm != null){
            try {
                Log.i("sampleapp", confirm.toJSONObject().toString(4));

                // TODO: send 'confirm' to your server for verification

            } catch (JSONException e) {
                Log.e("sampleapp", "no confirmation data: ", e);
            }
        }
    } else if (resultCode == Activity.RESULT_CANCELED) {
        Log.i("sampleapp", "The user canceled.");
    } else if (resultCode == PaymentActivity.RESULT_EXTRAS_INVALID) {
        Log.i("sampleapp", "Invalid payment / config set");
    }
}

W ramach metody onActivityResult(...) sprawdzamy, czy resultCode to RESULT_OK (płatność potwierdzona przez użytkownika), RESULT_CANCELED (płatność anulowana przez użytkownika) lub RESULT_EXTRAS_INVALID (wystąpił problem z konfiguracją). W przypadku prawidłowego potwierdzenia otrzymujemy obiekt zwracany z płatności i, w tym przykładzie, logujemy go. To, co zostanie nam zwrócone, powinno wyglądać mniej więcej tak:

{
    "client": {
        "environment": "sandbox",
        "paypal_sdk_version": "2.14.1",
        "platform": "Android",
        "product_name": "PayPal-Android-SDK"
    },
    "response": {
        "create_time": "2016-05-02T15:33:43Z",
        "id": "PAY-0PG63447RB821630KK1TXGTY",
        "intent": "sale",
        "state": "approved"
    },
    "response_type": "payment"
}

Jeśli spojrzymy pod obiekt response , zobaczymy, że mamy state approved , co oznacza, że płatność została potwierdzona. W tym momencie obiekt ten należy wysłać na serwer, aby potwierdzić, że płatność faktycznie przeszła. Aby uzyskać więcej informacji na temat tych kroków, zobacz te dokumenty .

Naszym ostatnim krokiem jest oczyszczenie w naszym onDestroy(...) .

@Override
public void onDestroy(){
    stopService(new Intent(this, PayPalService.class));
    super.onDestroy();
}

To wszystko. W tym przykładzie stworzyliśmy prosty przycisk do przetwarzania płatności za pomocą PayPal lub karty kredytowej. Od tego momentu możesz rozwinąć tę próbkę w kilku kolejnych krokach:

  • Dynamiczne pobieranie informacji o płatnościach w oparciu o wybór produktu użytkownika w beginPayment(...) .
  • Wysłanie potwierdzenia płatności na serwer i sprawdzenie, czy płatność faktycznie przeszła.
  • Obsługa błędów i anulowania przypadków użytkowników w aplikacji.