Android Billing Client in Kotlin

    private fun setupBillingClient() {
        billingClient = BillingClient.newBuilder(this).enablePendingPurchases().setListener(this).build()
        billingClient.startConnection(object : BillingClientStateListener {
            override fun onBillingSetupFinished(billingResult: BillingResult) {
                if (billingResult.responseCode == BillingClient.BillingResponseCode.OK)
                    loadAllSKUs()
            }

            override fun onBillingServiceDisconnected() {
                toast("Connection fail")
            }
        })
    }

    private fun loadAllSKUs() = if (billingClient.isReady) {

        //val paramsSubs = SkuDetailsParams.newBuilder().setSkusList(skuListSubs).setType(BillingClient.SkuType.SUBS).build()
        billingClient.querySkuDetailsAsync(
            SkuDetailsParams.newBuilder().setSkusList(skuListSubs)
                .setType(BillingClient.SkuType.SUBS).build()
        ) { _, skuDetailsList ->
            for (skuDetails in skuDetailsList!!) {
                if (skuDetails.sku == AppConst.MONTHLY_PACK) {

                    val offerPrice = skuDetails.priceAmountMicros.toDouble() / 1000000
                    val currencyCode = skuDetails.price.substring(0, 3)
                    val currencySymbol = CurrencySymbols().symbol(currencyCode)
                    val regularPrice =
                        String.format("%.2f", (((offerPrice / 1.99) * 2.99))).toDouble()

                    findViewById<TextView>(R.id.regularPriceMonth).text =
                        "$regularPrice $currencySymbol"
                    findViewById<TextView>(R.id.offerPriceMonth).text =
                        "$offerPrice $currencySymbol"
                } else if (skuDetails.sku == AppConst.YEARLY_PACK) {

                    val offerPrice = skuDetails.priceAmountMicros.toDouble() / 1000000
                    val currencyCode = skuDetails.price.substring(0, 3)
                    val currencySymbol = CurrencySymbols().symbol(currencyCode)
                    val regularPrice =
                        String.format("%.2f", (((offerPrice / 14.99) * 35.88))).toDouble()

                    findViewById<TextView>(R.id.regularPriceYear).text =
                        "$regularPrice $currencySymbol"
                    findViewById<TextView>(R.id.offerPriceYear).text = "$offerPrice $currencySymbol"
                }
            }
        }
        //val paramInAp = SkuDetailsParams.newBuilder().setSkusList(skuListInApp).setType(BillingClient.SkuType.INAPP).build()
        billingClient.querySkuDetailsAsync(
            SkuDetailsParams.newBuilder().setSkusList(skuListInApp)
                .setType(BillingClient.SkuType.INAPP).build()
        ) { _, skuDetailsList ->
            for (skuDetails in skuDetailsList!!) {
                if (skuDetails.sku == AppConst.LIFETIME_PACK) {
                    val offerPrice = skuDetails.priceAmountMicros.toDouble() / 1000000
                    val currencyCode = skuDetails.price.substring(0, 3)
                    val currencySymbol = CurrencySymbols().symbol(currencyCode)

                    findViewById<TextView>(R.id.offerPriceLifetime).text =
                        "$offerPrice $currencySymbol"
                }
            }
        }

        confirmBtn.setOnClickListener {
            if (AppSharedPref.getInstance(this).getPremiumUserState())
            toast("Congratulations!!!\nYou are already Premium User")
        else {
            val paramsSubs = SkuDetailsParams.newBuilder().setSkusList(skuListSubs)
                .setType(BillingClient.SkuType.SUBS).build()
            billingClient.querySkuDetailsAsync(paramsSubs) { billingResult, skuDetailsList ->

                if (billingResult.responseCode == BillingClient.BillingResponseCode.OK && skuDetailsList != null) {
                    for (skuDetails in skuDetailsList) {

                        if (skuDetails.sku == AppConst.MONTHLY_PACK && productType == 1) {
                            val billingFlowParams =
                                BillingFlowParams.newBuilder().setSkuDetails(skuDetails).build()
                            billingClient.launchBillingFlow(this, billingFlowParams)
                            Log.d("Riz1", "Month Selected")
                        } else if (skuDetails.sku == AppConst.YEARLY_PACK && productType == 2) {
                            val billingFlowParams =
                                BillingFlowParams.newBuilder().setSkuDetails(skuDetails).build()
                            billingClient.launchBillingFlow(this, billingFlowParams)
                            Log.d("Riz1", "Yearly Selected")
                        }
                    }
                }
            }

            val paramInAp = SkuDetailsParams.newBuilder().setSkusList(skuListInApp)
                .setType(BillingClient.SkuType.INAPP).build()
            billingClient.querySkuDetailsAsync(paramInAp) { billingResult, skuDetailsList ->
                if (billingResult.responseCode == BillingClient.BillingResponseCode.OK && skuDetailsList != null) {
                    for (skuDetails in skuDetailsList) {
                        if (skuDetails.sku == AppConst.LIFETIME_PACK && productType == 3) {
                            val billingFlowParams =
                                BillingFlowParams.newBuilder().setSkuDetails(skuDetails).build()
                            billingClient.launchBillingFlow(this, billingFlowParams)
                            Log.d("Riz1", "Lifetime Selected")
                        }
                    }
                }
            }
        }


        }
    } else this.toast("Billing Client not ready")

    override fun onPurchasesUpdated(billingResult: BillingResult, purchases: MutableList<Purchase>?) {
        Log.d("Riz1", "Inside Purchase Update")
        if (billingResult.responseCode == BillingClient.BillingResponseCode.OK && purchases != null) {
            Log.d("Riz1", "Inside Purchase Update, Pass Condition")
            for (purchase in purchases) {

                val param = AcknowledgePurchaseParams.newBuilder()
                    .setPurchaseToken(purchase.purchaseToken).build()
                billingClient.acknowledgePurchase(param) {

                    Log.d("Riz1", "Inside Purchase Update, Acknowledge test")
                    if (it.responseCode == BillingClient.BillingResponseCode.OK) {
                        AppSharedPref.getInstance(this).chnagePremiumUserState()

                        Log.d("Riz1", "Successful purchase")
                        toast("Congratulations!!! for PRO user")
                        //ProcessPhoenix.triggerRebirth(this);//Restart Library method
                    }
                }

            }
        } else if (billingResult.responseCode == BillingClient.BillingResponseCode.USER_CANCELED)
            toast("User has cancelled purchase!")
        else toast("Billing unavailable. Please check your device")
    }