导航菜单

页面标题

页面副标题

Hopscotch v9.7.2 - ReviewGuestCheckoutActivity.java 源代码

正在查看: Hopscotch v9.7.2 应用的 ReviewGuestCheckoutActivity.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件,支持语法高亮显示。 仅供安全研究与技术分析使用,严禁用于任何非法用途。请遵守相关法律法规。


package in.hopscotch.android.activity;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.webkit.WebView;
import androidx.annotation.NonNull;
import androidx.browser.customtabs.h;
import com.facebook.react.ReactInstanceManager;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableMap;
import com.payu.custombrowser.CustomBrowser;
import com.payu.custombrowser.PayUCustomBrowserCallback;
import com.payu.custombrowser.PayUWebChromeClient;
import com.payu.custombrowser.PayUWebViewClient;
import com.payu.custombrowser.bean.CustomBrowserConfig;
import com.payu.custombrowser.util.CBConstant;
import com.payu.india.Extras.PayUSdkDetails;
import com.payu.india.Model.PayuConfig;
import com.payu.india.Model.PayuHashes;
import com.payu.india.Payu.Payu;
import com.payu.paymentparamhelper.PaymentParams;
import com.payu.paymentparamhelper.PayuConstants;
import com.payu.paymentparamhelper.PostData;
import com.payu.upisdk.util.UpiConstant;
import com.segment.analytics.Properties;
import com.yalantis.ucrop.view.CropImageView;
import in.hopscotch.android.activity.OrderConfirmationActivityNew;
import in.hopscotch.android.api.ApiParam;
import in.hopscotch.android.api.RetrofitApiBuilder;
import in.hopscotch.android.api.factory.CheckoutApiFactory;
import in.hopscotch.android.api.factory.CustomerInfoApiFactory;
import in.hopscotch.android.api.factory.PayUApiFactory;
import in.hopscotch.android.api.factory.ShoppingCartApiFactory;
import in.hopscotch.android.api.factory.TrackingApiFactory;
import in.hopscotch.android.api.model.AllAddressItem;
import in.hopscotch.android.api.model.Bank;
import in.hopscotch.android.api.model.Card;
import in.hopscotch.android.api.model.CreditPromotionData;
import in.hopscotch.android.api.model.DialogDataItem;
import in.hopscotch.android.api.model.Header;
import in.hopscotch.android.api.model.HeaderItem;
import in.hopscotch.android.api.model.MessageBar;
import in.hopscotch.android.api.model.OrderConfirmationDetails;
import in.hopscotch.android.api.model.OrderDetails;
import in.hopscotch.android.api.model.OrderSummary;
import in.hopscotch.android.api.model.PaymentDetails;
import in.hopscotch.android.api.model.PromoItem;
import in.hopscotch.android.api.model.PromotionData;
import in.hopscotch.android.api.model.ReviewCartItem;
import in.hopscotch.android.api.model.ShoppingBagResponse;
import in.hopscotch.android.api.model.TotalOrderAmount;
import in.hopscotch.android.api.response.ActionResponse;
import in.hopscotch.android.api.response.CheckIsDomesticPayUResponse;
import in.hopscotch.android.api.response.CheckVPAResponse;
import in.hopscotch.android.api.response.Error;
import in.hopscotch.android.api.response.GCAddressResponse;
import in.hopscotch.android.api.response.InitJusPayResponse;
import in.hopscotch.android.api.response.LoginResponse;
import in.hopscotch.android.api.response.OrderConfirmationResponse;
import in.hopscotch.android.api.response.PaymentDetailResponse;
import in.hopscotch.android.api.response.PlaceOrderResponse;
import in.hopscotch.android.api.rest.HSRetrofitCallback;
import in.hopscotch.android.application.HsApplication;
import in.hopscotch.android.application.r;
import in.hopscotch.android.common.util.c;
import in.hopscotch.android.common.util.u;
import in.hopscotch.android.common.util.x;
import in.hopscotch.android.databinding.ei;
import in.hopscotch.android.domain.model.payment.Wallet;
import in.hopscotch.android.model.PayURequestHelper;
import in.hopscotch.android.model.UserStatus;
import in.hopscotch.android.payment.PaymentStateActivity;
import in.hopscotch.android.ui.orders.OrdersMainActivity;
import in.hopscotch.android.util.t;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import kotlin.jvm.internal.Intrinsics;
import net.mischneider.MSREventBridgeModule;
import org.json.JSONException;
import org.json.JSONObject;
import retrofit2.Response;

public class ReviewGuestCheckoutActivity extends in.hopscotch.android.activity.base.c implements net.mischneider.a, net.mischneider.b, r.a, t.a {
    private static final String TAG = "ReviewGuestCheckoutActi";
    public static final int q = 0;
    private String addressType;
    private boolean backButtonPressedWhilePOL;
    private ei binding;
    private String cardType;
    private boolean enableAutoApprove;
    private String fromLocation;
    private String fromScreen;
    private boolean isFromBuyNow;
    private String orderBarcodeForPayPal;
    private long orderIdForPayPal;
    private net.mischneider.d paymentCallback;
    private int paymentRetryCount;
    private boolean placeOrderStarted;
    private ReadableMap saveAddressReadableMap;
    private LoginResponse savedLoginResponse;
    private long startPayuTime;
    private String paymentCode = null;
    private Map<String, Object> saveCardMap = new HashMap();
    private int CUSTOM_TABS_INTENT = 8907;
    public final a p = new a(true);

    public class a extends androidx.activity.c0 {
        public a(boolean z) {
            super(z);
        }

        public final void d() {
            RetrofitApiBuilder.getInstance().cancelAllRequests();
            in.hopscotch.android.application.r.b().c().onBackPressed();
            ReviewGuestCheckoutActivity reviewGuestCheckoutActivity = ReviewGuestCheckoutActivity.this;
            if (reviewGuestCheckoutActivity.backButtonPressedWhilePOL) {
                reviewGuestCheckoutActivity.Q1();
            }
        }
    }

    public class b extends HSRetrofitCallback<PlaceOrderResponse> {
        public final String a;
        public final Card b;
        public final String c;
        public final Bank d;
        public final Wallet e;
        public final String f;

        public b(String str, Card card, String str2, Bank bank, Wallet wallet, String str3) {
            this.a = str;
            this.b = card;
            this.c = str2;
            this.d = bank;
            this.e = wallet;
            this.f = str3;
        }

        @Override
        public final void onFailure(Throwable th) {
            ?? r3 = ReviewGuestCheckoutActivity.this;
            displayFailureMessage(r3, null);
            int i = ReviewGuestCheckoutActivity.q;
            r3.C1("placeOrderCompleted", null);
            ((ReviewGuestCheckoutActivity) r3).placeOrderStarted = false;
        }

