Crafto v9.3.3 - AddPaymentMethodActivity.java 源代码

package com.stripe.android.view;

import Hk.p;
import W1.a0;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.text.method.LinkMovementMethod;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.lifecycle.u0;
import androidx.lifecycle.v0;
import androidx.lifecycle.x0;
import com.stripe.android.CustomerSession;
import com.stripe.android.PaymentConfiguration;
import com.stripe.android.R;
import com.stripe.android.Stripe;
import com.stripe.android.databinding.AddPaymentMethodActivityBinding;
import com.stripe.android.model.PaymentMethod;
import com.stripe.android.model.PaymentMethodCreateParams;
import com.stripe.android.view.AddPaymentMethodActivityStarter;
import com.stripe.android.view.AddPaymentMethodViewModel;
import java.util.Set;
import kotlin.Metadata;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.Reflection;
import org.jetbrains.annotations.NotNull;

@Metadata
public final class AddPaymentMethodActivity extends StripeActivity {

    @NotNull
    public static final String PRODUCT_TOKEN = "AddPaymentMethodActivity";

    @NotNull
    public static final Companion Companion = new Companion(null);
    public static final int $stable = 8;

    @NotNull
    private final Hk.k args$delegate = Hk.l.b(new Function0<AddPaymentMethodActivityStarter.Args>() {
        {
            super(0);
        }

        @Override
        @NotNull
        public final AddPaymentMethodActivityStarter.Args invoke() {
            AddPaymentMethodActivityStarter.Args.Companion companion = AddPaymentMethodActivityStarter.Args.Companion;
            Intent intent = AddPaymentMethodActivity.this.getIntent();
            Intrinsics.checkNotNullExpressionValue(intent, "intent");
            return companion.create$payments_core_release(intent);
        }
    });

    @NotNull
    private final Hk.k stripe$delegate = Hk.l.b(new Function0<Stripe>() {
        {
            super(0);
        }

        @Override
        @NotNull
        public final Stripe invoke() {
            AddPaymentMethodActivityStarter.Args args;
            args = AddPaymentMethodActivity.this.getArgs();
            PaymentConfiguration paymentConfiguration$payments_core_release = args.getPaymentConfiguration$payments_core_release();
            if (paymentConfiguration$payments_core_release == null) {
                paymentConfiguration$payments_core_release = PaymentConfiguration.Companion.getInstance(AddPaymentMethodActivity.this);
            }
            Context applicationContext = AddPaymentMethodActivity.this.getApplicationContext();
            Intrinsics.checkNotNullExpressionValue(applicationContext, "applicationContext");
            return new Stripe(applicationContext, paymentConfiguration$payments_core_release.getPublishableKey(), paymentConfiguration$payments_core_release.getStripeAccountId(), false, (Set) null, 24, (DefaultConstructorMarker) null);
        }
    });

    @NotNull
    private final Hk.k paymentMethodType$delegate = Hk.l.b(new Function0<PaymentMethod.Type>() {
        {
            super(0);
        }

        @Override
        @NotNull
        public final PaymentMethod.Type invoke() {
            AddPaymentMethodActivityStarter.Args args;
            args = AddPaymentMethodActivity.this.getArgs();
            return args.getPaymentMethodType$payments_core_release();
        }
    });

    @NotNull
    private final Hk.k shouldAttachToCustomer$delegate = Hk.l.b(new Function0<Boolean>() {
        {
            super(0);
        }

        @Override
        @NotNull
        public final Boolean invoke() {
            PaymentMethod.Type paymentMethodType;
            boolean z;
            AddPaymentMethodActivityStarter.Args args;
            paymentMethodType = AddPaymentMethodActivity.this.getPaymentMethodType();
            if (paymentMethodType.isReusable) {
                args = AddPaymentMethodActivity.this.getArgs();
                if (args.getShouldAttachToCustomer$payments_core_release()) {
                    z = true;
                    return Boolean.valueOf(z);
                }
            }
            z = false;
            return Boolean.valueOf(z);
        }
    });

    @NotNull
    private final Hk.k addPaymentMethodView$delegate = Hk.l.b(new Function0<AddPaymentMethodView>() {
        {
            super(0);
        }

        @Override
        @NotNull
        public final AddPaymentMethodView invoke() {
            AddPaymentMethodActivityStarter.Args args;
            AddPaymentMethodView createPaymentMethodView;
            AddPaymentMethodActivity addPaymentMethodActivity = AddPaymentMethodActivity.this;
            args = addPaymentMethodActivity.getArgs();
            createPaymentMethodView = addPaymentMethodActivity.createPaymentMethodView(args);
            createPaymentMethodView.setId(R.id.stripe_add_payment_method_form);
            return createPaymentMethodView;
        }
    });

