Android Integration von PayTM Payment Gateway

ausgewählt und auf Pay geklickt wurden. Diese Aktivität kommuniziert mehrmals mit dem Back-End-Server, um die Bestellung auszuführen. Ich habe detaillierte Kommentare zu jeder verwendeten Methode verfasst.

Schritt 1: Die Liste der Warenkorbelemente, die an den Server gesendet wurden, um eine neue Bestellung zu erstellen. Hier rufen wir den Endpunkt / prepareOrder auf, um die eindeutige Bestell-ID zu generieren.

Schritt 2: Sobald die Bestell-ID eingegangen ist, rufen wir als Nächstes auf. / getChecksum durch Übergabe der Bestell-ID zusammen mit anderen Parametern, um den Prüfsummen-Hash zu generieren.

Schritt 3: Sobald die Prüfsumme eingegangen ist, rufen wir pgService auf .startPaymentTransaction () um den Benutzer zum PayTM-Zahlungsbildschirm umzuleiten.

Schritt 4: Nach Abschluss der Zahlung wird / transactionStatus aufgerufen, um die Transaktion auf dem Server zu überprüfen. Hier übergeben wir dieselbe Bestell-ID um den Status zu überprüfen.

Schritt 5: Sobald der Transaktionsstatus empfangen wurde, wird dem Benutzer ein erfolgreicher oder fehlgeschlagener Bildschirm angezeigt, indem er showOrderStatus () aufruft. Methode.

 package info.androidhive.paytmgateway.ui.paytm;

android.content.Intent importieren;
android.os.Bundle importieren;
import android.support.v4.content.ContextCompat;
import android.view.MenuItem;
android.view.View importieren;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
android.widget.Toast importieren;

import com.paytm.pgsdk.PaytmOrder;
import com.paytm.pgsdk.PaytmPGService;
import com.paytm.pgsdk.PaytmPaymentTransactionCallback;
import com.wang.avi.AVLoadingIndicatorView;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import butterknife.BindView;
Buttermesser importieren.ButterKnife;
import butterknife.OnClick;
import info.androidhive.paytmgateway.BuildConfig;
import info.androidhive.paytmgateway.R;
info.androidhive.paytmgateway.app.Constants importieren;
import info.androidhive.paytmgateway.db.AppDatabase;
import info.androidhive.paytmgateway.db.model.CartItem;
import info.androidhive.paytmgateway.db.model.User;
import info.androidhive.paytmgateway.networking.model.AppConfig;
import info.androidhive.paytmgateway.networking.model.ChecksumResponse;
import info.androidhive.paytmgateway.networking.model.Order;
import info.androidhive.paytmgateway.networking.model.OrderItem;
import info.androidhive.paytmgateway.networking.model.PrepareOrderRequest;
import info.androidhive.paytmgateway.networking.model.PrepareOrderResponse;
import info.androidhive.paytmgateway.ui.base.BaseActivity;
info.androidhive.paytmgateway.ui.transactions.TransactionsActivity importieren;
import io.realm.Realm;
importieren retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
importieren timber.log.Timber;

public class PayTMActivity erweitert BaseActivity {
    @BindView (R.id.lbl_status)
    TextView lblStatus;

    @BindView (R.id.loader)
    AVLoadingIndicatorView loader;

    @BindView (R.id.icon_status)
    ImageView iconStatus;

    @BindView (R.id.status_message)
    TextView statusMessage;

    @BindView (R.id.title_status)
    TextView responseTitle;

    @BindView (R.id.btn_check_orders)
    TextView btnCheckOrders;

    @BindView (R.id.layout_order_placed)
    LinearLayout layoutOrderPlaced;

    privates Reich Reich;
    private AppConfig appConfig;
    privater Benutzer Benutzer;

    / **
     * Schritte zur Bestellabwicklung:
     * 1. Rufen Sie den Server an, um die Bestellung vorzubereiten. Womit eine neue Bestellung in der Datenbank erstellt wird
     * und gibt die eindeutige Bestellnummer zurück
     * 




