Plus 12 v10.13.1.1 - BillingController.java 源代码

package org.telegram.messenger;

import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import androidx.core.util.Consumer;
import androidx.core.util.Pair;
import com.android.billingclient.api.BillingClient;
import com.android.billingclient.api.BillingClientStateListener;
import com.android.billingclient.api.BillingFlowParams;
import com.android.billingclient.api.BillingResult;
import com.android.billingclient.api.ConsumeParams;
import com.android.billingclient.api.ProductDetails;
import com.android.billingclient.api.ProductDetailsResponseListener;
import com.android.billingclient.api.Purchase;
import com.android.billingclient.api.PurchasesResponseListener;
import com.android.billingclient.api.PurchasesUpdatedListener;
import com.android.billingclient.api.QueryProductDetailsParams;
import com.android.billingclient.api.QueryPurchasesParams;
import com.google.android.exoplayer2.extractor.FlacStreamMetadata;
import j$.util.Map;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Currency;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import org.telegram.messenger.BillingController$;
import org.telegram.messenger.utils.BillingUtilities;
import org.telegram.tgnet.TLObject;
import org.telegram.tgnet.TLRPC;
import org.telegram.ui.ActionBar.AlertDialog;
import org.telegram.ui.PremiumPreviewFragment;

public class BillingController implements PurchasesUpdatedListener, BillingClientStateListener {
    public static ProductDetails PREMIUM_PRODUCT_DETAILS = null;
    public static boolean billingClientEmpty;
    private static NumberFormat currencyInstance;
    private static BillingController instance;
    private final BillingClient billingClient;
    private boolean isDisconnected;
    private String lastPremiumToken;
    private String lastPremiumTransaction;
    private Runnable onCanceled;
    public static final String PREMIUM_PRODUCT_ID = "telegram_premium";
    public static final QueryProductDetailsParams.Product PREMIUM_PRODUCT = QueryProductDetailsParams.Product.newBuilder().setProductType("subs").setProductId(PREMIUM_PRODUCT_ID).build();
    private final Map<String, Consumer<BillingResult>> resultListeners = new HashMap();
    private final List<String> requestingTokens = Collections.synchronizedList(new ArrayList());
    private final Map<String, Integer> currencyExpMap = new HashMap();
    private ArrayList<Runnable> setupListeners = new ArrayList<>();
    private int triesLeft = 0;

    public static String getResponseCodeString(int code) {
        switch (code) {
            case -3:
                return "SERVICE_TIMEOUT";
            case -2:
                return "FEATURE_NOT_SUPPORTED";
            case FlacStreamMetadata.NOT_IN_LOOKUP_TABLE:
                return "SERVICE_DISCONNECTED";
            case 0:
                return "OK";
            case 1:
                return "USER_CANCELED";
            case 2:
                return "SERVICE_UNAVAILABLE";
            case 3:
                return "BILLING_UNAVAILABLE";
            case 4:
                return "ITEM_UNAVAILABLE";
            case 5:
                return "DEVELOPER_ERROR";
            case 6:
                return "ERROR";
            case 7:
                return "ITEM_ALREADY_OWNED";
            case 8:
                return "ITEM_NOT_OWNED";
            default:
                return null;
        }
    }

    public static void lambda$consumeGiftPurchase$5(BillingResult billingResult, String str) {
    }

    public static BillingController getInstance() {
        if (instance == null) {
            instance = new BillingController(ApplicationLoader.applicationContext);
        }
        return instance;
    }

    private BillingController(Context ctx) {
        this.billingClient = BillingClient.newBuilder(ctx).enablePendingPurchases().setListener(this).build();
    }

    public void setOnCanceled(Runnable onCanceled) {
        this.onCanceled = onCanceled;
    }

    public String getLastPremiumTransaction() {
        return this.lastPremiumTransaction;
    }

    public String getLastPremiumToken() {
        return this.lastPremiumToken;
    }