    @NotNull
    private final Hk.k viewModel$delegate = new u0(Reflection.getOrCreateKotlinClass(AddPaymentMethodViewModel.class), new Function0<x0>() {
        {
            super(0);
        }

        @Override
        @NotNull
        public final x0 invoke() {
            x0 viewModelStore = this.getViewModelStore();
            Intrinsics.checkNotNullExpressionValue(viewModelStore, "viewModelStore");
            return viewModelStore;
        }
    }, new Function0<v0.b>() {
        {
            super(0);
        }

        @Override
        @NotNull
        public final v0.b invoke() {
            Stripe stripe;
            AddPaymentMethodActivityStarter.Args args;
            stripe = AddPaymentMethodActivity.this.getStripe();
            args = AddPaymentMethodActivity.this.getArgs();
            return new AddPaymentMethodViewModel.Factory(stripe, args);
        }
    });

    @Metadata
    public static final class Companion {
        public Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        private Companion() {
        }
    }

    @Metadata
    public class WhenMappings {
        public static final int[] $EnumSwitchMapping$0;

        static {
            int[] iArr = new int[PaymentMethod.Type.values().length];
            iArr[PaymentMethod.Type.Card.ordinal()] = 1;
            iArr[PaymentMethod.Type.Fpx.ordinal()] = 2;
            iArr[PaymentMethod.Type.Netbanking.ordinal()] = 3;
            $EnumSwitchMapping$0 = iArr;
        }
    }

    private final void attachPaymentMethodToCustomer(PaymentMethod paymentMethod) {
        CustomerSession a;
        try {
            p.a aVar = Hk.p.b;
            a = CustomerSession.Companion.getInstance();
        } catch (Throwable th) {
            p.a aVar2 = Hk.p.b;
            a = Hk.q.a(th);
        }
        Throwable a2 = Hk.p.a(a);
        if (a2 != null) {
            finishWithResult(new AddPaymentMethodActivityStarter.Result.Failure(a2));
        } else {
            getViewModel().attachPaymentMethod$payments_core_release(a, paymentMethod).observe(this, new androidx.lifecycle.T() {
                public final void onChanged(Object obj) {
                    AddPaymentMethodActivity.m155attachPaymentMethodToCustomer$lambda8$lambda7(AddPaymentMethodActivity.this, (Hk.p) obj);
                }
            });
        }
    }

    public static final void m155attachPaymentMethodToCustomer$lambda8$lambda7(AddPaymentMethodActivity this$0, Hk.p result) {
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        Intrinsics.checkNotNullExpressionValue(result, "result");
        Object obj = result.a;
        Throwable a = Hk.p.a(obj);
        if (a == null) {
            this$0.finishWithPaymentMethod((PaymentMethod) obj);
            return;
        }
        this$0.setProgressBarVisible(false);
        String message = a.getMessage();
        if (message == null) {
            message = "";
        }
        this$0.showError(message);
    }

    private final void configureView(AddPaymentMethodActivityStarter.Args args) {
        Integer windowFlags$payments_core_release = args.getWindowFlags$payments_core_release();
        if (windowFlags$payments_core_release != null) {
            getWindow().addFlags(windowFlags$payments_core_release.intValue());
        }
        getViewStub$payments_core_release().setLayoutResource(R.layout.add_payment_method_activity);
        View inflate = getViewStub$payments_core_release().inflate();
        if (inflate == null) {
            throw new NullPointerException("null cannot be cast to non-null type android.view.ViewGroup");
        }
        AddPaymentMethodActivityBinding bind = AddPaymentMethodActivityBinding.bind((ViewGroup) inflate);
        Intrinsics.checkNotNullExpressionValue(bind, "bind(scrollView)");
        bind.root.addView(getAddPaymentMethodView());
        LinearLayout linearLayout = bind.root;
        Intrinsics.checkNotNullExpressionValue(linearLayout, "viewBinding.root");
        View createFooterView = createFooterView(linearLayout);
        if (createFooterView != null) {
            if (Build.VERSION.SDK_INT >= 22) {
                getAddPaymentMethodView().setAccessibilityTraversalBefore(createFooterView.getId());
                createFooterView.setAccessibilityTraversalAfter(getAddPaymentMethodView().getId());
            }
            bind.root.addView(createFooterView);
        }
        setTitle(getTitleStringRes());
    }

    private final View createFooterView(ViewGroup viewGroup) {
        if (getArgs().getAddPaymentMethodFooterLayoutId$payments_core_release() <= 0) {
            return null;
        }
        View inflate = getLayoutInflater().inflate(getArgs().getAddPaymentMethodFooterLayoutId$payments_core_release(), viewGroup, false);
        inflate.setId(R.id.stripe_add_payment_method_footer);
        if (!(inflate instanceof TextView)) {
            return inflate;
        }
        TextView textView = (TextView) inflate;
        U1.c.a(textView);
        a0.e(inflate);
        textView.setMovementMethod(LinkMovementMethod.getInstance());
        return inflate;
    }

