안드로이드 앱 만들기 : 구글 인앱 결제 쉽게 따라하기 (Kotlin 으로 이전해 보기)

인앱결제 코드 이전 이야기

이전 버전에서는 java 코드로 구현된 소스 코드를 공유해 보았습니다.

 

https://billcorea.tistory.com/165

안드로이드 앱 만들기 : 구글 인앱 결제 쉽게 따라하기 (정기결제, 소스공유)

 

오늘은 이 코드를 그대로 kotlin  코드로 변환을 해 보았습니다. 

Java File to Kotlin File

Android Studio 에서는 java 코드를 kotlin으로 변환해 줍니다. 

메뉴에서 Code 제일 아래에 보면 Convert Java File to Kotlin File 이 보입니다.  물로 이 메뉴는 Java 코드일 때만 보입니다.

android studio 메뉴

 

변환을 시행해 보겠습니다. 변환은 내 앱의 상위 package 이름이 나와 있는 위치에서 오른쪽 마우스를 클릭해서 하는 방법도 있습니다.  개발 java 파일을 선택해서 오른쪽 마우스 클릭해서 하게 되는 경우는 개별 파일만 처리해 주지만, 최상위 package을 선택하고 하는 경우 하위 경로에 있는 모든 파일을 한 번에 변환해 줍니다. 

 

주의 사항  

일괄 변환된 후에 해야할 일들이 생깁니다. java 코드에서는 global 변수로 사용하고자 하는 경우 그냥 변수 이름만 선언해 주면 되었던 부분들이 kotlin을 변환하게 되면 그 값을 정해 주는 것에 대해서 설정을 해 주어야 하는 부분들이 생기며  해당 변수를 일괄적으로 null 대입하는 코드로 변환을 해 주시기 때문에 아래 예시들처럼 수정을 해 주어야 하는 부분들이 생깁니다.

 

변환 전 / 후

위 예시는 kotlin  으로 변환 후에 코드를 정리한 후의 코드이니 변환된 직후의 코드와는 다르다는 것을 염두에 두고 보시길 바랍니다. 

 

조금더 자세한 주의 사항을 보시려면 google  에서 제공하는 codelab 을 살펴 보세요.

https://codelabs.developers.google.com/codelabs/java-to-kotlin?hl=ko#1 

Kotlin으로 변환  |  Google Codelabs

 

Gradle 설정 추가

 source code 는 변환을 해 주지만, gradle 파일을 자동 변환을 해 주지 않기 때문에 설정을 일부 추가해 주어야 합니다. 

 

먼저 project 의 gradle 파일에는 아래처럼 2곳에 추가를 해 주었습니다.