     * 2. Sobald die Bestellnummer eingegangen ist, senden Sie die PayTM-Parameter an den Server, um die zu berechnen
     * Checksum Hash
     * 



     * 3. Senden Sie die PayTM-Parameter zusammen mit dem Prüfsummen-Hash an das PayTM-Gateway
     * 















































     * 4. Wenn die Zahlung abgeschlossen ist, senden Sie die Bestellnummer an den Server zurück, um die Bestätigung zu erhalten
     * Transaktionsstatus
     * /

    @Override
    protected void onCreate (Bundle savedInstanceState) {
        super.onCreate (savedInstanceState);
        setContentView (R.layout.activity_pay_tm);
        ButterKnife.bind (this);
        setToolbar ();
        enableToolbarUpNavigation ();
        getSupportActionBar (). setTitle (getString (R.string.title_preparing_order));
        changeStatusBarColor ();
        drin();
    }

    @Override
    public int getLayoutId () {
        return R.layout.activity_pay_tm;
    }

    private void init () {
        realm = Realm.getDefaultInstance ();
        realm.where (CartItem.class) .findAllAsync ()
                .addChangeListener (cartItems -> {

                });

        user = AppDatabase.getUser ();
        appConfig = realm.where (AppConfig.class) .findFirst ();

        prepareOrder ();
    }

    private void setStatus (int message) {
        lblStatus.setText (message);
    }

    / **
     * SCHRITT 1: Senden Sie alle Artikel des Einkaufswagens an den Server und erhalten Sie die
     * eindeutige Bestellnummer, die an PayTM gesendet werden muss
     * /
    private void prepareOrder () {
        setStatus (R.string.msg_preparing_order);

        List 

 cartItems = realm.where (CartItem.class) .findAll ();
        PrepareOrderRequest request = new PrepareOrderRequest ();
        List 









 orderItems = new ArrayList <> ();
        für (CartItem cartItem: cartItems) {
            OrderItem orderItem = new OrderItem ();
            orderItem.productId = cartItem.product.id;
            orderItem.quantity = cartItem.quantity;
            orderItems.add (orderItem);
        }

        request.orderItems = orderItems;

        getApi (). prepareOrder (request) .enqueue (neuer Callback 

 () {
            @Override
            public void onResponse (Aufruf  Aufruf, Antwort 










 Antwort) {
                if (! response.isSuccessful ()) {
                    handleUnknownError ();
                    showOrderStatus (false);
                    Rückkehr;
                }

                getChecksum (response.body ());
            }

            @Override
            public void onFailure (Call 






















 call, Throwable t) {
                handleError (t);
                showOrderStatus (false);
            }
        });
    }

    / **
     * SCHRITT 2:
     * Senden Sie die Parameter an den Server, um die Prüfsumme zu generieren
     * das muss an PayTM gesendet werden
     * /
    void getChecksum (PrepareOrderResponse-Antwort) {
        setStatus (R.string.msg_fetching_checksum);

        if (appConfig == null) {
            Timber.e ("App config ist null! Kann die Bestellung nicht aufgeben. Dies sollte normalerweise nicht passieren");
            // Benutzer zum Anmeldebildschirm navigieren
            launchLogin (PayTMActivity.this);
            Fertig();
            Rückkehr;
        }

        Map 


 paramMap = preparePayTmParams (Antwort);
        Timber.d ("PayTm Params:% s", paramMap);

        getApi (). getCheckSum (paramMap) .enqueue (neuer Callback 

 () {
            @Override
            public void onResponse (Aufruf  Aufruf, Antwort 















 Antwort) {
                if (! response.isSuccessful ()) {
                    Timber.e ("Netzwerkanruf fehlgeschlagen");
                    handleUnknownError ();
                    showOrderStatus (false);
                    Rückkehr;
                }

                Timber.d ("Checksum Received:" + response.body (). Checksum);

                // Fügen Sie die Prüfsumme zur vorhandenen Parameterliste hinzu und senden Sie sie an PayTM
                paramMap.put ("CHECKSUMHASH", response.body (). checksum);
                placeOrder (paramMap);
            }

            @Override
            public void onFailure (Call 






 call, Throwable t) {
                handleError (t);
                showOrderStatus (false);
            }
        });
    }

