@virex-tech/paywallo-sdk 1.5.4 → 2.0.1

package/PaywalloSdk.podspec

@@ -12,7 +12,7 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => "15.0" }
   s.source       = { :git => "https://github.com/paywallo/sdk-react-native.git", :tag => "v#{s.version}" }
   s.source_files = "ios/**/*.{h,m,mm,swift}"
-  s.frameworks   = "Security", "StoreKit", "WebKit", "CoreTelephony", "AVFoundation"
+  s.frameworks   = "Security", "StoreKit", "WebKit", "CoreTelephony", "AVFoundation", "UserNotifications"
   s.swift_version = "5.5"
 
   s.dependency "React-Core"

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath("com.android.tools.build:gradle:7.4.2")
+        classpath("com.android.tools.build:gradle:${safeExtGet('androidGradlePluginVersion', '7.4.2')}")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.9.22')}")
     }
 }
@@ -53,6 +53,7 @@ dependencies {
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
     compileOnly "com.facebook.android:facebook-android-sdk:17.+"
+    compileOnly "com.google.firebase:firebase-messaging:24.0.0"
     implementation "androidx.security:security-crypto:1.0.0"
     implementation "com.android.installreferrer:installreferrer:2.2"
 }

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.paywallo.sdk">
+
+    <application>
+        <!--
+            PaywalloFirebaseMessagingService handles FCM token refresh and message delivery.
+            If the host app declares its own FirebaseMessagingService, Android will only
+            invoke ONE service (the one declared in the final merged manifest, typically
+            the host app's). In that case, the host app's service must forward
+            onNewToken/onMessageReceived to PaywalloFirebaseMessagingService manually,
+            or use Firebase's automatic message routing with multiple services.
+        -->
+        <service
+            android:name=".PaywalloFirebaseMessagingService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
+    </application>
+</manifest>

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

@@ -0,0 +1,67 @@
+package com.paywallo.sdk
+
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.ReactApplication
+
+class PaywalloFirebaseMessagingService : FirebaseMessagingService() {
+
+    companion object {
+        const val TOKEN_REFRESH_EVENT = "PaywalloTokenRefresh"
+        const val MESSAGE_RECEIVED_EVENT = "PaywalloMessageReceived"
+
+        @Volatile
+        var latestToken: String? = null
+
+        @Volatile
+        var pendingMessage: WritableNativeMap? = null
+    }
+
+    override fun onNewToken(token: String) {
+        super.onNewToken(token)
+        latestToken = token
+        emitEvent(TOKEN_REFRESH_EVENT, WritableNativeMap().apply {
+            putString("token", token)
+        })
+    }
+
+    override fun onMessageReceived(message: RemoteMessage) {
+        super.onMessageReceived(message)
+        val map = WritableNativeMap().apply {
+            putString("messageId", message.messageId ?: "")
+            message.notification?.let { n ->
+                putString("title", n.title ?: "")
+                putString("body", n.body ?: "")
+                putString("imageUrl", n.imageUrl?.toString())
+            }
+            val dataMap = WritableNativeMap()
+            message.data.forEach { (k, v) -> dataMap.putString(k, v) }
+            putMap("data", dataMap)
+            putDouble("sentTime", message.sentTime.toDouble())
+        }
+        emitEvent(MESSAGE_RECEIVED_EVENT, map)
+    }
+
+    private fun emitEvent(eventName: String, data: WritableNativeMap) {
+        try {
+            val reactContext = (application as? ReactApplication)
+                ?.reactNativeHost
+                ?.reactInstanceManager
+                ?.currentReactContext
+            if (reactContext != null) {
+                reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit(eventName, data)
+            } else if (eventName == MESSAGE_RECEIVED_EVENT) {
+                // Cold start: React context not ready — buffer for getInitialNotification()
+                pendingMessage = data
+            }
+        } catch (_: Exception) {
+            if (eventName == MESSAGE_RECEIVED_EVENT) {
+                pendingMessage = data
+            }
+        }
+    }
+}

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

@@ -0,0 +1,169 @@
+package com.paywallo.sdk
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class PaywalloNotificationsModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private var permissionPromise: Promise? = null
+    private val PERMISSION_REQUEST_CODE = 1001
+
+    private val activityEventListener = object : BaseActivityEventListener() {
+        override fun onRequestPermissionsResult(
+            requestCode: Int,
+            permissions: Array<out String>,
+            grantResults: IntArray
+        ) {
+            if (requestCode != PERMISSION_REQUEST_CODE) return
+            val promise = permissionPromise ?: return
+            permissionPromise = null
+
+            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+                promise.resolve("granted")
+            } else {
+                promise.resolve("denied")
+            }
+        }
+    }
+
+    init {
+        reactContext.addActivityEventListener(activityEventListener)
+    }
+
+    override fun getName() = "PaywalloNotifications"
+
+    // Required for NativeEventEmitter on Android (silences the warning and
+    // gives RN the hook it needs to wire listeners).
+    @ReactMethod
+    fun addListener(eventName: String) {}
+
+    @ReactMethod
+    fun removeListeners(count: Int) {}
+
+    @ReactMethod
+    fun getToken(promise: Promise) {
+        // First check static holder from FirebaseMessagingService
+        val cached = PaywalloFirebaseMessagingService.latestToken
+        if (cached != null) {
+            promise.resolve(cached)
+            return
+        }
+        // Fallback: ask Firebase directly.
+        // Catch Throwable (not just Exception) to handle NoClassDefFoundError when
+        // firebase-messaging is absent at runtime (compileOnly dependency).
+        try {
+            com.google.firebase.messaging.FirebaseMessaging.getInstance().token
+                .addOnCompleteListener { task ->
+                    if (task.isSuccessful) {
+                        val token = task.result
+                        PaywalloFirebaseMessagingService.latestToken = token
+                        promise.resolve(token)
+                    } else {
+                        android.util.Log.d("PaywalloNotifications", "FCM token request failed: ${task.exception?.message}")
+                        promise.resolve(null)
+                    }
+                }
+        } catch (e: Throwable) {
+            android.util.Log.d("PaywalloNotifications", "Firebase not available: ${e.message}")
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun requestPermission(options: ReadableMap?, promise: Promise) {
+        // Android 13+ (API 33) requires POST_NOTIFICATIONS runtime permission
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val activity = currentActivity
+            if (activity == null) {
+                promise.resolve("denied")
+                return
+            }
+            val granted = ContextCompat.checkSelfPermission(
+                activity, Manifest.permission.POST_NOTIFICATIONS
+            ) == PackageManager.PERMISSION_GRANTED
+
+            if (granted) {
+                promise.resolve("granted")
+            } else {
+                // If there's already a pending promise, reject it before storing the new one
+                permissionPromise?.reject("PERMISSION_SUPERSEDED", "New permission request superseded this one")
+                // Store promise and wait for onRequestPermissionsResult callback
+                permissionPromise = promise
+                ActivityCompat.requestPermissions(
+                    activity,
+                    arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+                    PERMISSION_REQUEST_CODE
+                )
+            }
+        } else {
+            // Pre-Android 13: notifications always allowed
+            promise.resolve("granted")
+        }
+    }
+
+    @ReactMethod
+    fun hasPermission(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val granted = ContextCompat.checkSelfPermission(
+                reactContext, Manifest.permission.POST_NOTIFICATIONS
+            ) == PackageManager.PERMISSION_GRANTED
+            promise.resolve(if (granted) "granted" else "denied")
+        } else {
+            promise.resolve("granted")
+        }
+    }
+
+    @ReactMethod
+    fun getInitialNotification(promise: Promise) {
+        // Check buffered data-only message from cold start first
+        val pending = PaywalloFirebaseMessagingService.pendingMessage
+        if (pending != null) {
+            PaywalloFirebaseMessagingService.pendingMessage = null
+            promise.resolve(pending)
+            return
+        }
+
+        // Check if the app was opened from a notification tap
+        val activity = currentActivity
+        val intent = activity?.intent
+        val extras = intent?.extras
+
+        if (extras != null && extras.containsKey("google.message_id")) {
+            val map = WritableNativeMap()
+            map.putString("messageId", extras.getString("google.message_id", ""))
+            map.putString("title", extras.getString("gcm.notification.title", ""))
+            map.putString("body", extras.getString("gcm.notification.body", ""))
+
+            val data = WritableNativeMap()
+            for (key in extras.keySet()) {
+                if (!key.startsWith("google.") && !key.startsWith("gcm.") && key != "from" && key != "collapse_key") {
+                    val value = extras.getString(key)
+                    if (value != null) data.putString(key, value)
+                }
+            }
+            map.putMap("data", data)
+
+            // Consume once — replace the intent's extras entirely so
+            // subsequent calls to getInitialNotification() return null.
+            // intent.removeExtra() mutates the same Bundle object in place
+            // but the Activity retains the original intent; replacing the
+            // extras Bundle is the only reliable way to prevent double-delivery.
+            intent.replaceExtras(android.os.Bundle())
+            promise.resolve(map)
+        } else {
+            promise.resolve(null)
+        }
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        reactContext.removeActivityEventListener(activityEventListener)
+        permissionPromise = null
+        super.onCatalystInstanceDestroy()
+    }
+}

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