    public String formatCurrency(long amount, String currency) {
        return formatCurrency(amount, currency, getCurrencyExp(currency));
    }

    public String formatCurrency(long amount, String currency, int exp) {
        return formatCurrency(amount, currency, exp, false);
    }

    public String formatCurrency(long amount, String currency, int exp, boolean rounded) {
        if (currency == null || currency.isEmpty()) {
            return String.valueOf(amount);
        }
        if ("TON".equalsIgnoreCase(currency)) {
            StringBuilder sb = new StringBuilder();
            sb.append("TON ");
            double d = amount;
            Double.isNaN(d);
            sb.append(d / 1.0E9d);
            return sb.toString();
        }
        Currency currency2 = Currency.getInstance(currency);
        if (currency2 != null) {
            if (currencyInstance == null) {
                currencyInstance = NumberFormat.getCurrencyInstance();
            }
            currencyInstance.setCurrency(currency2);
            if (rounded) {
                NumberFormat numberFormat = currencyInstance;
                double d2 = amount;
                double pow = Math.pow(10.0d, exp);
                Double.isNaN(d2);
                return numberFormat.format(Math.round(d2 / pow));
            }
            NumberFormat numberFormat2 = currencyInstance;
            double d3 = amount;
            double pow2 = Math.pow(10.0d, exp);
            Double.isNaN(d3);
            return numberFormat2.format(d3 / pow2);
        }
        return amount + " " + currency;
    }

    public int getCurrencyExp(String currency) {
        BillingUtilities.extractCurrencyExp(this.currencyExpMap);
        return ((Integer) Map.-EL.getOrDefault(this.currencyExpMap, currency, 0)).intValue();
    }

    public void lambda$onBillingServiceDisconnected$6() {
        if (isReady()) {
            return;
        }
        BillingUtilities.extractCurrencyExp(this.currencyExpMap);
        if (BuildVars.useInvoiceBilling()) {
            return;
        }
        this.billingClient.startConnection(this);
    }

    private void switchToInvoice() {
        if (billingClientEmpty) {
            return;
        }
        billingClientEmpty = true;
        NotificationCenter.getGlobalInstance().postNotificationName(NotificationCenter.billingProductDetailsUpdated, new Object[0]);
    }

    private void switchBackFromInvoice() {
        if (billingClientEmpty) {
            billingClientEmpty = false;
            NotificationCenter.getGlobalInstance().postNotificationName(NotificationCenter.billingProductDetailsUpdated, new Object[0]);
        }
    }

    public boolean isReady() {
        return this.billingClient.isReady();
    }

    public void queryProductDetails(List<QueryProductDetailsParams.Product> products, ProductDetailsResponseListener responseListener) {
        if (!isReady()) {
            throw new IllegalStateException("Billing: Controller should be ready for this call!");
        }
        this.billingClient.queryProductDetailsAsync(QueryProductDetailsParams.newBuilder().setProductList(products).build(), responseListener);
    }

    public void queryPurchases(String productType, PurchasesResponseListener responseListener) {
        this.billingClient.queryPurchasesAsync(QueryPurchasesParams.newBuilder().setProductType(productType).build(), responseListener);
    }

    public boolean startManageSubscription(Context ctx, String productId) {
        try {
            ctx.startActivity(new Intent("android.intent.action.VIEW", Uri.parse(String.format("https://play.google.com/store/account/subscriptions?sku=%s&package=%s", productId, ctx.getPackageName()))));
            return true;
        } catch (ActivityNotFoundException unused) {
            return false;
        }
    }

    public void addResultListener(String productId, Consumer<BillingResult> listener) {
        this.resultListeners.put(productId, listener);
    }

    public void launchBillingFlow(Activity activity, AccountInstance accountInstance, TLRPC.InputStorePaymentPurpose paymentPurpose, List<BillingFlowParams.ProductDetailsParams> productDetails) {
        launchBillingFlow(activity, accountInstance, paymentPurpose, productDetails, null, false);
    }

