Easycash v3.75.13 - PendingTransactionActivity.java 源代码

package com.fintopia.lender.module.pendingtransaction;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.viewpager.widget.ViewPager;
import butterknife.BindView;
import com.fintopia.lender.R;
import com.fintopia.lender.module.baseui.LenderCommonActivity;
import com.fintopia.lender.module.baseui.LenderCommonFragment;
import com.fintopia.lender.module.events.CloseSignEvent;
import com.fintopia.lender.module.events.EventLendSuccess;
import com.fintopia.lender.module.launch.AppGeneralConfigUtils;
import com.fintopia.lender.module.launch.model.LenderConfigKey;
import com.fintopia.lender.module.network.ILenderApiRoutes;
import com.fintopia.lender.module.pendingtransaction.fragment.PendingConfirmFragment;
import com.fintopia.lender.module.pendingtransaction.fragment.PendingMatchFragment;
import com.fintopia.lender.module.pendingtransaction.fragment.PendingReinvestFragment;
import com.fintopia.lender.module.pendingtransaction.fragment.PendingSignFragment;
import com.fintopia.lender.module.pendingtransaction.fragment.PendingTransactionFragment;
import com.fintopia.lender.module.traderecord.model.DebtProductType;
import com.fintopia.lender.module.traderecord.model.PendingEventResponse;
import com.fintopia.lender.module.traderecord.model.TransactionType;
import com.fintopia.lender.module.utils.SensorTrackEvent;
import com.google.android.material.tabs.TabLayout;
import com.lingyue.idnbaselib.framework.lifecycle.LifecycleEvent;
import com.lingyue.idnbaselib.framework.lifecycle.m;
import com.lingyue.idnbaselib.model.IdnObserver;
import com.lingyue.idnbaselib.utils.DevUtil;
import com.lingyue.idnbaselib.utils.ThirdPartEventUtils;
import com.lingyue.supertoolkit.widgets.SimpleFragmentPagerAdapter;
import com.sensorsdata.analytics.android.autotrack.aop.SensorsDataAutoTrackHelper;
import com.sensorsdata.analytics.android.sdk.SensorsDataInstrumented;
import com.yangqianguan.statistics.AutoTrackHelper;
import io.reactivex.disposables.Disposable;
import java.util.ArrayList;
import java.util.List;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
import org.json.JSONObject;

public class PendingTransactionActivity extends LenderCommonActivity {
    private TransactionType A;
    private TransactionType B;
    List<TransactionType> C = new ArrayList();
    private String D;
    private boolean E;
    private boolean F;
    private boolean G;
    public SimpleFragmentPagerAdapter adapter;

    @BindView(5530)
    TabLayout tlTabs;

    private PendingSignFragment f131u;

    private PendingReinvestFragment f132v;

    @BindView(6026)
    ViewPager vpTradeRecords;

    private PendingConfirmFragment f133w;

    private PendingTransactionFragment f134x;
    private PendingTransactionFragment y;
    private PendingMatchFragment z;

    static class AnonymousClass4 {
        static final int[] a;

