@virex-tech/paywallo-sdk 1.0.0

package/android/src/main/java/com/monety/sdk/PanelWebViewManager.kt

@@ -0,0 +1,52 @@
+package com.monety.sdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class PanelWebViewManager(private val reactContext: ReactApplicationContext) : SimpleViewManager<PanelWebView>() {
+
+    companion object {
+        const val REACT_CLASS = "PanelWebView"
+        const val COMMAND_INJECT_JS = 1
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): PanelWebView {
+        return PanelWebView(context)
+    }
+
+    @ReactProp(name = "sourceUrl")
+    fun setSourceUrl(view: PanelWebView, url: String?) {
+        view.setSourceUrl(url)
+    }
+
+    @ReactProp(name = "sourceHtml")
+    fun setSourceHtml(view: PanelWebView, html: String?) {
+        view.setSourceHtml(html)
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+        return MapBuilder.builder<String, Any>()
+            .put("onMessage", MapBuilder.of("registrationName", "onMessage"))
+            .put("onLoadEnd", MapBuilder.of("registrationName", "onLoadEnd"))
+            .build()
+    }
+
+    override fun getCommandsMap(): Map<String, Int>? {
+        return MapBuilder.of("injectJavaScript", COMMAND_INJECT_JS)
+    }
+
+    override fun receiveCommand(view: PanelWebView, commandId: String?, args: ReadableArray?) {
+        when (commandId) {
+            "injectJavaScript" -> {
+                val script = args?.getString(0) ?: return
+                view.injectJavaScript(script)
+            }
+        }
+    }
+}

package/android/src/main/java/com/paywallo/sdk/PaywalloSdkPackage.kt

@@ -0,0 +1,16 @@
+package com.paywallo.sdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PaywalloSdkPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(PaywalloStoreKitModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(PaywalloWebViewManager(reactContext))
+    }
+}

package/android/src/main/java/com/paywallo/sdk/PaywalloStoreKitModule.kt