        @Override
        public final void onResponse(Response<PlaceOrderResponse> response) {
            String str;
            long j;
            ?? r5 = ReviewGuestCheckoutActivity.this;
            if (response == null || !response.isSuccessful()) {
                displayFailureMessage(r5, response);
                int i = ReviewGuestCheckoutActivity.q;
                r5.C1("placeOrderCompleted", null);
            } else {
                if (response.body() != null) {
                    String str2 = ((PlaceOrderResponse) response.body()).action;
                    String str3 = in.hopscotch.android.util.a1.a;
                    if (ActionResponse.FAILURE.equalsIgnoreCase(str2) && ((PlaceOrderResponse) response.body()).dialog != null) {
                        ReviewGuestCheckoutActivity.x1(r5, ((PlaceOrderResponse) response.body()).dialog, null);
                        return;
                    }
                }
                PlaceOrderResponse placeOrderResponse = (PlaceOrderResponse) response.body();
                try {
                    String h = in.hopscotch.android.common.util.d.b().a().h(placeOrderResponse);
                    int i2 = ReviewGuestCheckoutActivity.q;
                    r5.getClass();
                    r5.C1("placeOrderCompleted", ReviewGuestCheckoutActivity.D1(h));
                } catch (Exception e) {
                    in.hopscotch.android.util.g.b(e);
                    int i3 = ReviewGuestCheckoutActivity.q;
                    r5.C1("placeOrderCompleted", null);
                }
                if (placeOrderResponse != null) {
                    String str4 = placeOrderResponse.action;
                    String str5 = in.hopscotch.android.util.a1.a;
                    if ("success".equalsIgnoreCase(str4)) {
                        r5.getClass();
                        String str6 = this.a;
                        if (str6 != null && !str6.equalsIgnoreCase("PAYU") && !str6.equalsIgnoreCase(ApiParam.INSTRUMENT_TYPE_UPI) && !str6.equalsIgnoreCase(PayuConstants.CASH)) {
                            if (in.hopscotch.android.common.util.t.a(str6) && str6.equalsIgnoreCase("PAYPAL")) {
                                long j2 = placeOrderResponse.orderId;
                                long j3 = placeOrderResponse.recordId;
                                String str7 = placeOrderResponse.orderBarcode;
                                HashMap o = android.support.v4.media.a.o("paymentCode", "POL", ApiParam.PaymentGatewayParams.PAYMENT_SYSTEM_TYPE, "PAYPAL");
                                HashMap hashMap = new HashMap();
                                hashMap.put("orderId", Long.valueOf(j2));
                                hashMap.put("recordId", Long.valueOf(j3));
                                CheckoutApiFactory.getInstance().makePaymentGatewayRequest(hashMap, o, new j5(r5, j2, str7));
                                return;
                            }
                            return;
                        }
                        long j4 = placeOrderResponse.recordId;
                        long j5 = placeOrderResponse.orderId;
                        String str8 = placeOrderResponse.orderBarcode;
                        HashMap hashMap2 = new HashMap();
                        Card card = this.b;
                        String str9 = this.c;
                        if (card != null) {
                            str = str8;
                            hashMap2.put("cardToken", card.card_token);
                            hashMap2.put("ccname", card.card_name);
                            hashMap2.put("ccvv", str9);
                            hashMap2.put(ApiParam.PlaceOrderParams.PAYU_PAYMENT_GATEWAY, card.card_mode);
                            hashMap2.put("storeCard", Integer.valueOf(card.isStoreCard() ? 1 : 0));
                        } else {
                            str = str8;
                        }
                        Bank bank = this.d;
                        if (bank != null && !TextUtils.isEmpty(bank.bankCode)) {
                            hashMap2.put("bankcode", bank.bankCode);
                            hashMap2.put(ApiParam.PlaceOrderParams.PAYU_PAYMENT_GATEWAY, PayuConstants.NB);
                        }
                        if (str6 == null || !str6.equalsIgnoreCase(ApiParam.INSTRUMENT_TYPE_UPI)) {
                            j = j5;
                        } else {
                            in.hopscotch.android.common.util.u.a.getClass();
                            j = j5;
                            String str10 = this.f;
                            if (u.a.a(str10)) {
                                hashMap2.put(ApiParam.PlaceOrderParams.PAYU_PAYMENT_GATEWAY, ApiParam.INSTRUMENT_TYPE_UPI);
                                hashMap2.put("pg", ApiParam.INSTRUMENT_TYPE_UPI);
                                hashMap2.put("vpa", str10);
                                hashMap2.put("enforce_paymethod", ApiParam.INSTRUMENT_TYPE_UPI);
                                hashMap2.put(ApiParam.PlaceOrderParams.PAYMENT_TYPE, ApiParam.INSTRUMENT_TYPE_UPI);
                                hashMap2.put("bankcode", ApiParam.INSTRUMENT_TYPE_UPI);
                            }
                        }
                        Wallet wallet = this.e;
                        if (str6 != null && str6.equalsIgnoreCase(PayuConstants.CASH) && wallet != null) {
                            hashMap2.put(ApiParam.PlaceOrderParams.PAYU_PAYMENT_GATEWAY, PayuConstants.CASH);
                            hashMap2.put("pg", PayuConstants.CASH);
                            hashMap2.put("enforce_paymethod", PayuConstants.CASH);
                            hashMap2.put(ApiParam.PlaceOrderParams.PAYMENT_TYPE, PayuConstants.CASH);
                            hashMap2.put("bankcode", wallet.getBankCode());
                        }
                        hashMap2.put("recordId", Long.valueOf(j4));
                        CheckoutApiFactory.getInstance().makePolPaymentForGC(hashMap2, new k5(r5, j, str, card, str9, bank, wallet, str6));
                        return;
                    }
                }
            }
            ((ReviewGuestCheckoutActivity) r5).placeOrderStarted = false;
        }
    }

    public class c extends PayUCustomBrowserCallback {
        public final String c;
        public final long d;
        public final String e;

        public c(String str, long j, String str2) {
            this.c = str;
            this.d = j;
            this.e = str2;
        }

        @Override
        public final void onBackApprove() {
            in.hopscotch.android.analytics.c m = in.hopscotch.android.analytics.c.m();
            long currentTimeMillis = System.currentTimeMillis();
            ReviewGuestCheckoutActivity reviewGuestCheckoutActivity = ReviewGuestCheckoutActivity.this;
            long j = currentTimeMillis - reviewGuestCheckoutActivity.startPayuTime;
            m.getClass();
            HashMap q = android.support.v4.media.c.q("from_screen", "Checkout");
            q.put("background_time", Long.valueOf(j));
            in.hopscotch.android.analytics.c.m().getClass();
            in.hopscotch.android.analytics.c.I("payu_payment_cancelled", q, true, true);
            reviewGuestCheckoutActivity.L1();
            reviewGuestCheckoutActivity.getClass();
            CustomerInfoApiFactory customerInfoApiFactory = CustomerInfoApiFactory.getInstance();
            long j2 = this.d;
            customerInfoApiFactory.getOrderConfirmation(j2, new l5(reviewGuestCheckoutActivity, false, j2, this.e));
            reviewGuestCheckoutActivity.placeOrderStarted = false;
        }

        @Override
        public final void onCBErrorReceived(int i, String str) {
            in.hopscotch.android.analytics.c m = in.hopscotch.android.analytics.c.m();
            long currentTimeMillis = System.currentTimeMillis();
            ReviewGuestCheckoutActivity reviewGuestCheckoutActivity = ReviewGuestCheckoutActivity.this;
            long j = currentTimeMillis - reviewGuestCheckoutActivity.startPayuTime;
            m.getClass();
            in.hopscotch.android.analytics.c.T(j, true);
            reviewGuestCheckoutActivity.placeOrderStarted = false;
        }

        @Override
        public final void onPaymentFailure(String str, String str2) {
            int i = ReviewGuestCheckoutActivity.q;
            ReviewGuestCheckoutActivity reviewGuestCheckoutActivity = ReviewGuestCheckoutActivity.this;
            reviewGuestCheckoutActivity.K1();
            in.hopscotch.android.analytics.c m = in.hopscotch.android.analytics.c.m();
            long currentTimeMillis = System.currentTimeMillis() - reviewGuestCheckoutActivity.startPayuTime;
            m.getClass();
            in.hopscotch.android.analytics.c.T(currentTimeMillis, true);
            reviewGuestCheckoutActivity.placeOrderStarted = false;
        }

        @Override
        public final void onPaymentSuccess(String str, String str2) {
            in.hopscotch.android.analytics.c m = in.hopscotch.android.analytics.c.m();
            long currentTimeMillis = System.currentTimeMillis();
            ReviewGuestCheckoutActivity reviewGuestCheckoutActivity = ReviewGuestCheckoutActivity.this;
            long j = currentTimeMillis - reviewGuestCheckoutActivity.startPayuTime;
            m.getClass();
            in.hopscotch.android.analytics.c.T(j, false);
            reviewGuestCheckoutActivity.getClass();
            CustomerInfoApiFactory customerInfoApiFactory = CustomerInfoApiFactory.getInstance();
            long j2 = this.d;
            customerInfoApiFactory.getOrderConfirmation(j2, new l5(reviewGuestCheckoutActivity, true, j2, this.e));
        }

        @Override
        public final void setCBProperties(WebView webView, com.payu.custombrowser.Bank bank) {
            webView.setWebChromeClient(new PayUWebChromeClient(bank));
            webView.setWebViewClient(new PayUWebViewClient(bank, this.c));
        }
    }

    public static void A1(HashMap hashMap) {
        List list;
        List list2;
        ShoppingBagResponse A = in.hopscotch.android.util.a1.A();
        HashMap hashMap2 = new HashMap();
        if (A != null) {
            OrderDetails orderDetails = A.orderDetails;
            if (orderDetails != null) {
                double d = orderDetails.productAmount;
                if (d > 0.0d) {
                    hashMap2.put("total_item_price", Double.valueOf(d));
                }
                float f = A.orderDetails.totalAmount;
                if (f > CropImageView.DEFAULT_ASPECT_RATIO) {
                    hashMap2.put("total_amount", Float.valueOf(f));
                }
                double d2 = A.orderDetails.discount;
                if (d2 > 0.0d) {
                    hashMap2.put("discount", Double.valueOf(d2));
                }
                double d3 = A.orderDetails.discountPercentage;
                if (d3 > 0.0d) {
                    hashMap2.put("discount_percentage", Double.valueOf(d3));
                }
                double d4 = A.orderDetails.shipping;
                if (d4 > 0.0d) {
                    hashMap2.put("shipping", Double.valueOf(d4));
                } else {
                    hashMap2.put("shipping", 0);
                }
                double d5 = A.orderDetails.payAmount;
                if (d5 > 0.0d) {
                    hashMap2.put("net_amount", Double.valueOf(d5));
                }
                int i = A.orderDetails.itemCount;
                if (i > 0) {
                    hashMap2.put("total_quantity", Integer.valueOf(i));
                }
            }
            List<ReviewCartItem> list3 = A.cartItems;
            if (list3 != null && list3.size() > 0) {
                hashMap2.put("sku_count", Integer.valueOf(A.cartItems.size()));
            }
            List arrayList = new ArrayList();
            CreditPromotionData creditPromotionData = A.creditPromotionData;
            if (creditPromotionData == null || (list2 = creditPromotionData.orderPromocodes) == null) {
                PromotionData promotionData = A.promotionData;
                if (promotionData != null && (list = promotionData.orderPromocodes) != null) {
                    arrayList = list;
                }
            } else {
                arrayList = list2;
            }
            if (arrayList.size() > 0) {
                for (int i2 = 0; i2 < arrayList.size(); i2++) {
                    if (((PromoItem) arrayList.get(i2)).applied && !TextUtils.isEmpty(((PromoItem) arrayList.get(i2)).code) && ((PromoItem) arrayList.get(i2)).discount > 0.0d) {
                        hashMap2.put("promo_code", ((PromoItem) arrayList.get(i2)).code);
                        hashMap2.put("promotion_discount", Double.valueOf(((PromoItem) arrayList.get(i2)).discount));
                    }
                }
            }
        }
        hashMap.putAll(hashMap2);
    }