        static {
            int[] iArr = new int[TransactionType.values().length];
            a = iArr;
            try {
                iArr[TransactionType.SIGN.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                a[TransactionType.REINVEST.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                a[TransactionType.CONFIRMING.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                a[TransactionType.MATCH.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                a[TransactionType.TOP_UP.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                a[TransactionType.WITHDRAW.ordinal()] = 6;
            } catch (NoSuchFieldError unused6) {
            }
        }
    }

    private void N(long j) {
        String str;
        this.f133w = new PendingConfirmFragment();
        StringBuilder sb = new StringBuilder();
        sb.append(getString(R.string.lender_confirming));
        if (j > 0) {
            str = "(" + j + ")";
        } else {
            str = "";
        }
        sb.append(str);
        this.adapter.a(this.f133w, sb.toString());
        this.C.add(TransactionType.CONFIRMING);
    }

    private void O(long j) {
        String str;
        this.z = new PendingMatchFragment();
        StringBuilder sb = new StringBuilder();
        sb.append(getString(R.string.lender_matching));
        if (j > 0) {
            str = "(" + j + ")";
        } else {
            str = "";
        }
        sb.append(str);
        this.adapter.a(this.z, sb.toString());
        this.C.add(TransactionType.MATCH);
    }

    private void P(long j) {
        String str;
        this.f132v = new PendingReinvestFragment();
        StringBuilder sb = new StringBuilder();
        sb.append(getString(R.string.lender_reinvest));
        if (j > 0) {
            str = "(" + j + ")";
        } else {
            str = "";
        }
        sb.append(str);
        this.adapter.a(this.f132v, sb.toString());
        this.C.add(TransactionType.REINVEST);
    }

    private void Q(long j) {
        String str;
        this.f131u = new PendingSignFragment();
        StringBuilder sb = new StringBuilder();
        sb.append(getString(R.string.lender_sign));
        if (j > 0) {
            str = "(" + j + ")";
        } else {
            str = "";
        }
        sb.append(str);
        this.adapter.a(this.f131u, sb.toString());
        this.C.add(TransactionType.SIGN);
    }

    private void R(long j) {
        String str;
        this.f134x = new PendingTransactionFragment();
        Bundle bundle = new Bundle();
        TransactionType transactionType = TransactionType.TOP_UP;
        bundle.putSerializable("intentKeyTradeType", transactionType);
        this.f134x.setArguments(bundle);
        StringBuilder sb = new StringBuilder();
        sb.append(getString(R.string.lender_top_up));
        if (j > 0) {
            str = "(" + j + ")";
        } else {
            str = "";
        }
        sb.append(str);
        this.adapter.a(this.f134x, sb.toString());
        this.C.add(transactionType);
    }

    private void S(long j) {
        String str;
        this.y = new PendingTransactionFragment();
        Bundle bundle = new Bundle();
        TransactionType transactionType = TransactionType.WITHDRAW;
        bundle.putSerializable("intentKeyTradeType", transactionType);
        this.y.setArguments(bundle);
        StringBuilder sb = new StringBuilder();
        sb.append(getString(R.string.lender_withdraw));
        if (j > 0) {
            str = "(" + j + ")";
        } else {
            str = "";
        }
        sb.append(str);
        this.adapter.a(this.y, sb.toString());
        this.C.add(transactionType);
    }

    private int T(PendingEventResponse pendingEventResponse) {
        PendingEventResponse.Body body = pendingEventResponse.body;
        if (body.waitSignatureCount > 0) {
            return getViewPagerIndexByType(TransactionType.SIGN);
        }
        if (body.waitConfirmCount > 0 && this.E) {
            return getViewPagerIndexByType(TransactionType.CONFIRMING);
        }
        if (body.waitAutoDebtMatchCount > 0 && this.F) {
            return getViewPagerIndexByType(TransactionType.MATCH);
        }
        if (body.waitReinvestCount > 0 && this.G) {
            return getViewPagerIndexByType(TransactionType.REINVEST);
        }
        if (body.waitTopUpCount > 0) {
            return getViewPagerIndexByType(TransactionType.TOP_UP);
        }
        if (body.waitWithdrawCount > 0) {
            return getViewPagerIndexByType(TransactionType.WITHDRAW);
        }
        return 0;
    }

    private void U() {
        this.vpTradeRecords.setAdapter(this.adapter);
        this.vpTradeRecords.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            public void onPageSelected(int i) {
                PendingTransactionActivity pendingTransactionActivity = PendingTransactionActivity.this;
                pendingTransactionActivity.B = pendingTransactionActivity.C.get(i);
                switch (AnonymousClass4.a[PendingTransactionActivity.this.B.ordinal()]) {
                    case 1:
                        ThirdPartEventUtils.y(PendingTransactionActivity.this, "lender_appdetail_btn_sign");
                        break;
                    case 2:
                        ThirdPartEventUtils.y(PendingTransactionActivity.this, "lender_appdetail_btn_invest");
                        break;
                    case 3:
                        ThirdPartEventUtils.y(PendingTransactionActivity.this, "lender_appdetail_btn_confirm");
                        break;
                    case 4:
                        ThirdPartEventUtils.y(PendingTransactionActivity.this, "lender_appdetail_btn_match");
                        break;
                    case 5:
                        ThirdPartEventUtils.y(PendingTransactionActivity.this, "lender_appdetail_btn_topup");
                        break;
                    case 6:
                        ThirdPartEventUtils.y(PendingTransactionActivity.this, "lender_appdetail_btn_withdraw");
                        break;
                }
                TabLayout.Tab tabAt = PendingTransactionActivity.this.tlTabs.getTabAt(i);
                PendingTransactionActivity.this.V(i, tabAt == null ? null : String.valueOf(tabAt.getText()));
            }

            public void onPageScrollStateChanged(int i) {
            }

            public void onPageScrolled(int i, float f, int i2) {
            }
        });
    }

    public void V(int i, String str) {
        try {
            SensorTrackEvent sensorTrackEvent = SensorTrackEvent.LENDER_TRANSACTION_DETAILS_TAB_CLICK;
            JSONObject a = sensorTrackEvent.a();
            a.put("tab_location", i);
            a.put("tab_name", str);
            a.put("financing_product_type", DebtProductType.getCurrentDebtProductTypeCode());
            ThirdPartEventUtils.G(this, (Fragment) null, sensorTrackEvent.b(), (String) null, a);
        } catch (Exception e) {
            DevUtil.a(e);
        }
    }

    private void W(SensorTrackEvent sensorTrackEvent) {
        try {
            JSONObject a = sensorTrackEvent.a();
            a.put("financing_product_type", DebtProductType.getCurrentDebtProductTypeCode());
            ThirdPartEventUtils.G(this, (Fragment) null, sensorTrackEvent.b(), (String) null, a);
        } catch (Exception e) {
            DevUtil.a(e);
        }
    }

    private void X(PendingEventResponse pendingEventResponse) {
        TransactionType transactionType = this.A;
        if (transactionType != null) {
            this.vpTradeRecords.setCurrentItem(getViewPagerIndexByType(transactionType));
        } else {
            this.vpTradeRecords.setCurrentItem(T(pendingEventResponse));
        }
    }

    public static void startPendingTransactionActivity(Context context, @Nullable TransactionType transactionType) {
        Intent intent = new Intent(context, (Class<?>) PendingTransactionActivity.class);
        intent.putExtra("parameterTransactionType", transactionType);
        context.startActivity(intent);
    }

    @Override
    protected void A() {
        super.A();
        this.adapter = new SimpleFragmentPagerAdapter(getSupportFragmentManager());
        this.tlTabs.setupWithViewPager(this.vpTradeRecords);
        this.tlTabs.addOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
            @Override
            @SensorsDataInstrumented
            public void onTabSelected(TabLayout.Tab tab) {
                SensorsDataAutoTrackHelper.trackTabLayoutSelected(this, tab);
                AutoTrackHelper.trackTabLayoutOnClick(tab);
            }

            @Override
            public void onTabReselected(TabLayout.Tab tab) {
            }

            @Override
            public void onTabUnselected(TabLayout.Tab tab) {
            }
        });
    }