@@ -0,0 +1,315 @@
+package com.paywallo.sdk
+
+import android.app.Activity
+import com.android.billingclient.api.*
+import com.facebook.react.bridge.*
+import kotlinx.coroutines.*
+
+class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), PurchasesUpdatedListener {
+
+    private var billingClient: BillingClient? = null
+    private var purchasePromise: Promise? = null
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+    override fun getName() = "PaywalloStoreKit"
+
+    private fun ensureBillingClient(): BillingClient {
+        if (billingClient == null || billingClient?.isReady != true) {
+            billingClient = BillingClient.newBuilder(reactContext)
+                .setListener(this)
+                .enablePendingPurchases()
+                .build()
+        }
+        return billingClient!!
+    }
+
+    private suspend fun connectBilling(): Boolean {
+        val client = ensureBillingClient()
+        if (client.isReady) return true
+
+        return suspendCancellableCoroutine { cont ->
+            client.startConnection(object : BillingClientStateListener {
+                override fun onBillingSetupFinished(result: BillingResult) {
+                    if (cont.isActive) {
+                        cont.resume(result.responseCode == BillingClient.BillingResponseCode.OK) {}
+                    }
+                }
+                override fun onBillingServiceDisconnected() {
+                    if (cont.isActive) {
+                        cont.resume(false) {}
+                    }
+                }
+            })
+        }
+    }
+
+    @ReactMethod
+    fun getProducts(productIds: ReadableArray, promise: Promise) {
+        scope.launch {
+            try {
+                if (!connectBilling()) {
+                    promise.reject("BILLING_ERROR", "Failed to connect to billing service")
+                    return@launch
+                }
+
+                val ids = mutableListOf<String>()
+                for (i in 0 until productIds.size()) {
+                    productIds.getString(i)?.let { ids.add(it) }
+                }
+
+                // Try subscriptions first, then one-time
+                val subsProducts = queryProducts(ids, BillingClient.ProductType.SUBS)
+                val inappProducts = queryProducts(ids, BillingClient.ProductType.INAPP)
+
+                val result = WritableNativeArray()
+
+                for (details in subsProducts + inappProducts) {
+                    val map = WritableNativeMap()
+                    map.putString("productId", details.productId)
+                    map.putString("title", details.title)
+                    map.putString("description", details.description)
+
+                    val subDetails = details.subscriptionOfferDetails
+                    if (subDetails != null && subDetails.isNotEmpty()) {
+                        val offer = subDetails[0]
+                        val pricingPhases = offer.pricingPhases.pricingPhaseList
+
+                        // Find the main pricing phase (not trial)
+                        val mainPhase = if (pricingPhases.size > 1) {
+                            pricingPhases.last()
+                        } else {
+                            pricingPhases.first()
+                        }
+
+                        map.putString("price", (mainPhase.priceAmountMicros / 1_000_000.0).toString())
+                        map.putDouble("priceValue", mainPhase.priceAmountMicros / 1_000_000.0)
+                        map.putString("currency", mainPhase.priceCurrencyCode)
+                        map.putString("localizedPrice", mainPhase.formattedPrice)
+                        map.putString("type", "subscription")
+                        map.putString("subscriptionPeriod", mainPhase.billingPeriod)
+
+                        // Check for free trial
+                        if (pricingPhases.size > 1) {
+                            val trialPhase = pricingPhases.first()
+                            if (trialPhase.priceAmountMicros == 0L) {
+                                map.putString("freeTrialPeriod", trialPhase.billingPeriod)
+                            } else {
+                                map.putString("introductoryPrice", trialPhase.formattedPrice)
+                                map.putDouble("introductoryPriceValue", trialPhase.priceAmountMicros / 1_000_000.0)
+                            }
+                        }
+                    } else {
+                        val oneTime = details.oneTimePurchaseOfferDetails
+                        if (oneTime != null) {
+                            map.putString("price", (oneTime.priceAmountMicros / 1_000_000.0).toString())
+                            map.putDouble("priceValue", oneTime.priceAmountMicros / 1_000_000.0)
+                            map.putString("currency", oneTime.priceCurrencyCode)
+                            map.putString("localizedPrice", oneTime.formattedPrice)
+                            map.putString("type", "non_consumable")
+                        }
+                    }
+
+                    result.pushMap(map)
+                }
+
+                promise.resolve(result)
+            } catch (e: Exception) {
+                promise.reject("PRODUCTS_ERROR", "Failed to load products: ${e.message}", e)
+            }
+        }
+    }
+
+    private suspend fun queryProducts(ids: List<String>, type: String): List<ProductDetails> {
+        val client = billingClient ?: return emptyList()
+
+        val productList = ids.map { id ->
+            QueryProductDetailsParams.Product.newBuilder()
+                .setProductId(id)
+                .setProductType(type)
+                .build()
+        }
+
+        val params = QueryProductDetailsParams.newBuilder()
+            .setProductList(productList)
+            .build()
+
+        return suspendCancellableCoroutine { cont ->
+            client.queryProductDetailsAsync(params) { result, detailsList ->
+                if (cont.isActive) {
+                    if (result.responseCode == BillingClient.BillingResponseCode.OK) {
+                        cont.resume(detailsList ?: emptyList()) {}
+                    } else {
+                        cont.resume(emptyList()) {}
+                    }
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun purchase(productId: String, promise: Promise) {
+        scope.launch {
+            try {
+                if (!connectBilling()) {
+                    promise.reject("BILLING_ERROR", "Failed to connect to billing service")
+                    return@launch
+                }
+
+                val client = billingClient!!
+                val activity = currentActivity
+
+                if (activity == null) {
+                    promise.reject("NO_ACTIVITY", "No current activity")
+                    return@launch
+                }
+
+                // Query product details
+                val subsProducts = queryProducts(listOf(productId), BillingClient.ProductType.SUBS)
+                val inappProducts = queryProducts(listOf(productId), BillingClient.ProductType.INAPP)
+                val details = (subsProducts + inappProducts).firstOrNull()
+
+                if (details == null) {
+                    promise.reject("PRODUCT_NOT_FOUND", "Product $productId not found")
+                    return@launch
+                }
+
+                purchasePromise = promise
+
+                val flowParamsBuilder = BillingFlowParams.newBuilder()
+
+                val productDetailsParams = BillingFlowParams.ProductDetailsParams.newBuilder()
+                    .setProductDetails(details)
+
+                // For subscriptions, set the offer token
+                details.subscriptionOfferDetails?.firstOrNull()?.let { offer ->
+                    productDetailsParams.setOfferToken(offer.offerToken)
+                }
+
+                flowParamsBuilder.setProductDetailsParamsList(
+                    listOf(productDetailsParams.build())
+                )
+
+                client.launchBillingFlow(activity, flowParamsBuilder.build())
+            } catch (e: Exception) {
+                purchasePromise = null
+                promise.reject("PURCHASE_ERROR", "Purchase failed: ${e.message}", e)
+            }
+        }
+    }
+
+    override fun onPurchasesUpdated(result: BillingResult, purchases: List<Purchase>?) {
+        val promise = purchasePromise ?: return
+        purchasePromise = null
+
+        when (result.responseCode) {
+            BillingClient.BillingResponseCode.OK -> {
+                val purchase = purchases?.firstOrNull()
+                if (purchase != null) {
+                    val map = WritableNativeMap()
+                    map.putString("transactionId", purchase.orderId ?: purchase.purchaseToken)
+                    map.putString("productId", purchase.products.firstOrNull() ?: "")
+                    map.putString("receipt", purchase.purchaseToken)
+                    map.putDouble("transactionDate", purchase.purchaseTime.toDouble())
+                    promise.resolve(map)
+                } else {
+                    promise.resolve(null)
+                }
+            }
+            BillingClient.BillingResponseCode.USER_CANCELED -> {
+                promise.resolve(null)
+            }
+            else -> {
+                promise.reject("PURCHASE_ERROR", "Purchase failed: ${result.debugMessage}")
+            }
+        }
+    }
+
+    @ReactMethod
+    fun finishTransaction(transactionId: String, promise: Promise) {
+        scope.launch {
+            try {
+                if (!connectBilling()) {
+                    promise.resolve(null)
+                    return@launch
+                }
+
+                val client = billingClient!!
+
+                // Query purchases to find the one to acknowledge
+                val subsResult = client.queryPurchasesAsync(
+                    QueryPurchasesParams.newBuilder()
+                        .setProductType(BillingClient.ProductType.SUBS)
+                        .build()
+                )
+
+                val allPurchases = subsResult.purchasesList
+
+                val purchase = allPurchases.firstOrNull {
+                    it.orderId == transactionId || it.purchaseToken == transactionId
+                }
+
+                if (purchase != null && !purchase.isAcknowledged) {
+                    val ackParams = AcknowledgePurchaseParams.newBuilder()
+                        .setPurchaseToken(purchase.purchaseToken)
+                        .build()
+
+                    client.acknowledgePurchase(ackParams) { ackResult ->
+                        if (ackResult.responseCode == BillingClient.BillingResponseCode.OK) {
+                            promise.resolve(null)
+                        } else {
+                            promise.reject("ACK_ERROR", "Failed to acknowledge: ${ackResult.debugMessage}")
+                        }
+                    }
+                } else {
+                    promise.resolve(null)
+                }
+            } catch (e: Exception) {
+                promise.resolve(null)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getActiveTransactions(promise: Promise) {
+        scope.launch {
+            try {
+                if (!connectBilling()) {
+                    promise.resolve(WritableNativeArray())
+                    return@launch
+                }
+
+                val client = billingClient!!
+                val result = WritableNativeArray()
+
+                val subsResult = client.queryPurchasesAsync(
+                    QueryPurchasesParams.newBuilder()
+                        .setProductType(BillingClient.ProductType.SUBS)
+                        .build()
+                )
+
+                for (purchase in subsResult.purchasesList) {
+                    if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
+                        val map = WritableNativeMap()
+                        map.putString("transactionId", purchase.orderId ?: purchase.purchaseToken)
+                        map.putString("productId", purchase.products.firstOrNull() ?: "")
+                        map.putString("receipt", purchase.purchaseToken)
+                        map.putDouble("transactionDate", purchase.purchaseTime.toDouble())
+                        result.pushMap(map)
+                    }
+                }
+
+                promise.resolve(result)
+            } catch (e: Exception) {
+                promise.resolve(WritableNativeArray())
+            }
+        }
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        scope.cancel()
+        billingClient?.endConnection()
+        billingClient = null
+        super.onCatalystInstanceDestroy()
+    }
+}

package/android/src/main/java/com/paywallo/sdk/PaywalloWebView.kt

@@ -0,0 +1,74 @@
+package com.paywallo.sdk
+
+import android.annotation.SuppressLint
+import android.webkit.JavascriptInterface
+import android.webkit.WebChromeClient
+import android.webkit.WebSettings
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+@SuppressLint("SetJavaScriptEnabled", "ViewConstructor")
+class PaywalloWebView(context: ReactContext) : WebView(context) {
+
+    private val reactContext = context
+
+    init {
+        setupWebView()
+    }
+
+    private fun setupWebView() {
+        settings.apply {
+            javaScriptEnabled = true
+            domStorageEnabled = true
+            mediaPlaybackRequiresUserGesture = false
+            mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
+            cacheMode = WebSettings.LOAD_DEFAULT
+        }
+
+        webViewClient = object : WebViewClient() {
+            override fun onPageFinished(view: WebView?, url: String?) {
+                super.onPageFinished(view, url)
+                dispatchEvent("onLoadEnd", null)
+            }
+        }
+
+        webChromeClient = WebChromeClient()
+
+        addJavascriptInterface(WebAppInterface(), "ReactNativeWebView")
+    }
+
+    private var pendingHtml: String? = null
+
+    fun setSourceUrl(url: String?) {
+        if (pendingHtml.isNullOrEmpty()) {
+            url?.let { loadUrl(it) }
+        }
+    }
+
+    fun setSourceHtml(html: String?) {
+        pendingHtml = html
+        html?.let { loadDataWithBaseURL("https://app.paywallo.io", it, "text/html", "UTF-8", null) }
+    }
+
+    fun injectJavaScript(script: String) {
+        evaluateJavascript(script, null)
+    }
+
+    private fun dispatchEvent(eventName: String, data: String?) {
+        val event = Arguments.createMap().apply {
+            data?.let { putString("data", it) }
+        }
+        reactContext.getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(id, eventName, event)
+    }
+
+    inner class WebAppInterface {
+        @JavascriptInterface
+        fun postMessage(message: String) {
+            post { dispatchEvent("onMessage", message) }
+        }
+    }
+}

package/android/src/main/java/com/paywallo/sdk/PaywalloWebViewManager.kt

@@ -0,0 +1,52 @@
+package com.paywallo.sdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class PaywalloWebViewManager(private val reactContext: ReactApplicationContext) : SimpleViewManager<PaywalloWebView>() {
+
+    companion object {
+        const val REACT_CLASS = "PaywalloWebView"
+        const val COMMAND_INJECT_JS = 1
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): PaywalloWebView {
+        return PaywalloWebView(context)
+    }
+
+    @ReactProp(name = "sourceUrl")
+    fun setSourceUrl(view: PaywalloWebView, url: String?) {
+        view.setSourceUrl(url)
+    }
+
+    @ReactProp(name = "sourceHtml")
+    fun setSourceHtml(view: PaywalloWebView, html: String?) {
+        view.setSourceHtml(html)
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+        return MapBuilder.builder<String, Any>()
+            .put("onMessage", MapBuilder.of("registrationName", "onMessage"))
+            .put("onLoadEnd", MapBuilder.of("registrationName", "onLoadEnd"))
+            .build()
+    }
+
+    override fun getCommandsMap(): Map<String, Int>? {
+        return MapBuilder.of("injectJavaScript", COMMAND_INJECT_JS)
+    }
+
+    override fun receiveCommand(view: PaywalloWebView, commandId: String?, args: ReadableArray?) {
+        when (commandId) {
+            "injectJavaScript" -> {
+                val script = args?.getString(0) ?: return
+                view.injectJavaScript(script)
+            }
+        }
+    }
+}