    public static final void m156createPaymentMethod$lambda4(AddPaymentMethodActivity this$0, Hk.p result) {
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        Intrinsics.checkNotNullExpressionValue(result, "result");
        Object obj = result.a;
        Throwable a = Hk.p.a(obj);
        if (a == null) {
            PaymentMethod paymentMethod = (PaymentMethod) obj;
            if (this$0.getShouldAttachToCustomer()) {
                this$0.attachPaymentMethodToCustomer(paymentMethod);
                return;
            } else {
                this$0.finishWithPaymentMethod(paymentMethod);
                return;
            }
        }
        this$0.setProgressBarVisible(false);
        String message = a.getMessage();
        if (message == null) {
            message = "";
        }
        this$0.showError(message);
    }

    public final AddPaymentMethodView createPaymentMethodView(AddPaymentMethodActivityStarter.Args args) {
        int i = WhenMappings.$EnumSwitchMapping$0[getPaymentMethodType().ordinal()];
        if (i == 1) {
            return new AddPaymentMethodCardView(this, null, 0, args.getBillingAddressFields$payments_core_release(), 6, null);
        }
        if (i == 2) {
            return AddPaymentMethodFpxView.Companion.create$payments_core_release(this);
        }
        if (i == 3) {
            return AddPaymentMethodNetbankingView.Companion.create$payments_core_release(this);
        }
        throw new IllegalArgumentException("Unsupported Payment Method type: " + getPaymentMethodType().code);
    }

    private final void finishWithPaymentMethod(PaymentMethod paymentMethod) {
        finishWithResult(new AddPaymentMethodActivityStarter.Result.Success(paymentMethod));
    }

    private final void finishWithResult(AddPaymentMethodActivityStarter.Result result) {
        setProgressBarVisible(false);
        setResult(-1, new Intent().putExtras(result.toBundle()));
        finish();
    }

    private final AddPaymentMethodView getAddPaymentMethodView() {
        return (AddPaymentMethodView) this.addPaymentMethodView$delegate.getValue();
    }

    public final AddPaymentMethodActivityStarter.Args getArgs() {
        return (AddPaymentMethodActivityStarter.Args) this.args$delegate.getValue();
    }

    public final PaymentMethod.Type getPaymentMethodType() {
        return (PaymentMethod.Type) this.paymentMethodType$delegate.getValue();
    }

    private final boolean getShouldAttachToCustomer() {
        return ((Boolean) this.shouldAttachToCustomer$delegate.getValue()).booleanValue();
    }

    public final Stripe getStripe() {
        return (Stripe) this.stripe$delegate.getValue();
    }

    private final int getTitleStringRes() {
        int i = WhenMappings.$EnumSwitchMapping$0[getPaymentMethodType().ordinal()];
        if (i == 1) {
            return R.string.title_add_a_card;
        }
        if (i == 2) {
            return R.string.title_bank_account;
        }
        if (i == 3) {
            return R.string.title_bank_account;
        }
        throw new IllegalArgumentException("Unsupported Payment Method type: " + getPaymentMethodType().code);
    }

    private final AddPaymentMethodViewModel getViewModel() {
        return (AddPaymentMethodViewModel) this.viewModel$delegate.getValue();
    }

    public final void createPaymentMethod$payments_core_release(@NotNull AddPaymentMethodViewModel viewModel, PaymentMethodCreateParams paymentMethodCreateParams) {
        Intrinsics.checkNotNullParameter(viewModel, "viewModel");
        if (paymentMethodCreateParams == null) {
            return;
        }
        setProgressBarVisible(true);
        viewModel.createPaymentMethod$payments_core_release(paymentMethodCreateParams).observe(this, new androidx.lifecycle.T() {
            public final void onChanged(Object obj) {
                AddPaymentMethodActivity.m156createPaymentMethod$lambda4(AddPaymentMethodActivity.this, (Hk.p) obj);
            }
        });
    }

    @Override
    public void onActionSave() {
        createPaymentMethod$payments_core_release(getViewModel(), getAddPaymentMethodView().getCreateParams());
    }

    @Override
    public void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        configureView(getArgs());
        setResult(-1, new Intent().putExtras(AddPaymentMethodActivityStarter.Result.Canceled.INSTANCE.toBundle()));
    }

    @Override
    public void onProgressBarVisibilityChanged(boolean z) {
        getAddPaymentMethodView().setCommunicatingProgress(z);
    }

    public void onResume() {
        super/*androidx.fragment.app.FragmentActivity*/.onResume();
        getAddPaymentMethodView().requestFocus();
    }
}