    public void launchBillingFlow(Activity activity, AccountInstance accountInstance, TLRPC.InputStorePaymentPurpose paymentPurpose, List<BillingFlowParams.ProductDetailsParams> productDetails, BillingFlowParams.SubscriptionUpdateParams subscriptionUpdateParams, boolean checkedConsume) {
        if (!isReady() || activity == null) {
            return;
        }
        if (((paymentPurpose instanceof TLRPC.TL_inputStorePaymentGiftPremium) || (paymentPurpose instanceof TLRPC.TL_inputStorePaymentStars)) && !checkedConsume) {
            queryPurchases("inapp", new BillingController$.ExternalSyntheticLambda4(this, activity, accountInstance, paymentPurpose, productDetails, subscriptionUpdateParams));
            return;
        }
        Pair createDeveloperPayload = BillingUtilities.createDeveloperPayload(paymentPurpose, accountInstance);
        String str = (String) createDeveloperPayload.first;
        String str2 = (String) createDeveloperPayload.second;
        BillingFlowParams.Builder productDetailsParamsList = BillingFlowParams.newBuilder().setObfuscatedAccountId(str).setObfuscatedProfileId(str2).setProductDetailsParamsList(productDetails);
        if (subscriptionUpdateParams != null) {
            productDetailsParamsList.setSubscriptionUpdateParams(subscriptionUpdateParams);
        }
        int responseCode = this.billingClient.launchBillingFlow(activity, productDetailsParamsList.build()).getResponseCode();
        if (responseCode != 0) {
            FileLog.d("Billing: Launch Error: " + responseCode + ", " + str + ", " + str2);
        }
    }

    public void lambda$launchBillingFlow$2(Activity activity, AccountInstance accountInstance, TLRPC.InputStorePaymentPurpose inputStorePaymentPurpose, List list, BillingFlowParams.SubscriptionUpdateParams subscriptionUpdateParams, BillingResult billingResult, List list2) {
        if (billingResult.getResponseCode() == 0) {
            BillingController$.ExternalSyntheticLambda7 externalSyntheticLambda7 = new BillingController$.ExternalSyntheticLambda7(this, activity, accountInstance, inputStorePaymentPurpose, list, subscriptionUpdateParams);
            AtomicInteger atomicInteger = new AtomicInteger(0);
            ArrayList arrayList = new ArrayList();
            Iterator it = list2.iterator();
            while (it.hasNext()) {
                Purchase purchase = (Purchase) it.next();
                if (purchase.isAcknowledged()) {
                    Iterator it2 = list.iterator();
                    while (true) {
                        if (it2.hasNext()) {
                            String productId = ((BillingFlowParams.ProductDetailsParams) it2.next()).zza().getProductId();
                            if (purchase.getProducts().contains(productId)) {
                                atomicInteger.incrementAndGet();
                                this.billingClient.consumeAsync(ConsumeParams.newBuilder().setPurchaseToken(purchase.getPurchaseToken()).build(), new BillingController$.ExternalSyntheticLambda0(arrayList, productId, atomicInteger, externalSyntheticLambda7));
                                break;
                            }
                        }
                    }
                } else {
                    onPurchasesUpdated(BillingResult.newBuilder().setResponseCode(0).build(), Collections.singletonList(purchase));
                    return;
                }
            }
            if (atomicInteger.get() == 0) {
                externalSyntheticLambda7.run();
            }
        }
    }

    public void lambda$launchBillingFlow$0(Activity activity, AccountInstance accountInstance, TLRPC.InputStorePaymentPurpose inputStorePaymentPurpose, List list, BillingFlowParams.SubscriptionUpdateParams subscriptionUpdateParams) {
        launchBillingFlow(activity, accountInstance, inputStorePaymentPurpose, list, subscriptionUpdateParams, true);
    }