    public static WritableMap D1(@NonNull String str) throws Exception {
        in.hopscotch.android.util.react.a d = in.hopscotch.android.util.react.a.d();
        JSONObject jSONObject = new JSONObject(str);
        d.getClass();
        return in.hopscotch.android.util.react.a.e(jSONObject);
    }

    public static void F1(net.mischneider.d dVar, WritableMap writableMap) {
        if (dVar != null) {
            ((MSREventBridgeModule.b.a) dVar).a(writableMap);
        }
    }

    public static HashMap P1(ReadableMap readableMap, boolean z) {
        Object obj;
        String str;
        if (readableMap == null) {
            return null;
        }
        HashMap hashMap = new HashMap();
        String string = readableMap.hasKey("shipToName") ? readableMap.getString("shipToName") : null;
        String string2 = readableMap.hasKey("city") ? readableMap.getString("city") : null;
        String string3 = readableMap.hasKey("zipCode") ? readableMap.getString("zipCode") : null;
        String string4 = readableMap.hasKey("streetAddress") ? readableMap.getString("streetAddress") : null;
        String string5 = readableMap.hasKey("landmark") ? readableMap.getString("landmark") : null;
        String string6 = readableMap.hasKey("cellPhone") ? readableMap.getString("cellPhone") : null;
        String string7 = readableMap.hasKey("state") ? readableMap.getString("state") : null;
        if (readableMap.hasKey("email")) {
            str = readableMap.getString("email");
            obj = "email";
        } else {
            obj = "email";
            str = null;
        }
        boolean z2 = readableMap.hasKey("defaultAddress") && readableMap.getBoolean("defaultAddress");
        String str2 = string6;
        boolean z3 = z2;
        String str3 = string5;
        String str4 = string4;
        if (in.hopscotch.android.util.a1.H(new String[]{string, string2, string3, string4, str2, string7})) {
            return null;
        }
        if (string != null) {
            hashMap.put("shipToName", string);
        }
        if (string2 != null) {
            hashMap.put("city", string2);
        }
        if (string3 != null) {
            hashMap.put("zipCode", string3);
        }
        if (str4 != null) {
            hashMap.put("streetAddress", str4);
        }
        if (!TextUtils.isEmpty(str3)) {
            hashMap.put("landmark", str3);
        }
        if (str2 != null) {
            hashMap.put("cellPhone", str2);
        }
        String str5 = string7;
        if (str5 != null) {
            hashMap.put("state", str5);
        }
        hashMap.put("defaultAddress", Boolean.valueOf(z3));
        if (!TextUtils.isEmpty(str) && z) {
            hashMap.put(obj, str);
        }
        return hashMap;
    }

