@virex-tech/paywallo-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Monety
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MonetySdk.podspec

@@ -0,0 +1,19 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "MonetySdk"
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.homepage     = "https://github.com/monety/sdk-react-native"
+  s.license      = package['license']
+  s.authors      = { "Monety" => "support@monety.io" }
+  s.platforms    = { :ios => "15.0" }
+  s.source       = { :git => "https://github.com/monety/sdk-react-native.git", :tag => "v#{s.version}" }
+  s.source_files = "ios/**/*.{h,m,swift}"
+  s.frameworks   = "WebKit", "StoreKit"
+  s.swift_version = "5.5"
+
+  s.dependency "React-Core"
+end

package/README.md

@@ -0,0 +1,164 @@
+# @monety/sdk-react-native
+
+SDK oficial para integração com Monety em aplicações React Native. Oferece Analytics, Feature Flags, Paywalls dinâmicas e gerenciamento de In-App Purchases.
+
+## Instalação
+
+```bash
+npm install @monety/sdk-react-native
+```
+
+### Peer Dependencies
+
+O SDK requer as seguintes dependências instaladas no seu projeto:
+
+```bash
+npm install @react-native-async-storage/async-storage @react-native-community/netinfo react-native-iap react-native-device-info
+```
+
+#### Persistência de Device ID (Recomendado)
+
+Para melhor persistência do device ID entre reinstalações do app (especialmente no iOS), instale também:
+
+```bash
+npm install react-native-keychain
+```
+
+Esta dependência é opcional, mas **altamente recomendada**. Com ela:
+- **iOS**: Device ID persiste no Keychain mesmo após desinstalar o app
+- **Android**: Device ID é armazenado de forma segura no Keystore
+
+Sem ela, o SDK usa AsyncStorage como fallback (funciona, mas não persiste após desinstalação).
+
+Para iOS:
+```bash
+cd ios && pod install
+```
+
+## Quick Start
+
+### 1. Configure o Provider
+
+```tsx
+import { PanelProvider } from '@monety/sdk-react-native';
+
+export default function App() {
+  return (
+    <PanelProvider
+      config={{
+        appKey: 'sua_app_key',
+        debug: __DEV__,
+      }}
+    >
+      <YourApp />
+    </PanelProvider>
+  );
+}
+```
+
+### 2. Use os Hooks
+
+```tsx
+import { usePanel, useSubscription } from '@monety/sdk-react-native';
+
+function MyComponent() {
+  const { presentPaywall, hasActiveSubscription } = usePanel();
+  const { subscription } = useSubscription();
+
+  const handlePurchase = async () => {
+    const hasAccess = await hasActiveSubscription();
+    if (!hasAccess) {
+      await presentPaywall('default');
+    }
+  };
+
+  return (
+    <Button onPress={handlePurchase}>
+      {subscription ? 'Premium' : 'Upgrade'}
+    </Button>
+  );
+}
+```
+
+## API Principal
+
+### PanelProvider
+
+Provider que inicializa o SDK e disponibiliza o contexto para toda a aplicação.
+
+```tsx
+<PanelProvider config={PanelConfig}>
+  {children}
+</PanelProvider>
+```
+
+### usePanel()
+
+Hook principal com acesso a todas as funcionalidades:
+
+- `isInitialized` - Se o SDK foi inicializado
+- `distinctId` - ID único do usuário
+- `presentPaywall(placement)` - Apresenta uma paywall
+- `hasActiveSubscription()` - Verifica se há assinatura ativa
+- `getSubscription()` - Obtém dados da assinatura
+- `restorePurchases()` - Restaura compras anteriores
+
+### useSubscription()
+
+Hook para gerenciamento de assinaturas:
+
+- `subscription` - Dados da assinatura atual
+- `isLoading` - Estado de carregamento
+- `refresh()` - Atualiza dados da assinatura
+
+### Panel (API Imperativa)
+
+Para uso fora de componentes React:
+
+```tsx
+import { Panel } from '@monety/sdk-react-native';
+
+// Identificar usuário
+await Panel.identify('user_123', { email: 'user@example.com' });
+
+// Rastrear evento
+await Panel.track('purchase_completed', { product: 'premium' });
+
+// Feature Flags
+const variant = await Panel.getVariant('new_feature');
+```
+
+## Tipos
+
+```tsx
+interface PanelConfig {
+  appKey: string;
+  baseUrl?: string;
+  debug?: boolean;
+  environment?: 'Production' | 'Sandbox';
+}
+
+interface Subscription {
+  productId: string;
+  status: 'active' | 'expired' | 'cancelled' | 'in_grace_period';
+  expiresAt: Date | null;
+  platform: 'ios' | 'android';
+  autoRenewEnabled: boolean;
+}
+
+interface PaywallResult {
+  presented: boolean;
+  purchased: boolean;
+  restored: boolean;
+  cancelled: boolean;
+  error?: Error;
+}
+```
+
+## Suporte
+
+Para dúvidas ou problemas, entre em contato com o suporte Monety.
+
+## Licença
+
+MIT

package/android/build.gradle

@@ -0,0 +1,54 @@
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.android.tools.build:gradle:7.4.2")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.9.22')}")
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.monety.sdk"
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 24)
+        targetSdkVersion safeExtGet('targetSdkVersion', 34)
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = ['src/main/java']
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', '1.9.22')}"
+    implementation "com.android.billingclient:billing-ktx:7.0.0"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+}

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

@@ -0,0 +1,16 @@
+package com.monety.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 MonetySdkPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(PanelStoreKitModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(PanelWebViewManager(reactContext))
+    }
+}

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

@@ -0,0 +1,315 @@
+package com.monety.sdk
+
+import android.app.Activity
+import com.android.billingclient.api.*
+import com.facebook.react.bridge.*
+import kotlinx.coroutines.*
+
+class PanelStoreKitModule(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() = "PanelStoreKit"
+
+    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/monety/sdk/PanelWebView.kt

@@ -0,0 +1,74 @@
+package com.monety.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 PanelWebView(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.monety.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) }
+        }
+    }
+}