    @Override
    protected void G(@NonNull Bundle bundle) {
        super.G(bundle);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void closeSignActivity(CloseSignEvent closeSignEvent) {
        finish();
    }

    @Override
    public int getLayoutID() {
        return R.layout.lender_activity_pending_transaction;
    }

    public int getViewPagerIndexByType(@NonNull TransactionType transactionType) {
        return this.C.indexOf(transactionType);
    }

    @Override
    protected void init() {
        super.init();
        AppGeneralConfigUtils o2 = AppGeneralConfigUtils.o();
        DebtProductType debtProductType = DebtProductType.RIGID_PAYMENT;
        this.D = o2.p(LenderConfigKey.DEBT_PRODUCT_TYPE, debtProductType.name());
        this.E = DebtProductType.REDEEM_WITH_REPAYMENT.name().equals(this.D);
        this.F = DebtProductType.AUTO_DEBT_MATCH.name().equals(this.D);
        this.G = debtProductType.name().equals(this.D);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void lendSuccess(EventLendSuccess eventLendSuccess) {
        finish();
    }

    public void modifyTabTitle(LenderCommonFragment lenderCommonFragment, String str) {
        if (lenderCommonFragment == null || TextUtils.isEmpty(str)) {
            return;
        }
        int c = this.adapter.c(lenderCommonFragment);
        if (this.tlTabs.getTabAt(c) != null) {
            this.tlTabs.getTabAt(c).setText(str);
        }
    }

    public void onBackPressed() {
        W(SensorTrackEvent.LENDER_TRANSACTION_DETAILS_BACK_CLICK);
        super/*androidx.activity.ComponentActivity*/.onBackPressed();
    }

    @Override
    protected void onResume() {
        super.onResume();
        W(SensorTrackEvent.LENDER_TRANSACTION_DETAILS_ON_RESUME);
    }

    @Override
    public void openCustomerService() {
        super.openCustomerService();
        W(SensorTrackEvent.LENDER_TRANSACTION_DETAILS_CUSTOMER_SERVICE_CLICK);
    }

    public void processTransactionTabResponse(PendingEventResponse pendingEventResponse) {
        this.C.clear();
        Q(pendingEventResponse.body.waitSignatureCount);
        if (this.E) {
            N(pendingEventResponse.body.waitConfirmCount);
        } else if (!this.F) {
            P(pendingEventResponse.body.waitReinvestCount);
        } else if (this.userSession.b().c()) {
            N(pendingEventResponse.body.waitConfirmCount);
        } else {
            O(pendingEventResponse.body.waitAutoDebtMatchCount);
        }
        R(pendingEventResponse.body.waitTopUpCount);
        S(pendingEventResponse.body.waitWithdrawCount);
        U();
        X(pendingEventResponse);
    }

    @Override
    public Disposable runOnActiveEvent(Runnable runnable) {
        return m.a(this, runnable);
    }

    @Override
    @SuppressLint({"CheckResult"})
    public Disposable runOnCreated(@NonNull Runnable runnable) {
        return m.b(this, runnable);
    }

    @Override
    @SuppressLint({"CheckResult"})
    public Disposable runOnDestroy(@NonNull Runnable runnable) {
        return m.c(this, runnable);
    }

    @Override
    @SuppressLint({"CheckResult"})
    public Disposable runOnEvent(@NonNull LifecycleEvent lifecycleEvent, @Nullable Runnable runnable) {
        return m.d(this, lifecycleEvent, runnable);
    }

    @Override
    public Disposable runOnEvents(@NonNull LifecycleEvent[] lifecycleEventArr, @Nullable Runnable runnable) {
        return m.e(this, lifecycleEventArr, runnable);
    }

    public void sendGetTransactionTabRequest() {
        showLoadingDialog();
        ((ILenderApiRoutes) this.apiHelper.a()).W0().a(new IdnObserver<PendingEventResponse>(getCallBack()) {
            public void onSuccess(PendingEventResponse pendingEventResponse) {
                PendingTransactionActivity.this.processTransactionTabResponse(pendingEventResponse);
                PendingTransactionActivity.this.dismissLoadingDialog();
            }
        });
    }

    @Override
    protected void w() {
        super.w();
        sendGetTransactionTabRequest();
    }

    @Override
    protected void y(@NonNull Bundle bundle) {
        super.y(bundle);
        this.A = (TransactionType) bundle.getSerializable("parameterTransactionType");
    }
}