    public static Card m1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity) {
        Map<String, Object> map = reviewGuestCheckoutActivity.saveCardMap;
        if (map != null && map.size() > 0) {
            Map map2 = (Map) reviewGuestCheckoutActivity.saveCardMap.get("cardData");
            if (map2.containsKey("isNewCard") && ((Boolean) map2.get("isNewCard")).booleanValue()) {
                Card card = new Card();
                card.card_bin = (String) map2.get("card_bin");
                card.card_no = (String) map2.get(com.payu.india.Payu.PayuConstants.CARD_NO);
                card.card_type = (String) map2.get("card_type");
                card.expiry_year = (String) map2.get("expiry_year");
                card.expiry_month = (String) map2.get("expiry_month");
                card.isDomestic = (String) map2.get(com.payu.india.Payu.PayuConstants.IS_DOMESTIC);
                card.card_mode = (String) map2.get(com.payu.india.Payu.PayuConstants.CARD_MODE);
                card.card_brand = (String) map2.get(com.payu.india.Payu.PayuConstants.CARD_BRAND);
                card.name_on_card = (String) map2.get("name_on_card");
                card.isPrimary = true;
                card.card_name = (String) map2.get("card_name");
                return card;
            }
        }
        return null;
    }

    public static void n1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity) {
        List<PromoItem> list;
        reviewGuestCheckoutActivity.getClass();
        try {
            ShoppingBagResponse A = in.hopscotch.android.util.a1.A();
            if (A == null || A.orderDetails == null) {
                return;
            }
            ArrayList arrayList = new ArrayList();
            ArrayList arrayList2 = new ArrayList();
            List<ReviewCartItem> list2 = A.cartItems;
            if (list2 != null && !list2.isEmpty()) {
                for (int i = 0; i < list2.size(); i++) {
                    arrayList.add(list2.get(i).sku);
                    arrayList2.add(list2.get(i).brandName);
                }
            }
            CreditPromotionData creditPromotionData = A.creditPromotionData;
            String str = (creditPromotionData == null || (list = creditPromotionData.orderPromocodes) == null || list.size() <= 0) ? null : A.creditPromotionData.orderPromocodes.get(0).code;
            in.hopscotch.android.analytics.facebook.a aVar = HsApplication.b().c;
            String obj = arrayList.toString();
            String obj2 = arrayList2.toString();
            OrderDetails orderDetails = A.orderDetails;
            aVar.g(obj, obj2, orderDetails.itemCount, orderDetails.totalAmount, str);
        } catch (Exception e) {
            in.hopscotch.android.util.g.b(e);
        }
    }

    public static void o1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, OrderConfirmationResponse orderConfirmationResponse) {
        TotalOrderAmount totalOrderAmount;
        reviewGuestCheckoutActivity.getClass();
        HashMap hashMap = new HashMap();
        OrderConfirmationDetails orderConfirmationDetails = orderConfirmationResponse.orderDetails;
        if (orderConfirmationDetails != null) {
            hashMap.put("order_id", Integer.valueOf(orderConfirmationDetails.orderId));
            hashMap.put("order_bar_code", orderConfirmationResponse.orderDetails.orderBarCode);
        }
        OrderSummary orderSummary = orderConfirmationResponse.orderSummary;
        if (orderSummary != null && (totalOrderAmount = orderSummary.totalOrderAmount) != null) {
            hashMap.put("revenue", totalOrderAmount.value);
        }
        hashMap.put(com.payu.india.Payu.PayuConstants.PAYU_CURRENCY, "INR");
        if (in.hopscotch.android.util.a1.A() != null) {
            ShoppingBagResponse A = in.hopscotch.android.util.a1.A();
            ArrayList arrayList = new ArrayList();
            for (int i = 0; i < A.cartItems.size(); i++) {
                ReviewCartItem reviewCartItem = A.cartItems.get(i);
                if (reviewCartItem != null) {
                    Properties.Product product = new Properties.Product(android.support.v4.media.b.i("", reviewCartItem.productId, new StringBuilder()), reviewCartItem.sku, reviewCartItem.orderPrice * reviewCartItem.quantity);
                    product.put("quantity", (Object) Integer.valueOf(reviewCartItem.quantity));
                    product.put("name", (Object) reviewCartItem.productName);
                    product.put("brand", (Object) reviewCartItem.brandName);
                    arrayList.add(product);
                }
            }
            hashMap.put("products", arrayList);
        }
        com.google.android.gms.internal.icing.v1.f("Order Completed", hashMap, false, false);
    }

    public static void p1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, OrderConfirmationResponse orderConfirmationResponse) {
        List<Object> list;
        List<HeaderItem> list2;
        reviewGuestCheckoutActivity.getClass();
        HashMap hashMap = new HashMap();
        OrderConfirmationDetails orderConfirmationDetails = orderConfirmationResponse.orderDetails;
        if (orderConfirmationDetails != null) {
            hashMap.put("order_id", Integer.valueOf(orderConfirmationDetails.orderId));
            if (orderConfirmationResponse.orderDetails.firstOrder) {
                hashMap.put("first_order", "Yes");
            }
            hashMap.put("discount", Double.valueOf(orderConfirmationResponse.orderDetails.discount));
            hashMap.put("discount_percentage", Double.valueOf(orderConfirmationResponse.orderDetails.discountPercentage));
            hashMap.put("promotion_discount", Double.valueOf(orderConfirmationResponse.orderDetails.promoDiscount));
            hashMap.put("promo_code", orderConfirmationResponse.orderDetails.promoCode);
            hashMap.put("total_amount", Double.valueOf(orderConfirmationResponse.orderDetails.totalAmount));
            hashMap.put("shipping", Double.valueOf(orderConfirmationResponse.orderDetails.shipping));
            hashMap.put("total_quantity", Integer.valueOf(orderConfirmationResponse.orderDetails.totalQuantity));
            hashMap.put("total_item_price", Double.valueOf(orderConfirmationResponse.orderDetails.productAmount));
            hashMap.put("net_amount", Double.valueOf(orderConfirmationResponse.orderDetails.payAmount));
            hashMap.put("sku_count", Integer.valueOf(orderConfirmationResponse.orderDetails.itemCount));
            hashMap.put("credit", Double.valueOf(orderConfirmationResponse.orderDetails.totalCredit));
        }
        PaymentDetails paymentDetails = orderConfirmationResponse.paymentDetails;
        if (paymentDetails != null) {
            hashMap.put("payment_mode", paymentDetails.paymentMethod.equalsIgnoreCase(PayuConstants.NB) ? "Net banking" : orderConfirmationResponse.paymentDetails.paymentMethod);
            Map<String, Object> map = orderConfirmationResponse.paymentDetails.payuBankAvailableAPi;
            if (map == null || !map.containsKey("displayname") || orderConfirmationResponse.paymentDetails.payuBankAvailableAPi.get("displayname") == null) {
                hashMap.put("netbanking_bank", UpiConstant.NONE);
            } else {
                hashMap.put("netbanking_bank", orderConfirmationResponse.paymentDetails.payuBankAvailableAPi.get("displayname").toString());
            }
        }
        AllAddressItem allAddressItem = orderConfirmationResponse.address;
        if (allAddressItem != null) {
            hashMap.put("delivery_city", allAddressItem.city);
            hashMap.put("state", orderConfirmationResponse.address.state);
            hashMap.put(ApiParam.PIN_CODE, orderConfirmationResponse.address.zipCode);
        }
        if (orderConfirmationResponse.messageBar != null) {
            hashMap.put("message_count", CBConstant.TRANSACTION_STATUS_SUCCESS);
            String[] strArr = new String[orderConfirmationResponse.messageBars.size()];
            strArr[0] = orderConfirmationResponse.messageBar.message;
            hashMap.put("message_bar", strArr);
        } else {
            List<MessageBar> list3 = orderConfirmationResponse.messageBars;
            if (list3 != null) {
                hashMap.put("message_count", Integer.valueOf(list3.size()));
                String[] strArr2 = new String[orderConfirmationResponse.messageBars.size()];
                for (int i = 0; i < orderConfirmationResponse.messageBars.size(); i++) {
                    strArr2[i] = orderConfirmationResponse.messageBars.get(i).message;
                }
                hashMap.put("message_bar", strArr2);
            } else {
                hashMap.put("message_count", com.payu.india.Payu.PayuConstants.STRING_ZERO);
                hashMap.put("message_bar", UpiConstant.NONE);
            }
        }
        Header header = orderConfirmationResponse.header;
        if (header != null && (list2 = header.items) != null && list2.size() >= 1 && orderConfirmationResponse.header.items.get(1) != null) {
            hashMap.put("banner", orderConfirmationResponse.header.items.get(1).action);
        }
        hashMap.put("payu_time", Long.valueOf(reviewGuestCheckoutActivity.startPayuTime));
        if (!TextUtils.isEmpty(reviewGuestCheckoutActivity.addressType)) {
            hashMap.put("address", reviewGuestCheckoutActivity.addressType);
        }
        hashMap.put("payment_retry", Integer.valueOf(reviewGuestCheckoutActivity.paymentRetryCount));
        if (!TextUtils.isEmpty(reviewGuestCheckoutActivity.cardType)) {
            hashMap.put(com.payu.india.Payu.PayuConstants.CARD, reviewGuestCheckoutActivity.cardType);
        }
        if (hashMap.containsKey("payment_mode") && !TextUtils.isEmpty((String) hashMap.get("payment_mode")) && ((String) hashMap.get("payment_mode")).equals("CARD")) {
            hashMap.put("payment_mode", "Card");
        }
        hashMap.put("paymentOffersActive", Boolean.valueOf(orderConfirmationResponse.paymentOffersActive));
        OrderConfirmationDetails orderConfirmationDetails2 = orderConfirmationResponse.orderDetails;
        if (orderConfirmationDetails2 != null && (list = orderConfirmationDetails2.promoApplied) != null && !list.isEmpty()) {
            hashMap.put("promoApplied", in.hopscotch.android.core.util.a.b(in.hopscotch.android.core.util.a.a(orderConfirmationResponse.orderDetails.promoApplied)));
        }
        in.hopscotch.android.analytics.c.m().getClass();
        hashMap.putAll(in.hopscotch.android.analytics.c.c(true));
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.I("order_placed", hashMap, false, false);
    }

    public static void q1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, OrderConfirmationResponse orderConfirmationResponse) {
        reviewGuestCheckoutActivity.getClass();
        HashMap hashMap = new HashMap();
        PaymentDetails paymentDetails = orderConfirmationResponse.paymentDetails;
        if (paymentDetails != null) {
            hashMap.put("payment_mode", paymentDetails.paymentMethod.equalsIgnoreCase(PayuConstants.NB) ? "Net banking" : orderConfirmationResponse.paymentDetails.paymentMethod);
            Map<String, Object> map = orderConfirmationResponse.paymentDetails.payuBankAvailableAPi;
            if (map == null || !map.containsKey("displayname") || orderConfirmationResponse.paymentDetails.payuBankAvailableAPi.get("displayname") == null) {
                hashMap.put("netbanking_bank", UpiConstant.NONE);
            } else {
                hashMap.put("netbanking_bank", orderConfirmationResponse.paymentDetails.payuBankAvailableAPi.get("displayname").toString());
            }
        }
        AllAddressItem allAddressItem = orderConfirmationResponse.address;
        if (allAddressItem != null) {
            hashMap.put("delivery_city", allAddressItem.city);
            hashMap.put("state", orderConfirmationResponse.address.state);
            hashMap.put(ApiParam.PIN_CODE, orderConfirmationResponse.address.zipCode);
        }
        if (!TextUtils.isEmpty(in.hopscotch.android.db.a.h())) {
            hashMap.put("checkout_user", in.hopscotch.android.db.a.h());
        }
        if (hashMap.containsKey("payment_mode") && !TextUtils.isEmpty((String) hashMap.get("payment_mode")) && ((String) hashMap.get("payment_mode")).equals("CARD")) {
            hashMap.put("payment_mode", "Card");
        }
        hashMap.put("step_duration", Long.valueOf(in.hopscotch.android.helper.a.c(true)));
        hashMap.put("total_duration", Long.valueOf(in.hopscotch.android.helper.a.b()));
        OrderConfirmationDetails orderConfirmationDetails = orderConfirmationResponse.orderDetails;
        if (orderConfirmationDetails != null) {
            hashMap.put("order_id", Integer.valueOf(orderConfirmationDetails.orderId));
            if (orderConfirmationResponse.orderDetails.firstOrder) {
                hashMap.put("first_order", "Yes");
            }
            if (orderConfirmationResponse.orderDetails.items != null) {
                for (int i = 0; i < orderConfirmationResponse.orderDetails.items.size(); i++) {
                    HashMap hashMap2 = new HashMap();
                    hashMap2.put("product_id", Integer.valueOf(orderConfirmationResponse.orderDetails.items.get(i).productId));
                    hashMap2.put("sku", orderConfirmationResponse.orderDetails.items.get(i).sku);
                    hashMap2.put(ApiParam.WishListParam.PRICE, Double.valueOf(orderConfirmationResponse.orderDetails.items.get(i).retailPrice));
                    hashMap2.put("mrp", Double.valueOf(orderConfirmationResponse.orderDetails.items.get(i).regularPrice));
                    hashMap2.put("discount_percentage", Integer.valueOf(orderConfirmationResponse.orderDetails.items.get(i).discountPercentage));
                    hashMap2.put("quantity", Integer.valueOf(orderConfirmationResponse.orderDetails.items.get(i).quantity));
                    hashMap2.put("revenue", Double.valueOf(orderConfirmationResponse.orderDetails.items.get(i).priceAfterAllDiscount));
                    hashMap2.put("delivery_days", Integer.valueOf(orderConfirmationResponse.orderDetails.items.get(i).deliveryDays));
                    hashMap2.put("name", orderConfirmationResponse.orderDetails.items.get(i).productName);
                    hashMap2.put("category", orderConfirmationResponse.orderDetails.items.get(i).category);
                    hashMap2.put("subcategory", orderConfirmationResponse.orderDetails.items.get(i).subcategory);
                    hashMap2.put("product_type", orderConfirmationResponse.orderDetails.items.get(i).productType);
                    hashMap2.put("subproduct_type", orderConfirmationResponse.orderDetails.items.get(i).subProductType);
                    hashMap2.put("brand", orderConfirmationResponse.orderDetails.items.get(i).brandName);
                    hashMap2.put("gender", orderConfirmationResponse.orderDetails.items.get(i).gender);
                    hashMap2.put("from_age", orderConfirmationResponse.orderDetails.items.get(i).fromAge);
                    hashMap2.put("to_age", orderConfirmationResponse.orderDetails.items.get(i).toAge);
                    hashMap2.put("preorder", Boolean.valueOf(orderConfirmationResponse.orderDetails.items.get(i).isPresale));
                    hashMap2.put("sale", Boolean.valueOf(orderConfirmationResponse.orderDetails.items.get(i).onSale));
                    hashMap2.put(ApiParam.PLpParam.COLOUR, orderConfirmationResponse.orderDetails.items.get(i).color);
                    hashMap2.put("size", orderConfirmationResponse.orderDetails.items.get(i).size);
                    hashMap2.put("image_url", orderConfirmationResponse.orderDetails.items.get(i).imgSrc);
                    hashMap.putAll(hashMap2);
                    if (!TextUtils.isEmpty((String) hashMap.get("sku"))) {
                        String str = (String) hashMap.get("sku");
                        in.hopscotch.android.analytics.c.m().getClass();
                        HashMap f0 = in.hopscotch.android.analytics.c.f0(str);
                        if (f0.size() > 0) {
                            hashMap.putAll(f0);
                        }
                    }
                    in.hopscotch.android.analytics.c.m().getClass();
                    in.hopscotch.android.analytics.c.I("product_ordered", hashMap, false, false);
                }
            }
        }
    }

    public static void r1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity) {
        reviewGuestCheckoutActivity.getClass();
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("payutime", System.currentTimeMillis() - reviewGuestCheckoutActivity.startPayuTime);
            in.hopscotch.android.util.react.a.d().getClass();
            reviewGuestCheckoutActivity.C1("paymentPolCompleted", in.hopscotch.android.util.react.a.e(jSONObject));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void s1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, String str, long j, String str2) {
        String str3;
        ?? r14;
        reviewGuestCheckoutActivity.getClass();
        if (TextUtils.isEmpty("payUResult")) {
            return;
        }
        try {
            JSONObject jSONObject = new JSONObject(str2);
            if (!jSONObject.get(com.payu.india.Payu.PayuConstants.FIELD9).toString().equalsIgnoreCase("success") || TextUtils.isEmpty(jSONObject.getString("orderId"))) {
                return;
            }
            in.hopscotch.android.application.a.e(0, reviewGuestCheckoutActivity);
            Long valueOf = Long.valueOf(jSONObject.getString("orderId"));
            String str4 = reviewGuestCheckoutActivity.addressType;
            String str5 = reviewGuestCheckoutActivity.cardType;
            Integer valueOf2 = Integer.valueOf(reviewGuestCheckoutActivity.paymentRetryCount);
            String stringExtra = reviewGuestCheckoutActivity.getIntent().getStringExtra("ADDRESS");
            String stringExtra2 = reviewGuestCheckoutActivity.getIntent().getStringExtra("CARD");
            Long valueOf3 = Long.valueOf(System.currentTimeMillis() - reviewGuestCheckoutActivity.startPayuTime);
            Boolean bool = Boolean.FALSE;
            OrderConfirmationActivityNew.i.getClass();
            str3 = "CARD";
            r14 = 0;
            try {
                OrderConfirmationActivityNew.a.a(reviewGuestCheckoutActivity, valueOf, str, str4, str5, valueOf2, stringExtra, stringExtra2, valueOf3, bool, false);
                reviewGuestCheckoutActivity.finish();
            } catch (Exception e) {
                e = e;
                Exception exc = e;
                try {
                    HashMap hashMap = new HashMap();
                    hashMap.put("postData", "{\"log\": \"Payment Error\", \"errorString\": " + str2 + "}");
                    TrackingApiFactory.getInstance().postTrackingData(hashMap, new m5(reviewGuestCheckoutActivity));
                } catch (Exception e2) {
                    in.hopscotch.android.util.g.b(e2);
                }
                in.hopscotch.android.util.g.b(exc);
                in.hopscotch.android.application.a.e(r14, reviewGuestCheckoutActivity);
                if (j != 0) {
                    Long valueOf4 = Long.valueOf(j);
                    String str6 = reviewGuestCheckoutActivity.addressType;
                    String str7 = reviewGuestCheckoutActivity.cardType;
                    Integer valueOf5 = Integer.valueOf(reviewGuestCheckoutActivity.paymentRetryCount);
                    String stringExtra3 = reviewGuestCheckoutActivity.getIntent().getStringExtra("ADDRESS");
                    String stringExtra4 = reviewGuestCheckoutActivity.getIntent().getStringExtra(str3);
                    Long valueOf6 = Long.valueOf(System.currentTimeMillis() - reviewGuestCheckoutActivity.startPayuTime);
                    Boolean bool2 = Boolean.TRUE;
                    OrderConfirmationActivityNew.i.getClass();
                    OrderConfirmationActivityNew.a.a(reviewGuestCheckoutActivity, valueOf4, str, str6, str7, valueOf5, stringExtra3, stringExtra4, valueOf6, bool2, false);
                } else {
                    OrdersMainActivity.b bVar = OrdersMainActivity.b.LISTING;
                    OrdersMainActivity.j.getClass();
                    Intent a2 = OrdersMainActivity.a.a(reviewGuestCheckoutActivity, "Checkout", (boolean) r14, bVar);
                    a2.putExtra("FROM_CHECKOUT", true);
                    a2.putExtra("payutime", System.currentTimeMillis() - reviewGuestCheckoutActivity.startPayuTime);
                    reviewGuestCheckoutActivity.startActivity(a2);
                }
                reviewGuestCheckoutActivity.finish();
            }
        } catch (Exception e3) {
            e = e3;
            str3 = "CARD";
            r14 = 0;
        }
    }

    public static JSONObject t1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, CheckIsDomesticPayUResponse checkIsDomesticPayUResponse) {
        reviewGuestCheckoutActivity.getClass();
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put(com.payu.india.Payu.PayuConstants.CARDTYPE, checkIsDomesticPayUResponse.cardType);
            jSONObject.put("cardBrand", checkIsDomesticPayUResponse.cardBrand);
            jSONObject.put(com.payu.india.Payu.PayuConstants.CARDCATEGORY, checkIsDomesticPayUResponse.cardCategory);
            jSONObject.put(com.payu.india.Payu.PayuConstants.IS_DOMESTIC, checkIsDomesticPayUResponse.isDomestic);
            jSONObject.put(com.payu.india.Payu.PayuConstants.ISSUINGBANK, checkIsDomesticPayUResponse.issuingBank);
            jSONObject.put(com.payu.india.Payu.PayuConstants.MSG, checkIsDomesticPayUResponse.msg);
            jSONObject.put("status", checkIsDomesticPayUResponse.status);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return jSONObject;
    }

    public static void u1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, GCAddressResponse gCAddressResponse, ReadableMap readableMap) {
        reviewGuestCheckoutActivity.getClass();
        String str = gCAddressResponse.action;
        if (str == null || !str.equalsIgnoreCase(ActionResponse.FAILURE)) {
            return;
        }
        reviewGuestCheckoutActivity.saveAddressReadableMap = readableMap;
        String str2 = gCAddressResponse.otpReason;
        if (str2 == null || TextUtils.isEmpty(str2)) {
            return;
        }
        in.hopscotch.android.util.w.a().c(gCAddressResponse.otpReason);
    }

    public static void v1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, long j, String str, PaymentDetailResponse paymentDetailResponse, Card card, String str2, Bank bank, Wallet wallet, String str3) {
        String str4;
        PostData paymentPostParams;
        reviewGuestCheckoutActivity.getClass();
        String str5 = PayuConstants.CASH;
        Payu.setInstance(reviewGuestCheckoutActivity);
        PayuHashes payuHashes = new PayuHashes();
        payuHashes.setPaymentHash(paymentDetailResponse.hash);
        payuHashes.setPaymentRelatedDetailsForMobileSdkHash(paymentDetailResponse.detailsForMobileSdkHash);
        payuHashes.setMerchantIbiboCodesHash(paymentDetailResponse.merchantCodesHash);
        payuHashes.setVasForMobileSdkHash(paymentDetailResponse.mobileSdkHash);
        PaymentParams paymentParams = new PaymentParams();
        paymentParams.setAmount(String.valueOf(paymentDetailResponse.amount));
        paymentParams.setTxnId(paymentDetailResponse.txnId);
        paymentParams.setProductInfo(paymentDetailResponse.productinfo);
        paymentParams.setUserCredentials(paymentDetailResponse.user_credentials);
        paymentParams.setFirstName(paymentDetailResponse.firstName);
        paymentParams.setEmail(paymentDetailResponse.email);
        paymentParams.setHash(payuHashes.getPaymentHash());
        paymentParams.setPhone(paymentDetailResponse.phone);
        paymentParams.setSurl("https://www.hopscotch.in/api" + paymentDetailResponse.surl);
        paymentParams.setFurl("https://www.hopscotch.in/api" + paymentDetailResponse.furl);
        if (card != null) {
            if (card.isNewCard()) {
                paymentParams.setCardNumber(card.card_no);
                paymentParams.setCardName(card.card_name);
                paymentParams.setNameOnCard(card.name_on_card);
                paymentParams.setCardBin(card.card_bin);
                paymentParams.setExpiryMonth(card.expiry_month);
                paymentParams.setExpiryYear(card.expiry_year);
                paymentParams.setStoreCard(card.isStoreCard() ? 1 : 0);
            } else {
                paymentParams.setCardToken(card.card_token);
            }
            paymentParams.setCvv(str2);
            com.google.android.gms.ads.internal.client.z0.n("last_used_card", card.card_no);
        } else if (bank != null) {
            paymentParams.setBankCode(bank.bankCode);
        }
        paymentParams.setUdf1("");
        paymentParams.setUdf2("");
        paymentParams.setUdf3("");
        paymentParams.setUdf4("");
        paymentParams.setUdf5("");
        try {
            Bundle bundle = reviewGuestCheckoutActivity.getPackageManager().getApplicationInfo(reviewGuestCheckoutActivity.getPackageName(), 128).metaData;
            str4 = paymentDetailResponse.key;
            paymentParams.setKey(str4);
            String str6 = card != null ? "CC" : PayuConstants.NB;
            if (str3 != null && str3.equalsIgnoreCase(ApiParam.INSTRUMENT_TYPE_UPI)) {
                String str7 = paymentDetailResponse.vpa;
                in.hopscotch.android.common.util.u.a.getClass();
                if (u.a.a(str7)) {
                    str6 = "upi";
                    paymentParams.setPg(ApiParam.INSTRUMENT_TYPE_UPI);
                    paymentParams.setBankCode(ApiParam.INSTRUMENT_TYPE_UPI);
                    paymentParams.setVpa(paymentDetailResponse.vpa);
                }
            }
            if (str3 == null || !str3.equalsIgnoreCase(PayuConstants.CASH) || wallet == null) {
                str5 = str6;
            } else {
                paymentParams.setBankCode(wallet.getBankCode());
                paymentParams.setPg(PayuConstants.CASH);
            }
            paymentPostParams = new com.payu.paymentparamhelper.a(paymentParams, str5).getPaymentPostParams();
        } catch (Exception e) {
            in.hopscotch.android.util.g.b(e);
            reviewGuestCheckoutActivity.K1();
        }
        if (paymentPostParams.getCode() != 0) {
            in.hopscotch.android.components.toast.a.d(reviewGuestCheckoutActivity.getApplicationContext(), 1, paymentPostParams.getResult());
            reviewGuestCheckoutActivity.K1();
            reviewGuestCheckoutActivity.placeOrderStarted = false;
        } else {
            PayuConfig payuConfig = new PayuConfig();
            payuConfig.setEnvironment(0);
            payuConfig.setData(paymentPostParams.getResult());
            reviewGuestCheckoutActivity.E1(j, str, payuConfig, paymentDetailResponse.txnId, str4);
        }
    }

    public static void w1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, String str) {
        reviewGuestCheckoutActivity.getClass();
        if (TextUtils.isEmpty(str)) {
            return;
        }
        in.hopscotch.android.components.toast.a.d(reviewGuestCheckoutActivity.getApplicationContext(), 1, str);
    }

    public static void x1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, DialogDataItem dialogDataItem, net.mischneider.d dVar) {
        InputMethodManager inputMethodManager;
        if (dVar != null) {
            reviewGuestCheckoutActivity.getClass();
            F1(dVar, null);
        }
        View currentFocus = reviewGuestCheckoutActivity.getCurrentFocus();
        if (currentFocus != null && (inputMethodManager = (InputMethodManager) reviewGuestCheckoutActivity.getSystemService("input_method")) != null) {
            inputMethodManager.hideSoftInputFromWindow(currentFocus.getWindowToken(), 2);
        }
        Intent intent = new Intent();
        intent.putExtra("saveCardMap", in.hopscotch.android.common.util.d.b().a().h(reviewGuestCheckoutActivity.saveCardMap));
        intent.putExtra("showDialogData", true);
        intent.putExtra("dialogData", dialogDataItem);
        reviewGuestCheckoutActivity.setResult(-1, intent);
        reviewGuestCheckoutActivity.finish();
    }

    public static void y1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, InitJusPayResponse initJusPayResponse, PlaceOrderResponse placeOrderResponse) {
        reviewGuestCheckoutActivity.getClass();
        Intent intent = new Intent((Context) reviewGuestCheckoutActivity, (Class<?>) PaymentStateActivity.class);
        intent.putExtra(ApiParam.PaymentGatewayParams.ADDRESS_TYPE, reviewGuestCheckoutActivity.addressType);
        intent.putExtra("juspayResponse", initJusPayResponse);
        intent.putExtra("juspayPayment", true);
        intent.putExtra("ORDER_ID", placeOrderResponse.orderId);
        reviewGuestCheckoutActivity.startActivityForResult(intent, 1998);
    }

    public static void z1(ReviewGuestCheckoutActivity reviewGuestCheckoutActivity, String str) {
        in.hopscotch.android.db.a.H(reviewGuestCheckoutActivity.addressType);
        androidx.browser.customtabs.h a2 = new h.d().a();
        Uri parse = Uri.parse(str);
        Intent intent = a2.a;
        intent.setData(parse);
        reviewGuestCheckoutActivity.startActivityForResult(intent, reviewGuestCheckoutActivity.CUSTOM_TABS_INTENT);
    }

    @Override
    public final void B() {
        InputMethodManager inputMethodManager;
        if (isDestroyed()) {
            return;
        }
        RetrofitApiBuilder.getInstance().cancelAllRequests();
        View currentFocus = getCurrentFocus();
        if (currentFocus != null && (inputMethodManager = (InputMethodManager) getSystemService("input_method")) != null) {
            inputMethodManager.hideSoftInputFromWindow(currentFocus.getWindowToken(), 2);
        }
        Intent intent = new Intent();
        String h = in.hopscotch.android.common.util.d.b().a().h(this.saveCardMap);
        if (this.backButtonPressedWhilePOL) {
            intent.putExtra("reloadCart", true);
        }
        intent.putExtra("saveCardMap", h);
        setResult(-1, intent);
        finish();
    }

    public final synchronized void B1(MSREventBridgeModule.b.a aVar, ReadableMap readableMap) {
        if (readableMap.hasKey("credits") && readableMap.hasKey("paymentCode")) {
            O1(aVar, readableMap.getString("paymentCode"), readableMap.getBoolean("credits"));
        }
    }

    public final void C1(String str, WritableMap writableMap) {
        MSREventBridgeModule.emitEventForActivity(this, this.binding.d, this, str, writableMap);
    }

    public final void D0() {
        in.hopscotch.android.helper.a.e();
    }

    public final void E1(long j, String str, PayuConfig payuConfig, String str2, String str3) {
        c cVar = new c(str3, j, str);
        CustomBrowserConfig customBrowserConfig = new CustomBrowserConfig(str3, str2);
        customBrowserConfig.setViewPortWideEnable(false);
        customBrowserConfig.setDisableBackButtonDialog(false);
        customBrowserConfig.setSdkVersionName(new PayUSdkDetails().getSdkVersionName());
        customBrowserConfig.setPostURL("https://secure.payu.in/_payment");
        customBrowserConfig.setPayuPostData(payuConfig.getData());
        customBrowserConfig.setMerchantSMSPermission(false);
        customBrowserConfig.setAutoSelectOTP(false);
        this.startPayuTime = System.currentTimeMillis();
        new CustomBrowser().addCustomBrowser((Activity) this, customBrowserConfig, (PayUCustomBrowserCallback) cVar);
    }

    public final void G1(ReadableMap readableMap, String str, boolean z) {
        in.hopscotch.android.util.react.a d = in.hopscotch.android.util.react.a.d();
        ReadableMap map = readableMap.getMap("eventData");
        d.getClass();
        HashMap g = in.hopscotch.android.util.react.a.g(map);
        if (!TextUtils.isEmpty((String) g.get("address")) && z) {
            this.addressType = (String) g.get("address");
        }
        if (this.isFromBuyNow) {
            g.put("source", "Buy now");
        }
        A1(g);
        in.hopscotch.android.analytics.c.m().getClass();
        g.putAll(in.hopscotch.android.analytics.c.c(z));
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.I(str, g, false, false);
    }

    public final void H1(ReadableMap readableMap, String str, boolean z) {
        in.hopscotch.android.util.react.a d = in.hopscotch.android.util.react.a.d();
        ReadableMap map = readableMap.getMap("eventData");
        d.getClass();
        HashMap g = in.hopscotch.android.util.react.a.g(map);
        if (this.isFromBuyNow) {
            g.put("source", "Buy now");
        }
        A1(g);
        in.hopscotch.android.analytics.c.m().getClass();
        g.putAll(in.hopscotch.android.analytics.c.c(z));
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.I(str, g, false, false);
    }

    public final void I1(ReadableMap readableMap, String str, boolean z) {
        in.hopscotch.android.util.react.a d = in.hopscotch.android.util.react.a.d();
        ReadableMap map = readableMap.getMap("eventData");
        d.getClass();
        HashMap g = in.hopscotch.android.util.react.a.g(map);
        if (!z && g.containsKey("payment_retry")) {
            this.paymentRetryCount = ((Integer) g.get("payment_retry")).intValue();
        }
        if (g.containsKey(com.payu.india.Payu.PayuConstants.CARD) && !TextUtils.isEmpty((String) g.get(com.payu.india.Payu.PayuConstants.CARD)) && z) {
            this.cardType = (String) g.get(com.payu.india.Payu.PayuConstants.CARD);
        }
        in.hopscotch.android.analytics.c.m().getClass();
        g.putAll(in.hopscotch.android.analytics.c.c(z));
        A1(g);
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.I(str, g, false, false);
    }

    public final void J1(ReadableMap readableMap, String str, boolean z) {
        in.hopscotch.android.util.react.a d = in.hopscotch.android.util.react.a.d();
        ReadableMap map = readableMap.getMap("eventData");
        d.getClass();
        HashMap g = in.hopscotch.android.util.react.a.g(map);
        if (this.isFromBuyNow) {
            g.put("source", "Buy now");
        }
        in.hopscotch.android.analytics.c.m().getClass();
        g.putAll(in.hopscotch.android.analytics.c.c(z));
        A1(g);
        in.hopscotch.android.analytics.c.m().getClass();
        in.hopscotch.android.analytics.c.I(str, g, false, false);
    }

    public final void K1() {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("payutime", System.currentTimeMillis() - this.startPayuTime);
            in.hopscotch.android.util.react.a.d().getClass();
            C1("payUFail", in.hopscotch.android.util.react.a.e(jSONObject));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public final void L1() {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("payutime", System.currentTimeMillis() - this.startPayuTime);
            in.hopscotch.android.util.react.a.d().getClass();
            C1("payuUserCancelled", in.hopscotch.android.util.react.a.e(jSONObject));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public final synchronized void M1(Card card, String str, Bank bank, Wallet wallet, String str2, String str3) {
        this.placeOrderStarted = true;
        HashMap hashMap = new HashMap();
        hashMap.put("paymentCode", "POL");
        CheckoutApiFactory.getInstance().placeOrderForGC(hashMap, new b(str2, card, str, bank, wallet, str3));
    }

    public final synchronized void N1(MSREventBridgeModule.b.a aVar, ReadableMap readableMap) {
        try {
            if (UserStatus.getInstance().getLoginStatus()) {
                boolean z = true;
                this.placeOrderStarted = true;
                HashMap hashMap = new HashMap();
                hashMap.put("paymentCode", "POL");
                if (!readableMap.hasKey("credits") || !readableMap.getBoolean("credits")) {
                    z = false;
                }
                hashMap.put(ApiParam.PlaceOrderParams.IS_CREDITS_APPLIED, Boolean.valueOf(z));
                CheckoutApiFactory.getInstance().placeOrderForGC(hashMap, new r5(this, readableMap, aVar));
            }
        } catch (Throwable th) {
            throw th;
        }
    }

    public final synchronized void O1(MSREventBridgeModule.b.a aVar, String str, boolean z) {
        this.placeOrderStarted = true;
        if (!UserStatus.getInstance().getLoginStatus()) {
            this.placeOrderStarted = false;
            return;
        }
        HashMap hashMap = new HashMap();
        hashMap.put("paymentCode", str);
        hashMap.put(ApiParam.PlaceOrderParams.IS_CREDITS_APPLIED, Boolean.valueOf(z));
        CheckoutApiFactory.getInstance().placeOrderForGC(hashMap, new t5(this, aVar));
    }

    public final void Q1() {
        InputMethodManager inputMethodManager;
        View currentFocus = getCurrentFocus();
        if (currentFocus != null && (inputMethodManager = (InputMethodManager) getSystemService("input_method")) != null) {
            inputMethodManager.hideSoftInputFromWindow(currentFocus.getWindowToken(), 2);
        }
        Intent intent = new Intent();
        intent.putExtra("saveCardMap", in.hopscotch.android.common.util.d.b().a().h(this.saveCardMap));
        intent.putExtra("reloadCart", true);
        setResult(-1, intent);
        finish();
    }

    public final void R1() {
        if (this.k != null) {
            this.k = null;
        }
        if (this.m != null) {
            this.m = null;
        }
    }

    @Override
    public final void S0(String str, boolean z) {
        ReadableMap readableMap = this.k;
        if (readableMap == null || this.m == null) {
            return;
        }
        String T0 = in.hopscotch.android.activity.base.c.T0(readableMap, ApiParam.LoginParam.LOGIN_ID);
        String T02 = in.hopscotch.android.activity.base.c.T0(this.k, ApiParam.LoginParam.OTP_REASON);
        String T03 = in.hopscotch.android.activity.base.c.T0(this.k, "pathUri");
        this.fromLocation = (!this.k.hasKey("from_location") || TextUtils.isEmpty(this.k.getString("from_location"))) ? this.fromLocation : this.k.getString("from_location");
        if (TextUtils.isEmpty(T0) || TextUtils.isEmpty(T02)) {
            F1(this.m, null);
            R1();
            return;
        }
        HashMap o = android.support.v4.media.a.o(ApiParam.LoginParam.LOGIN_ID, T0, ApiParam.LoginParam.OTP_REASON, T02);
        in.hopscotch.android.common.util.x.a.getClass();
        if (x.a.a(T0)) {
            W0();
        }
        CustomerInfoApiFactory.getInstance().sendPathOTP(T03, o, new h5(this));
    }

    @Override
    public final void V0(String str) {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("OTP", str);
            jSONObject.put("paymentCode", this.paymentCode);
            in.hopscotch.android.util.react.a.d().getClass();
            C1("autoReadOTP", in.hopscotch.android.util.react.a.e(jSONObject));
        } catch (Exception e) {
            in.hopscotch.android.util.g.b(e);
        }
    }

    public final void d(String str, ReadableMap readableMap, MSREventBridgeModule.b.a aVar) {
        Object obj;
        String str2;
        Object obj2;
        boolean z;
        if (TextUtils.isEmpty(str)) {
            return;
        }
        if (str.equalsIgnoreCase("loadPayment")) {
            CheckoutApiFactory.getInstance().gcOrderSummary(new o5(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("getCheckoutData")) {
            try {
                JSONObject jSONObject = new JSONObject("");
                in.hopscotch.android.util.react.a.d().getClass();
                F1(aVar, in.hopscotch.android.util.react.a.e(jSONObject));
                return;
            } catch (JSONException e) {
                in.hopscotch.android.util.g.b(e);
                F1(aVar, null);
                return;
            }
        }
        if (str.equalsIgnoreCase("saveAddress")) {
            if (readableMap == null) {
                F1(aVar, null);
                return;
            }
            HashMap P1 = P1(readableMap, true);
            if (P1 == null) {
                F1(aVar, null);
                return;
            } else {
                CustomerInfoApiFactory.getInstance().saveNewGCAddress(P1, new b5(this, aVar, readableMap));
                return;
            }
        }
        if (str.equalsIgnoreCase("updateAddress")) {
            if (readableMap == null) {
                F1(aVar, null);
                return;
            }
            String valueOf = readableMap.hasKey(ApiParam.CheckParam.Address.ADDRESS_ID) ? String.valueOf(readableMap.getInt(ApiParam.CheckParam.Address.ADDRESS_ID)) : null;
            String string = readableMap.hasKey("shipToName") ? readableMap.getString("shipToName") : null;
            String string2 = readableMap.hasKey("city") ? readableMap.getString("city") : null;
            String string3 = readableMap.hasKey("zipCode") ? readableMap.getString("zipCode") : null;
            String string4 = readableMap.hasKey("streetAddress") ? readableMap.getString("streetAddress") : null;
            String string5 = readableMap.hasKey("landmark") ? readableMap.getString("landmark") : null;
            String string6 = readableMap.hasKey("cellPhone") ? readableMap.getString("cellPhone") : null;
            String string7 = readableMap.hasKey("state") ? readableMap.getString("state") : null;
            if (readableMap.hasKey("email")) {
                str2 = readableMap.getString("email");
                obj = "email";
            } else {
                obj = "email";
                str2 = null;
            }
            if (readableMap.hasKey("defaultAddress") && readableMap.getBoolean("defaultAddress")) {
                obj2 = "landmark";
                z = true;
            } else {
                obj2 = "landmark";
                z = false;
            }
            String str3 = string4;
            String str4 = string3;
            String str5 = valueOf;
            String str6 = string2;
            if (in.hopscotch.android.util.a1.H(new String[]{valueOf, string, string2, str4, str3, string6, string7})) {
                F1(aVar, null);
                return;
            }
            HashMap o = android.support.v4.media.a.o("shipToName", string, "city", str6);
            o.put("zipCode", str4);
            o.put("streetAddress", str3);
            if (!TextUtils.isEmpty(string5)) {
                o.put(obj2, string5);
            }
            o.put("cellPhone", string6);
            o.put("state", string7);
            o.put("defaultAddress", Boolean.valueOf(z));
            if (!TextUtils.isEmpty(str2)) {
                o.put(obj, str2);
            }
            CustomerInfoApiFactory.getInstance().updateGCAddress(str5, o, new c5(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("getAddressList")) {
            CustomerInfoApiFactory.getInstance().getGCDeliveryAddresses(new z4(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("pincodeCheck")) {
            String string8 = (readableMap == null || !readableMap.hasKey(ApiParam.PIN_CODE)) ? null : readableMap.getString(ApiParam.PIN_CODE);
            if (TextUtils.isEmpty(string8)) {
                F1(aVar, null);
                return;
            } else {
                CustomerInfoApiFactory.getInstance().checkPinCode(string8, false, new d5(this, aVar));
                return;
            }
        }
        if (str.equalsIgnoreCase("selectDeliveryAddress")) {
            if (readableMap == null) {
                F1(aVar, null);
                return;
            }
            String valueOf2 = readableMap.hasKey(ApiParam.CheckParam.Address.ADDRESS_ID) ? String.valueOf(readableMap.getInt(ApiParam.CheckParam.Address.ADDRESS_ID)) : null;
            if (in.hopscotch.android.util.a1.H(new String[]{valueOf2})) {
                F1(aVar, null);
                return;
            } else {
                CustomerInfoApiFactory.getInstance().selectGCAddress(valueOf2, new e5(this, aVar, valueOf2));
                return;
            }
        }
        if (str.equalsIgnoreCase("proceedToShipping")) {
            HashMap hashMap = new HashMap();
            hashMap.put(ApiParam.AccountMobileParams.ACCOUNT_MOBILE, readableMap.getString(ApiParam.AccountMobileParams.ACCOUNT_MOBILE));
            CustomerInfoApiFactory.getInstance().getAccountMobile(hashMap, new f5(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("sendOTP")) {
            Y0(readableMap, aVar, str);
            return;
        }
        if (str.equalsIgnoreCase("verifyOTP")) {
            if (readableMap == null) {
                F1(aVar, null);
                return;
            }
            String T0 = in.hopscotch.android.activity.base.c.T0(readableMap, ApiParam.LoginParam.LOGIN_ID);
            String T02 = in.hopscotch.android.activity.base.c.T0(readableMap, ApiParam.LoginParam.OTP_REASON);
            String T03 = in.hopscotch.android.activity.base.c.T0(readableMap, "otpNumber");
            if (in.hopscotch.android.util.a1.H(new String[]{T0, T03, T02})) {
                F1(aVar, null);
                return;
            }
            HashMap o2 = android.support.v4.media.a.o(ApiParam.LoginParam.LOGIN_ID, T0, "otp", T03);
            o2.put(ApiParam.LoginParam.OTP_REASON, T02);
            CustomerInfoApiFactory.getInstance().verifyOTP(o2, new i5(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("getAddressList")) {
            CustomerInfoApiFactory.getInstance().getGCDeliveryAddresses(new z4(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("checkDomestic")) {
            PayURequestHelper.getApiPayURequest(this, 2132017625, false, CheckIsDomesticPayUResponse.class, new y4(this, aVar), new String[]{readableMap.getString("bin")});
            return;
        }
        if (str.equalsIgnoreCase("reviewCart")) {
            B();
            return;
        }
        if (str.equalsIgnoreCase("addCredit")) {
            Log.e(TAG, "addCredit: ");
            String string9 = readableMap.getString("creditName");
            if (UserStatus.getInstance().getLoginStatus()) {
                ShoppingCartApiFactory.getInstance().gcAddCredit(string9, new x4(this, aVar));
                return;
            }
            try {
                JSONObject jSONObject2 = new JSONObject();
                jSONObject2.put("loginStatus", false);
                in.hopscotch.android.util.react.a.d().getClass();
                F1(aVar, in.hopscotch.android.util.react.a.e(jSONObject2));
                return;
            } catch (JSONException e2) {
                in.hopscotch.android.util.g.b(e2);
                F1(aVar, null);
                return;
            }
        }
        if (str.equalsIgnoreCase("removeCredit")) {
            ShoppingCartApiFactory.getInstance().gcRemoveCredit(readableMap.getString("creditName"), new w4(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("getSavedCards")) {
            PayUApiFactory.getInstance().getUserCards(new g5(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase("placeOrderCod")) {
            if (this.placeOrderStarted) {
                return;
            }
            synchronized (this) {
                this.paymentCode = "COD";
                this.placeOrderStarted = true;
                HashMap hashMap2 = new HashMap();
                hashMap2.put("paymentCode", "COD");
                CheckoutApiFactory.getInstance().placeOrderForGC(hashMap2, new u5(this, aVar));
            }
            return;
        }
        if ("getNetbankingList".equalsIgnoreCase(str)) {
            PayUApiFactory.getInstance().getBanks(new w5(this, aVar));
            return;
        }
        if (str.equalsIgnoreCase(ApiParam.PdpParam.BUY_NOW)) {
            HashMap hashMap3 = new HashMap();
            hashMap3.put(ApiParam.CartParam.DISMISS, Boolean.FALSE);
            CheckoutApiFactory.getInstance().gcOrderNow(hashMap3, new p5(this, aVar));
        } else {
            if (str.equalsIgnoreCase("checkVPA")) {
                PayURequestHelper.getApiPayUUPIRequest(this, 2132017632, false, CheckVPAResponse.class, new q5(this, aVar), new String[]{readableMap.getString(ApiParam.PayURequestParam.PARAM)});
                return;
            }
            if (str.equalsIgnoreCase("payViaJusPay")) {
                if (this.placeOrderStarted) {
                    return;
                }
                N1(aVar, readableMap);
            } else {
                if (!str.equalsIgnoreCase("creditsCodPay") || this.placeOrderStarted) {
                    return;
                }
                B1(aVar, readableMap);
            }
        }
    }

    public final void onActivityResult(int i, int i2, Intent intent) {
        HashMap P1;
        super/*androidx.fragment.app.n*/.onActivityResult(i, i2, intent);
        if (i == 2058) {
            if (intent == null || !intent.getBooleanExtra("isFromAddAddress", false) || (P1 = P1(this.saveAddressReadableMap, false)) == null) {
                return;
            }
            CustomerInfoApiFactory.getInstance().saveNewGCAddress(P1, new a5(this));
            return;
        }
        if (i == this.CUSTOM_TABS_INTENT) {
            L1();
            long r = in.hopscotch.android.db.a.r();
            String q2 = in.hopscotch.android.db.a.q();
            in.hopscotch.android.db.a.r();
            CustomerInfoApiFactory.getInstance().getOrderConfirmation(r, new l5(this, false, r, q2));
            return;
        }
        if (i == 1998) {
            this.placeOrderStarted = false;
            if (i2 == 1999) {
                Q1();
                return;
            }
            if (i2 == 2000) {
                long longExtra = intent.getLongExtra("ORDER_ID", 0L);
                HashMap hashMap = new HashMap();
                hashMap.put("orderId", Long.valueOf(longExtra));
                CheckoutApiFactory.getInstance().orderFail(hashMap, new x5(this));
                net.mischneider.d dVar = this.paymentCallback;
                if (dVar != null) {
                    F1(dVar, null);
                    return;
                }
                return;
            }
            if (i2 == 1997 && intent != null && intent.hasExtra("errorData")) {
                JSONObject jSONObject = new JSONObject();
                try {
                    Error error = (Error) intent.getSerializableExtra("errorData");
                    if (error != null) {
                        jSONObject.put("errorData", new JSONObject(in.hopscotch.android.common.util.d.b().a().h(error)));
                        in.hopscotch.android.util.react.a.d().getClass();
                        F1(this.paymentCallback, in.hopscotch.android.util.react.a.e(jSONObject));
                    }
                } catch (Exception e) {
                    in.hopscotch.android.util.g.b(e);
                    net.mischneider.d dVar2 = this.paymentCallback;
                    if (dVar2 != null) {
                        F1(dVar2, null);
                    }
                }
            }
        }
    }

    public final void onBackPressed() {
        RetrofitApiBuilder.getInstance().cancelAllRequests();
        in.hopscotch.android.application.r.b().c().onBackPressed();
        if (this.backButtonPressedWhilePOL) {
            Q1();
        }
    }

    public final void onCreate(Bundle bundle) {
        super/*androidx.fragment.app.n*/.onCreate(bundle);
        String str = in.hopscotch.android.util.a1.a;
        LayoutInflater layoutInflater = getLayoutInflater();
        int i = ei.e;
        ei eiVar = (ei) androidx.databinding.p.M(layoutInflater, 2131559089, (ViewGroup) null, false, androidx.databinding.g.e());
        this.binding = eiVar;
        setContentView(eiVar.E());
        in.hopscotch.android.application.r.b().h(this);
        this.binding.d.setEventBridgeEventReceiver(this);
        this.isFromBuyNow = getIntent().getBooleanExtra("isFromBuyNow", false);
        Bundle bundleExtra = getIntent().getBundleExtra("userData");
        bundleExtra.putBoolean("isLoggedIn", UserStatus.getInstance().getLoginStatus());
        bundleExtra.putBoolean("isLowEndDevice", TextUtils.isEmpty(in.hopscotch.android.db.a.j()) || in.hopscotch.android.db.a.j().equalsIgnoreCase("low"));
        c.b.a.getClass();
        bundleExtra.putString("learnMoreLink", in.hopscotch.android.common.util.j.c());
        this.binding.d.startReactApplication(in.hopscotch.android.application.r.b().c(), "HSCheckout", bundleExtra);
        this.saveCardMap = (Map) in.hopscotch.android.common.util.d.b().a().b(HashMap.class, bundleExtra.getString("saveCardMap"));
        in.hopscotch.android.analytics.c m = in.hopscotch.android.analytics.c.m();
        boolean z = this.isFromBuyNow;
        m.getClass();
        in.hopscotch.android.analytics.c.F(null, z, true);
        androidx.activity.d0 onBackPressedDispatcher = getOnBackPressedDispatcher();
        a aVar = this.p;
        onBackPressedDispatcher.getClass();
        Intrinsics.checkNotNullParameter(aVar, "onBackPressedCallback");
        onBackPressedDispatcher.g(aVar);
    }

    @Override
    public final void onDestroy() {
        in.hopscotch.android.application.r.b().h(null);
        in.hopscotch.android.application.r.b().e(this);
        this.binding.d.unmountReactApplication();
        super.onDestroy();
        this.placeOrderStarted = false;
        this.saveCardMap = null;
    }

    public final void onPause() {
        in.hopscotch.android.application.r.b().f(this);
        super/*androidx.fragment.app.n*/.onPause();
    }

    public final void onResume() {
        in.hopscotch.android.application.r.b().g(this);
        super/*androidx.fragment.app.n*/.onResume();
    }

    public final void r0(com.facebook.react.bridge.ReadableMap r19, java.lang.String r20) {
        throw new UnsupportedOperationException("Method not decompiled: in.hopscotch.android.activity.ReviewGuestCheckoutActivity.r0(com.facebook.react.bridge.ReadableMap, java.lang.String):void");
    }

    public final ReactInstanceManager t0() {
        return in.hopscotch.android.application.r.b().c();
    }

    public final void x0() {
        in.hopscotch.android.helper.a.f();
    }
}