@@ -11,7 +11,8 @@ class PaywalloSdkPackage : ReactPackage {
             PaywalloStoreKitModule(reactContext),
             PaywalloFBBridgeModule(reactContext),
             PaywalloStorageModule(reactContext),
-            PaywalloDeviceModule(reactContext)
+            PaywalloDeviceModule(reactContext),
+            PaywalloNotificationsModule(reactContext)
         )
     }
 

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

@@ -3,6 +3,7 @@ package com.paywallo.sdk
 import android.app.Activity
 import com.android.billingclient.api.*
 import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.*
 
 class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext) :
@@ -12,8 +13,45 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
     private var purchasePromise: Promise? = null
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
 
+    // Tokens seen in the last getActiveTransactions() call. Used to detect
+    // refunds: a token that was active before but is missing on the next
+    // query has been refunded/revoked server-side and we surface it to JS as
+    // a `refunded` transaction update.
+    private val knownActiveTokens = mutableSetOf<String>()
+
+    companion object {
+        private const val TRANSACTION_UPDATE_EVENT = "PaywalloTransactionUpdate"
+    }
+
     override fun getName() = "PaywalloStoreKit"
 
+    // Required for NativeEventEmitter on Android (silences the warning and
+    // gives RN the hook it needs to wire listeners).
+    @ReactMethod
+    fun addListener(eventName: String) {}
+
+    @ReactMethod
+    fun removeListeners(count: Int) {}
+
+    private fun emitTransactionUpdate(
+        type: String,
+        transactionId: String,
+        productId: String,
+        amount: Double? = null,
+        currency: String? = null
+    ) {
+        val map = WritableNativeMap()
+        map.putString("type", type)
+        map.putString("transactionId", transactionId)
+        map.putString("productId", productId)
+        if (amount != null) map.putDouble("amount", amount)
+        if (currency != null) map.putString("currency", currency)
+
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(TRANSACTION_UPDATE_EVENT, map)
+    }
+
     private fun ensureBillingClient(): BillingClient {
         if (billingClient == null || billingClient?.isReady != true) {
             billingClient = BillingClient.newBuilder(reactContext)
@@ -206,6 +244,42 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
     }
 
     override fun onPurchasesUpdated(result: BillingResult, purchases: List<Purchase>?) {
+        // ITEM_ALREADY_OWNED is Google Play's signal for "this user is already
+        // subscribed" — which on auto-renewing subs also fires when the
+        // backend renews the entitlement. We surface it as `renewed` so the
+        // EventBatcher pipeline gets parity with StoreKit 2.
+        if (result.responseCode == BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED) {
+            scope.launch {
+                try {
+                    val client = billingClient ?: return@launch
+                    // Query both SUBS and INAPP — ITEM_ALREADY_OWNED fires for
+                    // one-time purchases (consumables not yet consumed) as well
+                    // as auto-renewing subscriptions. Checking only SUBS would
+                    // silently drop INAPP renewal recognition.
+                    val activeSubs = client.queryPurchasesAsync(
+                        QueryPurchasesParams.newBuilder()
+                            .setProductType(BillingClient.ProductType.SUBS)
+                            .build()
+                    )
+                    val activeInapp = client.queryPurchasesAsync(
+                        QueryPurchasesParams.newBuilder()
+                            .setProductType(BillingClient.ProductType.INAPP)
+                            .build()
+                    )
+                    val allPurchases = activeSubs.purchasesList + activeInapp.purchasesList
+                    allPurchases.forEach { p ->
+                        if (p.purchaseState == Purchase.PurchaseState.PURCHASED) {
+                            emitTransactionUpdate(
+                                type = "renewed",
+                                transactionId = p.orderId ?: p.purchaseToken,
+                                productId = p.products.firstOrNull() ?: ""
+                            )
+                        }
+                    }
+                } catch (_: Exception) { }
+            }
+        }
+
         val promise = purchasePromise ?: return
         purchasePromise = null
 
@@ -214,6 +288,11 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
                 val purchase = purchases?.firstOrNull()
                 if (purchase != null) {
                     if (purchase.purchaseState == Purchase.PurchaseState.PENDING) {
+                        emitTransactionUpdate(
+                            type = "pending",
+                            transactionId = purchase.orderId ?: purchase.purchaseToken,
+                            productId = purchase.products.firstOrNull() ?: ""
+                        )
                         val map = WritableNativeMap()
                         map.putBoolean("pending", true)
                         promise.resolve(map)
@@ -232,6 +311,11 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
             BillingClient.BillingResponseCode.USER_CANCELED -> {
                 promise.resolve(null)
             }
+            BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED -> {
+                // Renewal path: resolve null so JS doesn't crash and let the
+                // emitted `renewed` event drive the analytics update.
+                promise.resolve(null)
+            }
             else -> {
                 promise.reject("PURCHASE_ERROR", "Purchase failed: ${result.debugMessage}")
             }
@@ -306,8 +390,10 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
                         .build()
                 )
 
+                val seenTokens = mutableSetOf<String>()
                 for (purchase in subsResult.purchasesList) {
                     if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
+                        seenTokens.add(purchase.purchaseToken)
                         val map = WritableNativeMap()
                         map.putString("transactionId", purchase.orderId ?: purchase.purchaseToken)
                         map.putString("productId", purchase.products.firstOrNull() ?: "")
@@ -317,6 +403,23 @@ class PaywalloStoreKitModule(private val reactContext: ReactApplicationContext)
                     }
                 }
 
+                // Refund detection: tokens we saw in the previous restore but
+                // are no longer active have been revoked. Google Play Billing
+                // has no native "refund" callback in the client SDK — this
+                // diff is the best signal available from the device.
+                val refunded = knownActiveTokens - seenTokens
+                if (refunded.isNotEmpty()) {
+                    for (token in refunded) {
+                        emitTransactionUpdate(
+                            type = "refunded",
+                            transactionId = token,
+                            productId = ""
+                        )
+                    }
+                }
+                knownActiveTokens.clear()
+                knownActiveTokens.addAll(seenTokens)
+
                 promise.resolve(result)
             } catch (e: Exception) {
                 promise.resolve(WritableNativeArray())