    public Map 
 preparePayTmParams (PrepareOrderResponse-Antwort) {
        Map  paramMap = new HashMap 
















 ();
        paramMap.put ("CALLBACK_URL", String.format (BuildConfig.PAYTM_CALLBACK_URL, response.orderGatewayId));
        paramMap.put ("CHANNEL_ID", appConfig.getChannel ());
        paramMap.put ("CUST_ID", "CUSTOMER_" + user.id);
        paramMap.put ("INDUSTRY_TYPE_ID", appConfig.getIndustryType ());
        paramMap.put ("MID", appConfig.getMerchantId ());
        paramMap.put ("WEBSITE", appConfig.getWebsite ());
        paramMap.put ("ORDER_ID", response.orderGatewayId);
        paramMap.put ("TXN_AMOUNT", response.amount);
        return paramMap;
    }


    / **
     * SCHRITT 3: Weiterleitung an das PayTM-Gateway mit den erforderlichen Parametern und der Prüfsumme
     * Dies leitet zu PayTM Gateway weiter und gibt uns die PayTM-Transaktionsantwort
     * /
    public void placeOrder (Karte 













































































 params) {
        setStatus (R.string.msg_redirecting_to_paytm);

        // Wahl zwischen PayTM-Inszenierung und Produktion
        PaytmPGService pgService = BuildConfig.IS_PATM_STAGIN? PaytmPGService.getStagingService (): PaytmPGService.getProductionService ();

        PaytmOrder Order = neue PaytmOrder (Parameter);

        pgService.initialize (Order, null);

        pgService.startPaymentTransaction (dies, wahr, wahr,
                new PaytmPaymentTransactionCallback () {
                    @Override
                    public void someUIErrorOccurred (String inErrorMessage) {
                        Timber.e ("someUIErrorOccurred:% s", inErrorMessage);
                        Fertig();
                        // In der Payment Gateway-Aktivität ist ein Benutzeroberflächenfehler aufgetreten.
                        // // Dies kann an der Initialisierung von Views in liegen
                        // Payment Gateway-Aktivität oder möglicherweise aufgrund von //
                        // initialisierung von webview. // Details zur Fehlermeldung
                        // Der Fehler ist aufgetreten.
                    }

                    @Override
                    public void onTransactionResponse (Bundle inResponse) {
                        Timber.d ("PayTM Transaction Response:% s", inResponse.toString ());
                        String orderId = inResponse.getString ("ORDERID");
                        verifyTransactionStatus (orderId);
                    }

                    @Override
                    public void networkNotAvailable () {// Wenn Netzwerk nicht
                        Timber.e ("networkNotAvailable");
                        Fertig();
                        // verfügbar, dann das
                        // Methode wird aufgerufen.
                    }

                    @Override
                    public void clientAuthenticationFailed (String inErrorMessage) {
                        Timber.e ("clientAuthenticationFailed:% s", inErrorMessage);
                        Fertig();
                        // Diese Methode wird aufgerufen, wenn die Clientauthentifizierung erfolgt
                        // gescheitert. // Fehler können folgende Gründe haben //
                        // 1. Serverfehler oder Ausfallzeit. // 2. Server kann nicht
                        // Prüfsumme generieren oder Prüfsummenantwort ist nicht in
                        // richtiges Format. // 3. Server konnte sich nicht authentifizieren
                        // dieser Client. Das ist der Wert von payt_STATUS ist 2. //
                        // Fehlermeldung beschreibt den Grund für den Fehler.
                    }

                    @Override
                    public void onErrorLoadingWebPage (int iniErrorCode,
                                                      String inErrorMessage, String inFailingUrl) {
                        Timber.e ("onErrorLoadingWebPage:% d |% s |% s", iniErrorCode, inErrorMessage, inFailingUrl);
                        Fertig();
                    }

                    @Override
                    public void onBackPressedCancelTransaction () {
                        Toast.makeText (PayTMActivity.this, "Zurück gedrückt. Transaktion abgebrochen", Toast.LENGTH_LONG) .show ();
                        Fertig();
                    }

                    @Override
                    public void onTransactionCancel (String inErrorMessage, Bundle inResponse) {
                        Timber.e ("onTransactionCancel:% s |% s", inErrorMessage, inResponse);
                        Fertig();
                    }
                });
    }