    public static void lambda$launchBillingFlow$1(List list, String str, AtomicInteger atomicInteger, Runnable runnable, BillingResult billingResult, String str2) {
        if (billingResult.getResponseCode() == 0) {
            list.add(str);
            if (atomicInteger.get() == list.size()) {
                runnable.run();
            }
        }
    }

    @Override
    public void onPurchasesUpdated(BillingResult billing, List<Purchase> list) {
        Pair extractDeveloperPayload;
        FileLog.d("Billing: Purchases updated: " + billing + ", " + list);
        if (billing.getResponseCode() != 0) {
            if (billing.getResponseCode() == 1) {
                PremiumPreviewFragment.sentPremiumBuyCanceled();
            }
            Runnable runnable = this.onCanceled;
            if (runnable != null) {
                runnable.run();
                this.onCanceled = null;
                return;
            }
            return;
        }
        if (list == null || list.isEmpty()) {
            return;
        }
        this.lastPremiumTransaction = null;
        for (Purchase purchase : list) {
            if (purchase.getProducts().contains(PREMIUM_PRODUCT_ID)) {
                this.lastPremiumTransaction = purchase.getOrderId();
                this.lastPremiumToken = purchase.getPurchaseToken();
            }
            if (!this.requestingTokens.contains(purchase.getPurchaseToken()) && purchase.getPurchaseState() == 1 && (extractDeveloperPayload = BillingUtilities.extractDeveloperPayload(purchase)) != null) {
                if (!purchase.isAcknowledged()) {
                    this.requestingTokens.add(purchase.getPurchaseToken());
                    TLObject tL_payments_assignPlayMarketTransaction = new TLRPC.TL_payments_assignPlayMarketTransaction();
                    TLRPC.TL_dataJSON tL_dataJSON = new TLRPC.TL_dataJSON();
                    ((TLRPC.TL_payments_assignPlayMarketTransaction) tL_payments_assignPlayMarketTransaction).receipt = tL_dataJSON;
                    tL_dataJSON.data = purchase.getOriginalJson();
                    ((TLRPC.TL_payments_assignPlayMarketTransaction) tL_payments_assignPlayMarketTransaction).purpose = (TLRPC.InputStorePaymentPurpose) extractDeveloperPayload.second;
                    AlertDialog alertDialog = new AlertDialog(ApplicationLoader.applicationContext, 3);
                    AndroidUtilities.runOnUIThread(new BillingController$.ExternalSyntheticLambda9(alertDialog));
                    AccountInstance accountInstance = (AccountInstance) extractDeveloperPayload.first;
                    accountInstance.getConnectionsManager().sendRequest(tL_payments_assignPlayMarketTransaction, new BillingController$.ExternalSyntheticLambda10(this, alertDialog, purchase, accountInstance, billing, tL_payments_assignPlayMarketTransaction), 65602);
                } else {
                    consumeGiftPurchase(purchase, (TLRPC.InputStorePaymentPurpose) extractDeveloperPayload.second);
                }
            }
        }
    }

    public void lambda$onPurchasesUpdated$4(AlertDialog alertDialog, Purchase purchase, AccountInstance accountInstance, BillingResult billingResult, TLRPC.TL_payments_assignPlayMarketTransaction tL_payments_assignPlayMarketTransaction, TLObject tLObject, TLRPC.TL_error tL_error) {
        Objects.requireNonNull(alertDialog);
        AndroidUtilities.runOnUIThread(new BillingController$.ExternalSyntheticLambda8(alertDialog));
        this.requestingTokens.remove(purchase.getPurchaseToken());
        if (tLObject instanceof TLRPC.Updates) {
            accountInstance.getMessagesController().processUpdates((TLRPC.Updates) tLObject, false);
            Iterator<String> it = purchase.getProducts().iterator();
            while (it.hasNext()) {
                Consumer<BillingResult> remove = this.resultListeners.remove(it.next());
                if (remove != null) {
                    remove.accept(billingResult);
                }
            }
            consumeGiftPurchase(purchase, tL_payments_assignPlayMarketTransaction.purpose);
            return;
        }
        if (tL_error != null) {
            Runnable runnable = this.onCanceled;
            if (runnable != null) {
                runnable.run();
                this.onCanceled = null;
            }
            NotificationCenter.getGlobalInstance().postNotificationNameOnUIThread(NotificationCenter.billingConfirmPurchaseError, new Object[]{tL_payments_assignPlayMarketTransaction, tL_error});
        }
    }