buildscript {
    ext.kotlin_version = '1.7.20' // kotlin 추가
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:7.3.1'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" // kotlin 추가
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

 

module의 gradle 파일은 다음과 같이 추가해 주었습니다.

plugins {
    id 'com.android.application'
    id 'kotlin-android-extensions' // kotlin 추가
    id 'kotlin-android' // kotlin 추가
    id 'kotlin-kapt' // kotlin 추가
}

 

이제 빌드를 진행해 봅니다. 

 

앱 실행 화면

 

이런 게 변환된 코드는 정상적으로 실행이 되는 것을 확인했습니다. 

 

구글 인앱 결제 

인앱 정기결제 코드는 어떻게 변환이 되었을까요 ?

 

import android.app.Activity
import android.content.Context
import android.content.SharedPreferences
import android.util.Log
import android.widget.Toast
import com.android.billingclient.api.*
import com.billcoreatech.daycnt415.R
import com.billcoreatech.daycnt415.util.KakaoToast
import java.text.SimpleDateFormat
import java.util.*

class BillingManager(var mActivity: Activity) : PurchasesUpdatedListener, ConsumeResponseListener {
    var TAG = "BillingManager"
    lateinit var mBillingClient: BillingClient
    lateinit var mSkuDetails: List<SkuDetails>

    enum class connectStatusTypes {
        waiting, connected, fail, disconnected
    }

    var connectStatus = connectStatusTypes.waiting

    /**
     * 구글에 설정한 구독 상품 아이디와 일치 하지 않으면 오류를 발생 시킴.
     * 21.04.20 이번에는 1회성 구매로 변경   210414_monthly_bill_999, 210420_monthly_bill
     */
    var punchName = "220302_bill_1month_999"
    var punchNameInapp = "210420_monthly_bill"
    var payType = BillingClient.SkuType.SUBS
    var option: SharedPreferences
    var editor: SharedPreferences.Editor

    init {
        option = mActivity.getSharedPreferences("option", Context.MODE_PRIVATE)
        editor = option.edit()
        mBillingClient = BillingClient.newBuilder(mActivity)
            .setListener(this)
            .enablePendingPurchases()
            .build()
        mBillingClient.startConnection(object : BillingClientStateListener {
            override fun onBillingSetupFinished(billingResult: BillingResult) {
                Log.e(TAG, "respCode=" + billingResult.responseCode)
                if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
                    connectStatus = connectStatusTypes.connected
                    Log.e(TAG, "connected...")
                    purchaseAsync()
                } else {
                    connectStatus = connectStatusTypes.fail
                    Log.i(TAG, "connected... fail ")
                }
            }

            override fun onBillingServiceDisconnected() {
                connectStatus = connectStatusTypes.disconnected
                Log.i(TAG, "disconnected ")
            }
        })
    }

    /**
     * 정기 결재 소모 여부를 수신 : 21.04.20 1회성 구매의 경우는 결재하면 끝임.
     * @param billingResult
     * @param purchaseToken
     */
    override fun onConsumeResponse(billingResult: BillingResult, purchaseToken: String) {
        if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
            Log.i(TAG, "사용끝 + $purchaseToken")
            return
        } else {
            Log.i(TAG, "소모에 실패 " + billingResult.responseCode + " 대상 상품 " + purchaseToken)
            return
        }
    }

    fun purchase(skuDetails: SkuDetails?): Int {
        val flowParams = BillingFlowParams.newBuilder()
            .setSkuDetails(skuDetails!!)
            .build()
        return mBillingClient.launchBillingFlow(mActivity, flowParams).responseCode
    }

    fun purchaseAsync() {
        Log.e(TAG, "--------------------------------------------------------------")
        mBillingClient.queryPurchasesAsync(payType) { billingResult, list ->
            Log.e(TAG, "onQueryPurchasesResponse=" + billingResult.responseCode)
            val sdf = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
            if (list.size < 1) {
                editor = option.edit()
                editor.putBoolean("isBill", false)
                editor.commit()
                Log.e(TAG, "getData=" + list.size)
            } else {
                for (purchase in list) {
                    Log.e(TAG, "getPurchaseToken=" + purchase.purchaseToken)
                    for (str in purchase.skus) {
                        Log.e(TAG, "getSkus=$str")
                    }
                    val now = Date()
                    now.time = purchase.purchaseTime
                    Log.e(TAG, "getPurchaseTime=" + sdf.format(now))
                    Log.e(TAG, "getQuantity=" + purchase.quantity)
                    Log.e(TAG, "getSignature=" + purchase.signature)
                    Log.e(TAG, "isAutoRenewing=" + purchase.isAutoRenewing)
                    Log.e(TAG, "getPurchaseState=" + purchase.purchaseState)
                    editor = option.edit()
                    editor.putBoolean("isBill", purchase.isAutoRenewing)
                    editor.commit()
                }
            }
            Log.e(TAG, "--------------------------------------------------------------")
        }
    }

    val skuDetailList: Unit
        get() {
            val skuIdList: MutableList<String> = ArrayList()
            skuIdList.add(punchName)
            val params = SkuDetailsParams.newBuilder()
            params.setSkusList(skuIdList).setType(payType)
            mBillingClient.querySkuDetailsAsync(
                params.build(),
                SkuDetailsResponseListener { billingResult, skuDetailsList ->
                    if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
                        Log.i(TAG, "detail respCode=" + billingResult.responseCode)
                        return@SkuDetailsResponseListener
                    }
                    if (skuDetailsList == null) {
                        KakaoToast.makeToast(
                            mActivity,
                            mActivity.getString(R.string.msgNotInfo),
                            Toast.LENGTH_LONG
                        ).show()
                        return@SkuDetailsResponseListener
                    }
                    Log.i(TAG, "listCount=" + skuDetailsList.size)
                    for (skuDetails in skuDetailsList) {
                        Log.i(TAG, """    
     ${skuDetails.sku}
     ${skuDetails.title}
     ${skuDetails.price}
     ${skuDetails.description}
     ${skuDetails.freeTrialPeriod}
     ${skuDetails.iconUrl}
     ${skuDetails.introductoryPrice}
     ${skuDetails.introductoryPriceAmountMicros}
     ${skuDetails.originalPrice}
     ${skuDetails.priceCurrencyCode}
     """.trimIndent()
                        )
                    }
                    purchase(skuDetailsList[0])
                })
        }

    /**
     * @param billingResult
     * @param purchases
     */
    override fun onPurchasesUpdated(billingResult: BillingResult, purchases: List<Purchase>?) {
        if (billingResult == null) {
            Log.wtf(TAG, "onPurchasesUpdated: null BillingResult")
            return
        }
        val responseCode = billingResult.responseCode
        val debugMessage = billingResult.debugMessage
        Log.d(TAG, "onPurchasesUpdated: ${responseCode} ${debugMessage}")
        when (responseCode) {
            BillingClient.BillingResponseCode.OK -> if (purchases == null) {
                Log.d(TAG, "onPurchasesUpdated: null purchase list")
                processPurchases(null)
            } else {
                processPurchases(purchases)
            }
            BillingClient.BillingResponseCode.USER_CANCELED -> Log.i(
                TAG,
                "onPurchasesUpdated: User canceled the purchase"
            )
            BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED -> Log.i(
                TAG,
                "onPurchasesUpdated: The user already owns this item"
            )
            BillingClient.BillingResponseCode.DEVELOPER_ERROR -> Log.e(
                TAG, "onPurchasesUpdated: Developer error means that Google Play " +
                        "does not recognize the configuration. If you are just getting started, " +
                        "make sure you have configured the application correctly in the " +
                        "Google Play Console. The SKU product ID must match and the APK you " +
                        "are using must be signed with release keys."
            )
        }
    }

    private fun processPurchases(purchasesList: List<Purchase>?) {
        if (purchasesList != null) {
            Log.d(TAG, "processPurchases: " + purchasesList.size + " purchase(s)")
        } else {
            Log.d(TAG, "processPurchases: with no purchases")
        }
        if (isUnchangedPurchaseList(purchasesList)) {
            Log.d(TAG, "processPurchases: Purchase list has not changed")
            return
        }
    }

    /**
     * subs 의 경우는 아래와 같이 구매확인을 해 주어야 됨.
     * @param purchase
     */
    fun confirmPerchase(purchase: Purchase) {
        //PURCHASED
        if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
            if (!purchase.isAcknowledged) {
                val acknowledgePurchaseParams = AcknowledgePurchaseParams.newBuilder()
                    .setPurchaseToken(purchase.purchaseToken)
                    .build()
                mBillingClient.acknowledgePurchase(acknowledgePurchaseParams) { billingResult ->
                    Log.e(TAG, "getResponseCode=" + billingResult.responseCode)
                    editor.putBoolean("isBill", true)
                    editor.commit()
                }
            }
        } else if (purchase.purchaseState == Purchase.PurchaseState.PENDING) {
            //구매 유예
            Log.e(TAG, "//구매 유예")
        } else {
            //구매확정 취소됨(기타 다양한 사유...)
            Log.e(TAG, "//구매확정 취소됨(기타 다양한 사유...)")
        }
    }

    private fun isUnchangedPurchaseList(purchasesList: List<Purchase>?): Boolean {
        for (purchase in purchasesList!!) {
            confirmPerchase(purchase)
        }
        return false
    }
}

이전에 포스팅했던 java 코드와 비교를 해 보면 코드가 많이 간소화되었다는 것을 알 수 있습니다.  호출해서 사용하는 코드는 github의 코드를 참고해 보세요. 

 

결제 테스트

결제 진행에 대한 테스트는 꼭 playstore에 게시한 이후에 진행하여야 합니다.  저는 내부 테스트로 게시한 이후 진행 하고 있습니다. 그리고  정기결제 항목을 처음 등록한 경우에는 해당 결제 항목이 사용이 될 수 있으려면 24시간 이상 걸리는 경우가 있으므로 미리 정기결제 항목을 등록해 두고 앱을 만들어 가는 것이 시간 활용에 도움이 됩니다. 

 

결제 테스트

 

이상으로 Java 코드의 소스를 Kotlin으로 변환을 해 보았습니다.

 

전체 코드 보기

전체소스코드는 아래 링크를 참고하세요.

https://github.com/nari4169/daycnt415_kotlin

GitHub - nari4169/daycnt415_kotlin