    / **
     * SCHRITT 4: Überprüfen des Transaktionsstatus nach Abschluss der PayTM-Transaktion
     * Dies veranlasst den Aufruf von server (own) -> server (PayTM), um den Transaktionsstatus zu überprüfen
     * /
    private void verifyTransactionStatus (String orderId) {
        setStatus (R.string.msg_verifying_status);
        getApi (). checkTransactionStatus (orderId) .enqueue (neuer Callback 

 () {
            @Override
            public void onResponse (Aufruf  Aufruf, Antwort 











 Antwort) {
                if (! response.isSuccessful ()) {
                    Timber.e ("Netzwerkanruf fehlgeschlagen");
                    handleUnknownError ();
                    showOrderStatus (false);
                    Rückkehr;
                }

                showOrderStatus (response.body (). status.equalsIgnoreCase (Constants.ORDER_STATUS_COMPLETED));
            }

            @Override
            public void onFailure (Call 























































 call, Throwable t) {
                handleError (t);
                showOrderStatus (false);
            }
        });
    }

    / *
     * Anzeigen des Auftragsstatus auf der Benutzeroberfläche. Dies schaltet die Benutzeroberfläche zwischen erfolgreichen und fehlgeschlagenen Fällen um
     * * /
    private void showOrderStatus (Boolean isSuccess) {
        loader.setVisibility (View.GONE);
        lblStatus.setVisibility (View.GONE);
        if (isSuccess) {
            iconStatus.setImageResource (R.drawable.baseline_check_black_48);
            iconStatus.setColorFilter (ContextCompat.getColor (this, R.color.colorGreen));
            responseTitle.setText (R.string.thank_you);
            statusMessage.setText (R.string.msg_order_placed_successfully);

            // Wenn die Bestellung erfolgreich aufgegeben wurde, löschen Sie den Warenkorb
            AppDatabase.clearCart ();
        } else {
            iconStatus.setImageResource (R.drawable.baseline_close_black_48);
            iconStatus.setColorFilter (ContextCompat.getColor (this, R.color.btn_remove_item));
            responseTitle.setText (R.string.order_failed);
            statusMessage.setText (R.string.msg_order_placed_failed);
        }

        layoutOrderPlaced.setVisibility (View.VISIBLE);
    }

    @OnClick (R.id.btn_check_orders)
    void onOrdersClick () {
        startActivity (neue Absicht (PayTMActivity.this, TransactionsActivity.class));
        Fertig();
    }

    @Override
    public boolean onOptionsItemSelected (Menüelement) {
        if (item.getItemId () == android.R.id.home) {
            Fertig();
            return true;
        }
        return super.onOptionsItemSelected (item);
    }

    @Override
    Geschützte Leere onDestroy () {
        super.onDestroy ();

        if (realm! = null) {
            realm.removeAllChangeListeners ();
            realm.close ();
        }
    }
}

4. Testen der App

Nachdem Sie die PayTM-Integration abgeschlossen haben, können Sie Ihre App (oder die in diesem Artikel bereitgestellte App) mit den bereitgestellten Anmeldeinformationen für den Testmodus testen.

5. Referenzen

Nachfolgend finden Sie nützliche Links, die Sie bei der Arbeit an diesem Projekt bereithalten können.
1 . PayTM Android SDK-Dokumentation
2 . PayTM REST API-Dokumentation
3 . PayTM-Testmodus-Anmeldeinformationen

Ich hoffe, dieser Artikel hat den PayTM-Integrationsprozess vereinfacht. Wenn Sie Fragen / Vorschläge haben, posten Sie diese bitte im Kommentarbereich unten.

Happy Coding 🙂