    private void consumeGiftPurchase(Purchase purchase, TLRPC.InputStorePaymentPurpose purpose) {
        if ((purpose instanceof TLRPC.TL_inputStorePaymentGiftPremium) || (purpose instanceof TLRPC.TL_inputStorePaymentPremiumGiftCode) || (purpose instanceof TLRPC.TL_inputStorePaymentStars) || (purpose instanceof TLRPC.TL_inputStorePaymentPremiumGiveaway)) {
            this.billingClient.consumeAsync(ConsumeParams.newBuilder().setPurchaseToken(purchase.getPurchaseToken()).build(), BillingController$.ExternalSyntheticLambda1.INSTANCE);
        }
    }

    @Override
    public void onBillingServiceDisconnected() {
        FileLog.d("Billing: Service disconnected");
        int i = this.isDisconnected ? 15000 : 5000;
        this.isDisconnected = true;
        AndroidUtilities.runOnUIThread(new BillingController$.ExternalSyntheticLambda5(this), i);
    }

    public void whenSetuped(Runnable listener) {
        this.setupListeners.add(listener);
    }

    @Override
    public void onBillingSetupFinished(BillingResult setupBillingResult) {
        FileLog.d("Billing: Setup finished with result " + setupBillingResult);
        if (setupBillingResult.getResponseCode() == 0) {
            this.isDisconnected = false;
            this.triesLeft = 3;
            try {
                queryProductDetails(Collections.singletonList(PREMIUM_PRODUCT), new BillingController$.ExternalSyntheticLambda2(this));
            } catch (Exception e) {
                FileLog.e(e);
            }
            queryPurchases("inapp", new BillingController$.ExternalSyntheticLambda3(this));
            queryPurchases("subs", new BillingController$.ExternalSyntheticLambda3(this));
            if (this.setupListeners.isEmpty()) {
                return;
            }
            for (int i = 0; i < this.setupListeners.size(); i++) {
                AndroidUtilities.runOnUIThread(this.setupListeners.get(i));
            }
            this.setupListeners.clear();
            return;
        }
        if (this.isDisconnected) {
            return;
        }
        switchToInvoice();
    }

    public void onQueriedPremiumProductDetails(BillingResult billingResult, List<ProductDetails> list) {
        FileLog.d("Billing: Query product details finished " + billingResult + ", " + list);
        if (billingResult.getResponseCode() == 0) {
            for (ProductDetails productDetails : list) {
                if (productDetails.getProductId().equals(PREMIUM_PRODUCT_ID)) {
                    PREMIUM_PRODUCT_DETAILS = productDetails;
                }
            }
            if (PREMIUM_PRODUCT_DETAILS == null) {
                switchToInvoice();
                return;
            } else {
                switchBackFromInvoice();
                NotificationCenter.getGlobalInstance().postNotificationNameOnUIThread(NotificationCenter.billingProductDetailsUpdated, new Object[0]);
                return;
            }
        }
        switchToInvoice();
        int i = this.triesLeft - 1;
        this.triesLeft = i;
        if (i > 0) {
            AndroidUtilities.runOnUIThread(new BillingController$.ExternalSyntheticLambda6(this), i == 2 ? 1000L : 10000L);
        }
    }

    public void lambda$onQueriedPremiumProductDetails$7() {
        try {
            queryProductDetails(Collections.singletonList(PREMIUM_PRODUCT), new BillingController$.ExternalSyntheticLambda2(this));
        } catch (Exception e) {
            FileLog.e(e);
        }
    }
}