expo-superwall 0.0.1-beta.0

package/android/src/main/java/expo/modules/superwallexpo/SuperwallExpoModule.kt

@@ -0,0 +1,367 @@
+package expo.modules.superwallexpo
+
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.app.Application
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.Promise
+import expo.modules.superwallexpo.bridges.PurchaseControllerBridge
+import expo.modules.superwallexpo.bridges.SuperwallDelegateBridge
+import expo.modules.superwallexpo.json.*
+import com.superwall.sdk.Superwall
+import com.superwall.sdk.delegate.SuperwallDelegate
+import com.superwall.sdk.delegate.PurchaseResult
+import com.superwall.sdk.delegate.RestorationResult
+import com.superwall.sdk.models.entitlements.SubscriptionStatus
+import com.superwall.sdk.models.entitlements.Entitlement
+import com.superwall.sdk.identity.IdentityOptions
+import com.superwall.sdk.identity.identify
+import com.superwall.sdk.identity.setUserAttributes
+import com.superwall.sdk.config.options.SuperwallOptions
+import com.superwall.sdk.logger.LogLevel
+import com.superwall.sdk.network.device.InterfaceStyle
+import com.superwall.sdk.paywall.presentation.PaywallPresentationHandler
+import com.superwall.sdk.paywall.presentation.result.PresentationResult
+import com.superwall.sdk.config.models.ConfigurationStatus
+import com.superwall.sdk.paywall.presentation.register
+import com.superwall.sdk.paywall.presentation.dismiss
+import com.superwall.sdk.paywall.presentation.get_presentation_result.getPresentationResult
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class SuperwallExpoModule : Module() {
+
+  companion object {
+    var instance: SuperwallExpoModule? = null
+  }
+
+  val scope = CoroutineScope(Dispatchers.Main)
+  val ioScope = CoroutineScope(Dispatchers.IO)
+  init {
+    instance = this
+  }
+
+  fun emitEvent(name: String, body: Map<String, Any?>?) {
+    SuperwallExpoModule.instance?.sendEvent(name, body?:emptyMap())
+  }
+
+  private val onPaywallPresent = "onPaywallPresent"
+  private val onPaywallDismiss = "onPaywallDismiss"
+  private val onPaywallError = "onPaywallError"
+  private val onPaywallSkip = "onPaywallSkip"
+
+  // Purchase Events
+  private val onPurchase = "onPurchase"
+  private val onPurchaseRestore = "onPurchaseRestore"
+
+  // Legacy Events
+  private val subscriptionStatusDidChange = "subscriptionStatusDidChange"
+  private val handleSuperwallEvent = "handleSuperwallEvent"
+  private val handleCustomPaywallAction = "handleCustomPaywallAction"
+  private val willDismissPaywall = "willDismissPaywall"
+  private val willPresentPaywall = "willPresentPaywall"
+  private val didDismissPaywall = "didDismissPaywall"
+  private val didPresentPaywall = "didPresentPaywall"
+  private val paywallWillOpenURL = "paywallWillOpenURL"
+  private val paywallWillOpenDeepLink = "paywallWillOpenDeepLink"
+  private val handleLog = "handleLog"
+  private val willRedeemLink = "willRedeemLink"
+  private val didRedeemLink = "didRedeemLink"
+  val purchaseController = PurchaseControllerBridge.instance
+
+  override fun definition() = ModuleDefinition {
+
+
+    Name("SuperwallExpo")
+
+    Events(
+      onPaywallPresent,
+      onPaywallDismiss,
+      onPaywallError,
+      onPaywallSkip,
+      onPurchase,
+      onPurchaseRestore,
+
+      // Legacy events
+      subscriptionStatusDidChange,
+      handleSuperwallEvent,
+      handleCustomPaywallAction,
+      willDismissPaywall,
+      willPresentPaywall,
+      didDismissPaywall,
+      didPresentPaywall,
+      paywallWillOpenURL,
+      paywallWillOpenDeepLink,
+      handleLog,
+      willRedeemLink,
+      didRedeemLink
+    )
+
+    Function("getApiKey") {
+      val applicationInfo = appContext?.reactContext?.packageManager?.getApplicationInfo(appContext?.reactContext?.packageName.toString(), PackageManager.GET_META_DATA)
+      return@Function applicationInfo?.metaData?.getString("SUPERWALL_API_KEY")
+    }
+
+    Function("identify") { userId: String, options: Map<String, Any> ->
+      try {
+        val options = identityOptionsFromJson(options)
+        Superwall.instance.identify(userId = userId, options = options)
+      } catch (error: Exception) {
+        error.printStackTrace()
+      }
+    }
+
+    Function("reset") {
+      Superwall.instance.reset()
+    }
+
+    AsyncFunction("configure") {
+      apiKey: String,
+      options: Map<String, Any>?,
+      usingPurchaseController: Boolean?,
+      sdkVersion: String?,
+      promise: Promise ->
+      //TODO SDK version in arguments?
+      val superwallOptions: SuperwallOptions = options?.let {
+        superwallOptionsFromJson(options)
+      }?:SuperwallOptions()
+
+
+      Superwall.configure(
+        apiKey = apiKey,
+        applicationContext = appContext.reactContext?.applicationContext as Application,
+        purchaseController = if (usingPurchaseController == true) purchaseController else null,
+        activityProvider = ExpoActivityProvider(appContext),
+        options = superwallOptions,
+        completion = {
+          Superwall.instance.setPlatformWrapper("React Native", version = "sdkVersion" ?: "0.0.0")
+          promise.resolve(true)
+         }
+       )
+    }
+
+    AsyncFunction("getConfigurationStatus") { promise: Promise ->
+      try {
+        val configurationStatus = Superwall.instance.configurationState.asString()
+          promise.resolve(configurationStatus)
+        } catch (error: Throwable) {
+          promise.reject(CodedException(error))
+        }
+      }
+
+    AsyncFunction("registerPlacement") {
+      placement: String,
+      params: Map<String, Any>?,
+      handlerId: String?,
+      promise: Promise ->
+
+
+
+      var handler: PaywallPresentationHandler? = handlerId?.let {
+        PaywallPresentationHandler()
+      }
+
+
+
+        handler?.onPresent { paywallInfo ->
+          val data =
+          mapOf(
+            "paywallInfoJson" to paywallInfo.toJson(),
+          "handlerId" to handlerId)
+          sendEvent(onPaywallPresent, data)
+        }
+
+
+
+        handler?.onDismiss { paywallInfo, result ->
+          val data =
+          mapOf(
+            "paywallInfoJson" to paywallInfo.toJson(),
+          "result" to result.toJson(),
+          "handlerId" to handlerId)
+          
+          sendEvent(onPaywallDismiss, data)
+        }
+
+        handler?.onError { error ->
+          val data =
+          mapOf(
+            "errorString" to error.localizedMessage,
+          "handlerId" to handlerId,
+          )
+          sendEvent(onPaywallError, data)
+        }
+
+        handler?.onSkip { reason ->
+          val data =
+          mapOf(
+            "skippedReason" to reason.toJson(),
+             "handlerId" to handlerId)
+          sendEvent(onPaywallSkip, data)
+        }
+
+      Superwall.instance.register(
+        placement = placement,
+        params = params,
+        handler = handler
+      ) {
+        promise.resolve(null)
+      }
+    }
+    
+
+    AsyncFunction("getAssignments") { promise: Promise ->
+        Superwall.instance.getAssignments()
+        .fold({
+          promise.resolve(it.map { it.toJson() })
+        }, { error ->
+          promise.reject(CodedException(error))
+        })
+      }
+
+    AsyncFunction("getEntitlements") { promise: Promise ->
+      try {
+        val entitlements = Superwall.instance.entitlements
+        val map = mutableMapOf<String, List<Map<String, String>>>()
+        
+        map["all"] = entitlements.all.map { entitlement ->
+          mapOf("id" to entitlement.id)
+        }
+        
+        map["inactive"] = entitlements.inactive.map { entitlement ->
+          mapOf("id" to entitlement.id)
+        }
+        
+        map["active"] = entitlements.active.map { entitlement ->
+          mapOf("id" to entitlement.id)
+        }
+        promise.resolve(map)
+      } catch (error: Exception) {
+        promise.reject(CodedException(error))
+      }
+      }
+
+    AsyncFunction("getSubscriptionStatus") { promise: Promise ->
+      try {
+        val subscriptionStatus = Superwall.instance.subscriptionStatus
+          promise.resolve(subscriptionStatus)
+      } catch (error: Exception) {
+        promise.reject(CodedException(error))
+      }
+    }
+
+    Function("setSubscriptionStatus") { status: Map<String,Any> ->
+      val statusString = (status["status"] as? String)?.uppercase() ?: "UNKNOWN"
+      val subscriptionStatus: SubscriptionStatus
+
+      when (statusString) {
+        "UNKNOWN" -> subscriptionStatus = SubscriptionStatus.Unknown
+        "INACTIVE" -> subscriptionStatus = SubscriptionStatus.Inactive
+        "ACTIVE" -> {
+          val entitlementsArray = status["entitlements"] as? List<Map<String, Any>>
+          val entitlementsSet: Set<Entitlement> = entitlementsArray?.map { item ->
+            val id = item["id"] as? String
+            id?.let { Entitlement(id = it) }
+          }?.filterNotNull()?.toSet() ?: emptySet()
+          subscriptionStatus = SubscriptionStatus.Active(entitlementsSet)
+        }
+        else -> subscriptionStatus = SubscriptionStatus.Unknown
+      }
+
+      Superwall.instance.setSubscriptionStatus(subscriptionStatus)
+    }
+
+    Function("setDelegate") { isUndefined: Boolean ->
+      Superwall.instance.delegate = if (isUndefined) null else SuperwallDelegateBridge()
+    }
+
+    Function("setInterfaceStyle") { style: String? ->
+      var interfaceStyle: InterfaceStyle? = style?.let { interfaceStyleFromString(it) }
+      Superwall.instance.setInterfaceStyle(interfaceStyle)
+    }
+
+    AsyncFunction("getUserAttributes") { promise: Promise ->
+      val attributes = Superwall.instance.userAttributes
+      promise.resolve(attributes)
+    }
+
+    Function("setUserAttributes") { userAttributes: Map<String, Any> ->
+      Superwall.instance.setUserAttributes(userAttributes)
+    }
+
+    AsyncFunction("handleDeepLink") { url: String, promise: Promise ->
+      val url = Uri.parse(url)
+      val result = Superwall.instance.handleDeepLink(url).fold({
+        promise.resolve(it)
+      }, { error ->
+        promise.reject(CodedException(error))
+      })
+    }
+
+    Function("didPurchase") { result: Map<String, Any> ->
+      val purchaseResult = purchaseResultFromJson(result)
+      purchaseController.purchasePromise?.complete(purchaseResult)
+    }
+
+    Function("didRestore") { result: Map<String, Any> ->
+      val restorationResult = restorationResultFromJson(result)
+      purchaseController.restorePromise?.complete(restorationResult)
+    }
+
+    AsyncFunction("dismiss") { promise: Promise ->
+      ioScope.launch {
+        Superwall.instance.dismiss()
+        scope.launch {
+          promise.resolve(null)
+        }
+      }
+    }
+
+    AsyncFunction("confirmAllAssignments") { promise: Promise ->
+      ioScope.launch {
+        Superwall.instance.confirmAllAssignments().fold({
+          scope.launch {
+            promise.resolve(it.map { it.toJson() })
+          }
+        }, { error ->
+          scope.launch {
+            promise.reject(CodedException(error))
+          }
+        })
+      }
+    }
+
+    AsyncFunction("getPresentationResult") { placement: String, params: Map<String, Any>?, promise: Promise ->
+      ioScope.launch {
+        Superwall.instance.getPresentationResult(placement = placement, params = params)
+        .fold({ result ->
+          scope.launch {
+            promise.resolve(result.toJson())
+          }
+        }, { error ->
+          scope.launch {
+            promise.reject(CodedException(error))
+          }
+        })
+      }
+    }
+
+    Function("preloadPaywalls") { placementNames: List<String> ->
+      Superwall.instance.preloadPaywalls(placementNames = placementNames.toSet())
+    }
+
+    Function("preloadAllPaywalls") {
+      Superwall.instance.preloadAllPaywalls()
+    }
+
+    Function("setLogLevel") { level: String ->
+      val logLevel = LogLevel.values().find { it.toString().equals(level, ignoreCase = true) }
+      if (logLevel != null) {
+        Superwall.instance.logLevel = logLevel
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/superwallexpo/bridges/PurchaseControllerBridge.kt

@@ -0,0 +1,59 @@
+package expo.modules.superwallexpo.bridges
+
+import android.app.Activity
+import com.superwall.sdk.delegate.PurchaseResult
+import com.android.billingclient.api.ProductDetails
+import com.superwall.sdk.delegate.RestorationResult
+import com.superwall.sdk.delegate.subscription_controller.PurchaseController
+import kotlinx.coroutines.future.await
+import java.util.concurrent.CompletableFuture
+import expo.modules.superwallexpo.SuperwallExpoModule
+
+class PurchaseControllerBridge(): PurchaseController {
+
+    var purchasePromise: CompletableFuture<PurchaseResult>? = null
+    var restorePromise: CompletableFuture<RestorationResult>? = null
+
+    companion object {
+        val instance = PurchaseControllerBridge()
+    }
+
+    fun completePurchase(result: PurchaseResult) {
+        purchasePromise?.complete(result)
+    }
+
+    fun completeRestore(result: RestorationResult) {
+        restorePromise?.complete(result)
+    }
+
+    override suspend fun purchase(
+        activity: Activity,
+        productDetails: ProductDetails,
+        basePlanId: String?,
+        offerId: String?
+    ): PurchaseResult {
+        purchasePromise = CompletableFuture()
+        
+        val productData = mapOf(
+            "platform" to "android",
+            "productId" to productDetails.productId,
+            "basePlanId" to basePlanId,
+            "offerId" to offerId
+        )
+        
+        SuperwallExpoModule.instance?.emitEvent(
+            "onPurchase",
+            productData
+        )
+
+        return purchasePromise!!.await()
+    }
+
+    override suspend fun restorePurchases(): RestorationResult {
+        restorePromise = CompletableFuture()
+
+        SuperwallExpoModule.instance?.emitEvent("onPurchaseRestore", null)
+
+        return restorePromise!!.await()
+    }
+}

package/android/src/main/java/expo/modules/superwallexpo/bridges/SuperwallDelegateBridge.kt

@@ -0,0 +1,108 @@
+package expo.modules.superwallexpo.bridges
+
+import com.superwall.sdk.delegate.SuperwallDelegate
+import com.superwall.sdk.analytics.superwall.SuperwallEventInfo
+import com.superwall.sdk.paywall.presentation.PaywallInfo
+import com.superwall.sdk.models.entitlements.SubscriptionStatus
+import com.superwall.sdk.models.internal.RedemptionResult
+import java.net.URI
+import android.net.Uri
+import expo.modules.superwallexpo.json.*
+import expo.modules.superwallexpo.SuperwallExpoModule
+class SuperwallDelegateBridge : SuperwallDelegate {
+  override fun subscriptionStatusDidChange(
+    oldValue: SubscriptionStatus,
+    newValue: SubscriptionStatus
+  ) {
+    val data = mapOf<String, Any>(
+      "from" to oldValue.toJson(),
+      "to" to newValue.toJson()
+    )
+    sendEvent("subscriptionStatusDidChange", data)
+  }
+
+  override fun handleSuperwallEvent(eventInfo: SuperwallEventInfo) {
+    val data = mapOf<String, Any?>(
+      "eventInfo" to eventInfo.toJson()
+    )
+    sendEvent("handleSuperwallEvent", data)
+  }
+
+  override fun handleCustomPaywallAction(name: String) {
+    val data = mapOf<String, Any?>(
+      "name" to name
+    )
+    sendEvent("handleCustomPaywallAction", data)
+  }
+
+  override fun willDismissPaywall(withInfo: PaywallInfo) {
+    val data = mapOf<String, Any?>(
+      "info" to withInfo.toJson()
+    )
+    sendEvent("willDismissPaywall", data)
+  }
+
+  override fun willPresentPaywall(withInfo: PaywallInfo) {
+    val data = mapOf<String, Any?>(
+      "info" to withInfo.toJson()
+    )
+    sendEvent("willPresentPaywall", data)
+  }
+
+  override fun didDismissPaywall(withInfo: PaywallInfo) {
+    val data = mapOf<String, Any?>(
+      "info" to withInfo.toJson()
+    )
+    sendEvent("didDismissPaywall", data)
+  }
+
+  override fun didPresentPaywall(withInfo: PaywallInfo) {
+    val data = mapOf<String, Any?>(
+      "info" to withInfo.toJson()
+    )
+    sendEvent("didPresentPaywall", data)
+  }
+
+  override fun paywallWillOpenURL(url: URI) {
+    val data = mapOf<String, Any?>(
+      "url" to url.toString()
+    )
+    sendEvent("paywallWillOpenURL", data)
+  }
+
+  override fun paywallWillOpenDeepLink(url: Uri) {
+    val data = mapOf<String, Any?>(
+      "url" to url.toString()
+    )
+    sendEvent("paywallWillOpenDeepLink", data)
+  }
+
+  override fun handleLog(
+    level: String,
+    scope: String,
+    message: String?,
+    info: Map<String, Any>?,
+    error: Throwable?
+  ) {
+    val data = mapOf<String, Any?>(
+      "level" to level,
+      "scope" to scope,
+      "message" to message,
+      "info" to info,
+      "error" to error?.localizedMessage
+    )
+    sendEvent("handleLog", data)
+  }
+
+  private fun sendEvent(name: String, body: Map<String, Any?>) {
+    SuperwallExpoModule.instance?.emitEvent(name, body)
+  }
+
+  override fun willRedeemLink() {
+    sendEvent("willRedeemLink", emptyMap())
+  }
+
+  override fun didRedeemLink(result: RedemptionResult) {
+    sendEvent("didRedeemLink", result.toJson())
+  }
+}

package/android/src/main/java/expo/modules/superwallexpo/json/ConfigurationStatus.kt

@@ -0,0 +1,11 @@
+package expo.modules.superwallexpo.json
+
+import com.superwall.sdk.config.models.ConfigurationStatus
+
+fun ConfigurationStatus.asString(): String {
+    return when (this) {
+        ConfigurationStatus.Pending -> "PENDING"
+        ConfigurationStatus.Configured -> "CONFIGURED"
+        ConfigurationStatus.Failed -> "FAILED"
+    }
+}

package/android/src/main/java/expo/modules/superwallexpo/json/ConfirmedAssignment.kt

@@ -0,0 +1,12 @@
+package expo.modules.superwallexpo.json
+
+
+import com.superwall.sdk.models.triggers.Experiment
+import com.superwall.sdk.models.assignment.ConfirmedAssignment
+
+fun ConfirmedAssignment.toJson(): Map<String, Any> {
+    val assignmentMap = mutableMapOf<String, Any>()
+    assignmentMap["experimentId"] = this.experimentId
+    assignmentMap["variant"] = this.variant.toJson()
+    return assignmentMap
+}

package/android/src/main/java/expo/modules/superwallexpo/json/Entitlements.kt

@@ -0,0 +1,20 @@
+package expo.modules.superwallexpo.json
+
+
+import com.superwall.sdk.models.entitlements.Entitlement
+
+
+fun Set<Entitlement>.toJson(): List<Map<String, Any>> {
+  val array = mutableListOf<Map<String, Any>>()
+  this@toJson.forEach { entitlement ->
+    array.add(entitlement.toJson())
+  }
+  return array
+}
+
+fun Entitlement.toJson(): Map<String, Any> {
+  val map = mutableMapOf<String, Any>()
+  map["id"] = this.id
+  map["type"] = this.type.toString()
+  return map
+}

package/android/src/main/java/expo/modules/superwallexpo/json/Experiment.kt

@@ -0,0 +1,19 @@
+package expo.modules.superwallexpo.json
+
+
+import com.superwall.sdk.models.triggers.Experiment
+import com.superwall.sdk.paywall.presentation.internal.state.PaywallSkippedReason
+
+class Experiment {
+  companion object {
+    fun toJson(experiment: Experiment): Map<String, Any> {
+      val variantMap = experiment.variant.toJson()
+
+      return mapOf(
+        "id" to experiment.id,
+        "groupId" to experiment.groupId,
+        "variant" to variantMap
+      )
+    }
+  }
+}

package/android/src/main/java/expo/modules/superwallexpo/json/FeatureGatingBehavior.kt

@@ -0,0 +1,10 @@
+package expo.modules.superwallexpo.json
+
+import com.superwall.sdk.models.config.FeatureGatingBehavior
+
+fun FeatureGatingBehavior.rawValue(): String {
+  return when (this) {
+    FeatureGatingBehavior.Gated -> "gated"
+    FeatureGatingBehavior.NonGated -> "nonGated"
+  }
+}

package/android/src/main/java/expo/modules/superwallexpo/json/IdentityOptions.kt

@@ -0,0 +1,8 @@
+package expo.modules.superwallexpo.json
+
+import com.superwall.sdk.identity.IdentityOptions
+
+fun identityOptionsFromJson(json: Map<String, Any>): IdentityOptions {
+    val restorePaywallAssignments = json["restorePaywallAssignments"] as Boolean
+    return IdentityOptions(restorePaywallAssignments = restorePaywallAssignments)
+}

package/android/src/main/java/expo/modules/superwallexpo/json/InterfaceStyle.kt

@@ -0,0 +1,13 @@
+package expo.modules.superwallexpo.json
+
+
+import com.superwall.sdk.network.device.InterfaceStyle
+
+fun interfaceStyleFromString(interfaceStyle: String): InterfaceStyle {
+    return when (interfaceStyle) {
+    "LIGHT" -> InterfaceStyle.LIGHT
+    "DARK" -> InterfaceStyle.DARK
+    else -> InterfaceStyle.LIGHT // Default case to handle unexpected values
+    }
+}
+

package/android/src/main/java/expo/modules/superwallexpo/json/LocalNotificationType.kt

@@ -0,0 +1,10 @@
+package expo.modules.superwallexpo.json
+
+import com.superwall.sdk.models.paywall.LocalNotificationType
+
+fun LocalNotificationType.toJson(): String {
+  return when (this) {
+    LocalNotificationType.TrialStarted -> "trialStarted"
+    else -> ""
+  }
+}

package/android/src/main/java/expo/modules/superwallexpo/json/PaywallCloseReason.kt

@@ -0,0 +1,11 @@
+package expo.modules.superwallexpo.json
+
+import com.superwall.sdk.paywall.presentation.PaywallCloseReason
+
+fun PaywallCloseReason.rawValue(): String = when (this) {
+  is PaywallCloseReason.SystemLogic -> "systemLogic"
+  is PaywallCloseReason.ForNextPaywall -> "forNextPaywall"
+  is PaywallCloseReason.WebViewFailedToLoad -> "webViewFailedToLoad"
+  is PaywallCloseReason.ManualClose -> "manualClose"
+  is PaywallCloseReason.None -> "none"
+}