@qonversion/react-native-sdk 10.0.0-RC1

package/README.md

@@ -0,0 +1,129 @@
+<h1 align="center">
+    Qonversion
+</h1>
+
+Qonversion - In-app subscription monetization: implement subscriptions and grow your app’s revenue with A/B experiments 
+
+* In-app subscription management SDK
+* API and webhooks to make your subscription data available where you need it
+* Seamless Stripe integration to enable cross-platform access management
+* Subscribers CRM with user-level transactions
+* Instant access to real-time subscription analytics
+* Built-in A/B experiments for subscription business model
+
+<p align="center">
+     <a href="https://qonversion.io"><img width="90%" src="https://qcdn3.sfo3.digitaloceanspaces.com/github/qonversion_platform.png">
+     </a>
+</p>
+
+[![npm](https://img.shields.io/npm/v/react-native-qonversion)](https://www.npmjs.com/package/react-native-qonversion)
+[![MIT License](http://img.shields.io/cocoapods/l/Qonversion.svg?style=flat)](https://qonversion.io)
+
+
+## In-App Subscription Implementation & Management
+
+<p align="center">
+     <a href="https://documentation.qonversion.io/docs/integrations-overview"><img width="90%" src="https://user-images.githubusercontent.com/13959241/161107203-8ef3ecee-86be-47a2-ac57-b21d3da19339.png">
+     </a>
+</p>
+
+1. Qonversion SDK provides three simple methods to manage subscriptions:
+	* Get in-app product details
+	* Make purchases
+	* Check subscription status to manage premium access
+2. Qonversion communicates with Apple or Google platforms both through SDK and server-side to process native in-app payments and keep subscription statuses up to date.
+3. You can use Qonversion webhooks and API in addition to SDK to get user-level data where you need it.
+
+See the [quick start guide documentation](https://documentation.qonversion.io/docs/quickstart).
+
+## Analytics
+
+Qonversion provides advanced subscription analytics out of the box. You can monitor real-time metrics from new users and trial-to-paid conversions to revenue, MRR, ARR, cohort retention, and more. Understand your customers and make better decisions with precise subscription analytics.
+
+<p align="center">
+     <a href="https://documentation.qonversion.io/docs/analytics"><img width="90%" src="https://files.readme.io/9a4fdf6-Analytics.png">
+     </a>
+</p>
+
+
+## A/B Experiments
+
+Qonversion's A/B Experiments feature provides everything required to quickly launch paywall and other monetization experiments, analyze results and roll out winning versions without releasing a new app build. Qonversion A/B Experiments include:
+
+* User segmentation by country, install date, app version, free/paying user
+* Traffic allocation
+* Advanced subscription analytics
+* Visualization of A/B experiments results
+* Statistical significance of the results
+* Roll out winning versions without app release with remote config
+
+
+<p align="center">
+     <a href="https://documentation.qonversion.io/docs/subscription-ab-testing"><img width="90%" src="https://qcdn3.sfo3.digitaloceanspaces.com/github/ab_tests.png">
+     </a>
+</p>
+
+See more details [here](https://documentation.qonversion.io/docs/paywall-experiments).
+
+## Integrations
+
+Send user-level subscription data to your favorite platforms.
+
+* Amplitude
+* Mixpanel
+* Appsflyer
+* Adjust
+* Singular
+* CleverTap
+* [All other integrations here](qonversion.io/integrations)
+
+<p align="center">
+     <a href="https://documentation.qonversion.io/docs/integrations-overview"><img width="90%", src="https://qcdn3.sfo3.digitaloceanspaces.com/github/integrations.png">
+     </a>
+</p>
+
+## Why Qonversion?
+
+* **No headaches with Apple's StoreKit & Google Billing.** Qonversion provides simple methods to handle Apple StoreKit & Google Billing purchase flow.
+* **Receipt validation.** Qonversion validates user receipts with Apple and Google to provide 100% accurate purchase information and subscription statuses. It also prevents unauthorized access to the premium features of your app.
+* **Track and increase your revenue.** Qonversion provides detailed real-time revenue analytics including cohort analysis, trial conversion rates, country segmentation, and much more.
+* **Integrations with the leading mobile platforms.** Qonversion allows sending data to platforms like AppsFlyer, Adjust, Branch, Tenjin, Facebook Ads, Amplitude, Mixpanel, and many others.
+* **Change promoted in-app products.** Change promoted in-app products anytime without app releases.
+* **A/B test** and identify winning in-app purchases, subscriptions, or paywalls.
+* **Cross-device and cross-platform access management.** If you provide user authorization in your app, you can easily set Qonversion to provide premium access to authorized users across devices and operating systems.
+* **SDK caches the data.** Qonversion SDK caches purchase data including in-app products and entitlements, so the user experience is not affected even with a slow or interrupted network connection.
+* **Webhooks.** You can easily send all the data to your server with Qonversion webhooks.
+* **Customer support.** You can always reach out to our customer support and get the help required.
+
+Convinced? Let's go!
+
+## Documentation
+
+Check the [full documentation](https://documentation.qonversion.io/docs/quickstart) to learn about implementation details and available features.
+
+#### Help us improve the documentation
+
+Whether you’re a core user or trying it out for the first time, you can make a valuable contribution to Qonversion by improving the documentation. Help us by:
+
+* sending us feedback about something you thought was confusing or simply missing
+* sending us a pull request via GitHub
+* suggesting better wording or ways of explaining certain topics in the [Qonversion documentation](http://documentation.qonversion.io). Use `SUGGEST EDITS` button in the top right corner.
+
+## Contributing
+
+Contributions are what make the open-source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/SuperFeature`)
+3. Commit your Changes. Use small commits with separate logic. (`git commit -m 'Add some super feature'`)
+4. Push to the Branch (`git push origin feature/SuperFeature`)
+5. Open a Pull Request
+
+
+## Have a question?
+
+Contact us via [issues on GitHub](https://github.com/qonversion/react-native-sdk/issues) or [ask a question](https://documentation.qonversion.io/discuss-new) on the site.
+
+## License
+
+Qonversion SDK is available under the MIT license.

package/android/build.gradle

@@ -0,0 +1,92 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeSdk_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeSdk_" + name]).toInteger()
+}
+
+android {
+  namespace "com.qonversion.reactnativesdk"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "io.qonversion:sandwich:6.0.10"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "ReactNativeSdk"
+    codegenJavaPackageName = "com.qonversion.reactnativesdk"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,6 @@
+ReactNativeSdk_kotlinVersion=2.0.21
+ReactNativeSdk_minSdkVersion=24
+ReactNativeSdk_targetSdkVersion=34
+ReactNativeSdk_compileSdkVersion=35
+ReactNativeSdk_ndkVersion=27.1.12297006
+newArchEnabled=true

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/qonversion/reactnativesdk/EntitiesConverter.kt

@@ -0,0 +1,135 @@
+package com.qonversion.reactnativesdk
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableMapKeySetIterator
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+
+class EntitiesConverter {
+    companion object {
+        @Throws(JSONException::class)
+        fun convertReadableMapToHashMap(readableMap: ReadableMap): HashMap<String, Any> {
+            val jsonObject = convertMapToJson(readableMap)
+            return toMap(jsonObject) as HashMap<String, Any>
+        }
+
+        @Throws(JSONException::class)
+        fun toMap(jsonObj: JSONObject): Map<String, Any> {
+            val map: MutableMap<String, Any> = HashMap()
+            val keys: Iterator<String> = jsonObj.keys()
+            while (keys.hasNext()) {
+                val key = keys.next()
+                var value = jsonObj[key]
+                if (value is JSONArray) {
+                    value = toList(value)
+                } else if (value is JSONObject) {
+                    value = toMap(value)
+                }
+                map[key] = value
+            }
+            return map
+        }
+
+        @Throws(JSONException::class)
+        fun toList(array: JSONArray): List<Any> {
+            val list: MutableList<Any> = ArrayList()
+            for (i in 0 until array.length()) {
+                var value = array[i]
+                if (value is JSONArray) {
+                    value = toList(value)
+                } else if (value is JSONObject) {
+                    value = toMap(value)
+                }
+                list.add(value)
+            }
+            return list
+        }
+
+        @Throws(JSONException::class)
+        fun convertMapToJson(readableMap: ReadableMap): JSONObject {
+            val `object` = JSONObject()
+            val iterator: ReadableMapKeySetIterator = readableMap.keySetIterator()
+            while (iterator.hasNextKey()) {
+                val key = iterator.nextKey()
+                when (readableMap.getType(key)) {
+                    ReadableType.Null -> `object`.put(key, JSONObject.NULL)
+                    ReadableType.Boolean -> `object`.put(key, readableMap.getBoolean(key))
+                    ReadableType.Number -> `object`.put(key, readableMap.getDouble(key))
+                    ReadableType.String -> `object`.put(key, readableMap.getString(key))
+                    ReadableType.Map -> `object`.put(key, convertMapToJson(readableMap.getMap(key)!!))
+                    ReadableType.Array -> `object`.put(key, convertArrayToJson(readableMap.getArray(key)!!))
+                }
+            }
+            return `object`
+        }
+
+        @Throws(JSONException::class)
+        fun convertArrayToJson(readableArray: ReadableArray): JSONArray {
+            val array = JSONArray()
+            for (i in 0 until readableArray.size()) {
+                when (readableArray.getType(i)) {
+                    ReadableType.Null -> {}
+                    ReadableType.Boolean -> array.put(readableArray.getBoolean(i))
+                    ReadableType.Number -> array.put(readableArray.getDouble(i))
+                    ReadableType.String -> array.put(readableArray.getString(i))
+                    ReadableType.Map -> array.put(convertMapToJson(readableArray.getMap(i)!!))
+                    ReadableType.Array -> array.put(convertArrayToJson(readableArray.getArray(i)!!))
+                }
+            }
+            return array
+        }
+
+        fun convertArrayToStringList(readableArray: ReadableArray): List<String> {
+            val list: MutableList<String> = ArrayList()
+            for (i in 0 until readableArray.size()) {
+                list.add(readableArray.getString(i)!!)
+            }
+            return list
+        }
+
+        fun convertListToWritableArray(list: List<*>): WritableArray {
+            val array: WritableArray = WritableNativeArray()
+            for (i in list.indices) {
+                val value = list[i]
+                when (value) {
+                    is String -> array.pushString(value)
+                    is Int -> array.pushInt(value)
+                    is Long -> array.pushDouble(value.toDouble())
+                    is Double -> array.pushDouble(value)
+                    is Float -> array.pushDouble(value.toDouble())
+                    is Boolean -> array.pushBoolean(value)
+                    is List<*> -> array.pushArray(convertListToWritableArray(value))
+                    is Map<*, *> -> array.pushMap(convertMapToWritableMap(value))
+                }
+            }
+            return array
+        }
+
+        fun convertMapToWritableMap(map: Map<*, *>): WritableMap {
+            val writableMap: WritableMap = WritableNativeMap()
+            val keys: Set<*> = map.keys
+            for (key in keys) {
+                val keyStr = key.toString()
+                val value = map[key]
+                when (value) {
+                    is String -> writableMap.putString(keyStr, value)
+                    is Int -> writableMap.putInt(keyStr, value)
+                    is Long -> writableMap.putDouble(keyStr, value.toDouble())
+                    is Double -> writableMap.putDouble(keyStr, value)
+                    is Float -> writableMap.putDouble(keyStr, value.toDouble())
+                    is Boolean -> writableMap.putBoolean(keyStr, value)
+                    is List<*> -> writableMap.putArray(keyStr, convertListToWritableArray(value))
+                    is Map<*, *> -> writableMap.putMap(keyStr, convertMapToWritableMap(value))
+                }
+            }
+            return writableMap
+        }
+    }
+}

package/android/src/main/java/com/qonversion/reactnativesdk/NoCodesModule.kt

@@ -0,0 +1,76 @@
+package com.qonversion.reactnativesdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import io.qonversion.sandwich.BridgeData
+import io.qonversion.sandwich.NoCodesSandwich
+import io.qonversion.sandwich.NoCodesEventListener
+
+@ReactModule(name = NoCodesModule.NAME)
+class NoCodesModule(private val reactContext: ReactApplicationContext) : NativeNoCodesModuleSpec(reactContext) {
+    private val noCodesSandwich: NoCodesSandwich = NoCodesSandwich()
+    private val noCodesEventListener: NoCodesEventListener = object : NoCodesEventListener {
+        override fun onNoCodesEvent(event: NoCodesEventListener.Event, payload: BridgeData?) {
+            val eventMap: WritableMap = WritableNativeMap()
+            eventMap.putString("name", event.key)
+            payload?.let {
+                val payloadMap = EntitiesConverter.convertMapToWritableMap(it)
+
+                eventMap.putMap("payload", payloadMap)
+            }
+            emitOnNoCodeEvent(eventMap)
+        }
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod
+    override fun initialize(projectKey: String, source: String, version: String) {
+        noCodesSandwich.storeSdkInfo(reactContext, source, version)
+        noCodesSandwich.initialize(reactContext, projectKey, null, null, null)
+        noCodesSandwich.setDelegate(noCodesEventListener)
+        noCodesSandwich.setScreenCustomizationDelegate()
+    }
+
+    @ReactMethod
+    override fun setScreenPresentationConfig(configData: ReadableMap, contextKey: String?, promise: Promise) {
+        try {
+            val config: Map<String, Any> = EntitiesConverter.convertReadableMapToHashMap(configData)
+            noCodesSandwich.setScreenPresentationConfig(config, contextKey)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject(e)
+        }
+    }
+
+    @ReactMethod
+    override fun showScreen(contextKey: String, promise: Promise) {
+        try {
+            noCodesSandwich.showScreen(contextKey)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject(e)
+        }
+    }
+
+    @ReactMethod
+    override fun close(promise: Promise) {
+        try {
+            noCodesSandwich.close()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject(e)
+        }
+    }
+
+    companion object {
+        const val NAME = "RNNoCodes"
+    }
+}