2.7.7

CHANGELOG.md

@@ -2,6 +2,15 @@
 
 The changelog for `Superwall`. Also see the [releases](https://github.com/superwall/Superwall-Android/releases) on GitHub.
 
+
+## 2.7.7
+
+## Enhancements
+- Adds support for local resource loading in paywalls via `Superwall.instance.localResources`
+
+## Fixes
+- Fix issues with stripe period types failing to deserialize
+
 ## 2.7.6
 
 ## Fixes

superwall/src/main/java/com/superwall/sdk/Superwall.kt

@@ -57,6 +57,7 @@ import com.superwall.sdk.paywall.view.PaywallViewState
 import com.superwall.sdk.paywall.view.SuperwallPaywallActivity
 import com.superwall.sdk.paywall.view.delegate.PaywallLoadingState
 import com.superwall.sdk.paywall.view.delegate.PaywallViewEventCallback
+import com.superwall.sdk.paywall.view.webview.PaywallResource
 import com.superwall.sdk.paywall.view.webview.messaging.PaywallWebEvent
 import com.superwall.sdk.paywall.view.webview.messaging.PaywallWebEvent.Closed
 import com.superwall.sdk.paywall.view.webview.messaging.PaywallWebEvent.Custom
@@ -208,6 +209,25 @@ class Superwall(
             options.paywalls.overrideProductsByName = value
         }
 
+    /**
+     * A mapping of local resource IDs to local paywall resources.
+     *
+     * Use this to serve paywall assets (images, videos, Lottie animations) from local files
+     * instead of fetching them over the network. When a paywall references a `localResourceId`,
+     * the SDK will look up the corresponding resource in this map.
+     *
+     * ```kotlin
+     * Superwall.instance.localResources = mapOf(
+     *     "hero-video" to PaywallResource.FromUri(Uri.fromFile(File(context.filesDir, "onboarding.mp4"))),
+     *     "hero-image" to PaywallResource.FromResources(R.drawable.hero),
+     *     "bg-animation" to PaywallResource.FromResources(R.raw.lottie_bg),
+     * )
+     * ```
+     *
+     * Paywall HTML usage: `<video src="swlocal://hero-video" autoplay></video>`
+     */
+    var localResources: Map<String, PaywallResource> = emptyMap()
+
     internal val _customerInfo: MutableStateFlow<CustomerInfo> =
         MutableStateFlow(CustomerInfo.empty())
 

superwall/src/main/java/com/superwall/sdk/network/SubscriptionService.kt

@@ -31,6 +31,7 @@ class SubscriptionService(
             namingStrategy = null
             explicitNulls = false
             ignoreUnknownKeys = true
+            coerceInputValues = true
         }
 
     suspend fun redeemToken(

superwall/src/main/java/com/superwall/sdk/paywall/view/webview/DefaultWebviewClient.kt

@@ -19,6 +19,7 @@ internal open class DefaultWebviewClient(
     private val forUrl: String = "",
     private val ioScope: CoroutineScope,
     private val onWebViewCrash: (view: WebView, RenderProcessGoneDetail) -> Unit = { v, d -> },
+    private val localResourceHandler: LocalResourceHandler? = null,
 ) : WebViewClient() {
     val webviewClientEvents: MutableSharedFlow<WebviewClientEvent> =
         MutableSharedFlow(extraBufferCapacity = 10, replay = 2)
@@ -28,6 +29,16 @@ internal open class DefaultWebviewClient(
         request: WebResourceRequest?,
     ): Boolean = true
 
+    override fun shouldInterceptRequest(
+        view: WebView?,
+        request: WebResourceRequest?,
+    ): WebResourceResponse? {
+        val url = request?.url ?: return super.shouldInterceptRequest(view, request)
+        val handler = localResourceHandler ?: return super.shouldInterceptRequest(view, request)
+        if (!handler.isLocalResourceUrl(url)) return super.shouldInterceptRequest(view, request)
+        return handler.handleRequest(url)
+    }
+
     override fun onPageStarted(
         view: WebView?,
         url: String?,

superwall/src/main/java/com/superwall/sdk/paywall/view/webview/LocalResourceHandler.kt

@@ -0,0 +1,180 @@
+package com.superwall.sdk.paywall.view.webview
+
+import android.content.Context
+import android.net.Uri
+import android.webkit.MimeTypeMap
+import android.webkit.WebResourceResponse
+import com.superwall.sdk.logger.LogLevel
+import com.superwall.sdk.logger.LogScope
+import com.superwall.sdk.logger.Logger
+import java.io.ByteArrayInputStream
+import java.io.InputStream
+
+/**
+ * Represents a local resource that can be served to paywall WebViews via `swlocal://` URLs.
+ */
+sealed class PaywallResource {
+    /**
+     * A resource backed by an Android [Uri] (`file://`, `content://`, etc.).
+     */
+    data class FromUri(
+        val uri: Uri,
+    ) : PaywallResource()
+
+    /**
+     * A resource backed by an Android resource ID (e.g. `R.raw.hero_video`, `R.drawable.bg`).
+     */
+    data class FromResources(
+        val resId: Int,
+    ) : PaywallResource()
+}
+
+internal class LocalResourceHandler(
+    private val context: Context,
+    private val localResources: () -> Map<String, PaywallResource>,
+) {
+    companion object {
+        private const val SCHEME = "swlocal"
+        private const val DEFAULT_MIME_TYPE = "application/octet-stream"
+    }
+
+    fun isLocalResourceUrl(url: Uri): Boolean = url.scheme == SCHEME
+
+    fun handleRequest(url: Uri): WebResourceResponse {
+        val resourceId = url.host
+        if (resourceId.isNullOrEmpty()) {
+            Logger.debug(
+                LogLevel.error,
+                LogScope.paywallView,
+                "swlocal:// URL has no resource ID: $url",
+            )
+            return errorResponse(400, "Bad Request", "Missing resource ID in swlocal:// URL")
+        }
+
+        val resource = localResources()[resourceId]
+        if (resource == null) {
+            Logger.debug(
+                LogLevel.error,
+                LogScope.paywallView,
+                "No local resource found for ID: $resourceId",
+            )
+            return errorResponse(404, "Not Found", "No local resource mapped for ID: $resourceId")
+        }
+
+        return when (resource) {
+            is PaywallResource.FromUri -> handleUri(resourceId, resource.uri)
+            is PaywallResource.FromResources -> handleAndroidResource(resourceId, resource.resId)
+        }
+    }
+
+    private fun handleUri(
+        resourceId: String,
+        uri: Uri,
+    ): WebResourceResponse {
+        val mimeType = resolveMimeType(uri)
+        val inputStream =
+            openStreamOrError(resourceId, uri) ?: return errorResponse(500, "Internal Error", "Failed to read resource: $resourceId")
+        return successResponse(mimeType, inputStream)
+    }
+
+    private fun handleAndroidResource(
+        resourceId: String,
+        resId: Int,
+    ): WebResourceResponse {
+        val uri = Uri.parse("android.resource://${context.packageName}/$resId")
+        val mimeType = resolveResourceMimeType(resId, uri)
+        val inputStream =
+            try {
+                context.resources.openRawResource(resId)
+            } catch (e: Exception) {
+                Logger.debug(
+                    LogLevel.error,
+                    LogScope.paywallView,
+                    "Failed to open Android resource '$resourceId' (resId=$resId)",
+                    error = e,
+                )
+                return errorResponse(500, "Internal Error", "Failed to read resource: ${e.message}")
+            }
+        return successResponse(mimeType, inputStream)
+    }
+
+    private fun openStreamOrError(
+        resourceId: String,
+        uri: Uri,
+    ): InputStream? =
+        try {
+            context.contentResolver.openInputStream(uri)
+                ?: throw IllegalStateException("ContentResolver returned null InputStream")
+        } catch (e: Exception) {
+            Logger.debug(
+                LogLevel.error,
+                LogScope.paywallView,
+                "Failed to open local resource '$resourceId' at $uri",
+                error = e,
+            )
+            null
+        }
+
+    private fun resolveMimeType(uri: Uri): String {
+        context.contentResolver.getType(uri)?.let { return it }
+        return mimeTypeFromExtension(uri.toString())
+    }
+
+    private fun resolveResourceMimeType(
+        resId: Int,
+        uri: Uri,
+    ): String {
+        context.contentResolver.getType(uri)?.let { return it }
+
+        // Try to extract extension from the resource entry name (e.g. "hero_video" won't have one,
+        // but the resource type name "raw"/"drawable" gives us a hint)
+        try {
+            val entryName = context.resources.getResourceEntryName(resId)
+            val ext = entryName.substringAfterLast('.', "")
+            if (ext.isNotEmpty()) {
+                return mimeTypeFromExtension(entryName)
+            }
+        } catch (_: Exception) {
+            // Resource not found - fall through
+        }
+
+        return DEFAULT_MIME_TYPE
+    }
+
+    private fun mimeTypeFromExtension(path: String): String {
+        val extension = MimeTypeMap.getFileExtensionFromUrl(path)
+        if (!extension.isNullOrEmpty()) {
+            MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension)?.let { return it }
+        }
+        return DEFAULT_MIME_TYPE
+    }
+
+    private fun successResponse(
+        mimeType: String,
+        inputStream: InputStream,
+    ): WebResourceResponse =
+        WebResourceResponse(
+            mimeType,
+            null,
+            200,
+            "OK",
+            corsHeaders(),
+            inputStream,
+        )
+
+    private fun errorResponse(
+        statusCode: Int,
+        reasonPhrase: String,
+        body: String,
+    ): WebResourceResponse =
+        WebResourceResponse(
+            "text/plain",
+            "UTF-8",
+            statusCode,
+            reasonPhrase,
+            corsHeaders(),
+            ByteArrayInputStream(body.toByteArray()),
+        )
+
+    private fun corsHeaders(): Map<String, String> = mapOf("Access-Control-Allow-Origin" to "*")
+}

superwall/src/main/java/com/superwall/sdk/paywall/view/webview/SWWebView.kt

@@ -89,6 +89,10 @@ class SWWebView(
     }
     override var onScrollChangeListener: PaywallWebUI.OnScrollChangeListener? = null
 
+    private val localResourceHandler by lazy {
+        LocalResourceHandler(context) { Superwall.instance.localResources }
+    }
+
     override fun detach(fromView: ViewGroup) {
         fromView.removeView(this)
     }
@@ -230,6 +234,7 @@ class SWWebView(
                         }
                     }
                 },
+                localResourceHandler = localResourceHandler,
             )
         this.webViewClient = client
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
@@ -285,6 +290,7 @@ class SWWebView(
                         }
                     }
                 },
+                localResourceHandler = localResourceHandler,
             )
         this.webViewClient = client
 

superwall/src/main/java/com/superwall/sdk/paywall/view/webview/WebviewFallbackClient.kt

@@ -26,7 +26,8 @@ internal class WebviewFallbackClient(
     private val loadUrl: (PaywallWebviewUrl) -> Unit,
     private val stopLoading: () -> Unit,
     private val onCrashed: (view: WebView, RenderProcessGoneDetail) -> Unit,
-) : DefaultWebviewClient("", ioScope, onCrashed) {
+    localResourceHandler: LocalResourceHandler? = null,
+) : DefaultWebviewClient("", ioScope, onCrashed, localResourceHandler) {
     private class MaxAttemptsReachedException : Exception("Max attempts reached")
 
     private var failureCount = 0

superwall/src/main/java/com/superwall/sdk/store/abstractions/product/receipt/LatestPeriodType.kt

@@ -5,15 +5,21 @@ import kotlinx.serialization.Serializable
 
 @Serializable
 enum class LatestPeriodType {
-    @SerialName("TRIAL")
+    @SerialName("trial")
     TRIAL,
 
-    @SerialName("SUBSCRIPTION")
+    @SerialName("code")
+    CODE,
+
+    @SerialName("subscription")
     SUBSCRIPTION,
 
-    @SerialName("PROMOTIONAL")
+    @SerialName("promotional")
     PROMOTIONAL,
 
-    @SerialName("REVOKED")
+    @SerialName("winback")
+    WINBACK,
+
+    @SerialName("revoked")
     REVOKED,
 }

superwall/src/main/java/com/superwall/sdk/store/abstractions/product/receipt/LatestSubscriptionState.kt

@@ -1,38 +1,25 @@
 package com.superwall.sdk.store.abstractions.product.receipt
 
-import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
 
-@Serializable(with = LatestSubscriptionStateSerializer::class)
+@Serializable
 enum class LatestSubscriptionState {
+    @SerialName("grace_period")
     GRACE_PERIOD,
+
+    @SerialName("expired")
     EXPIRED,
+
+    @SerialName("subscribed")
     SUBSCRIBED,
-    BILLING_RETRY,
-    REVOKED,
-    UNKNOWN,
-}
 
-object LatestSubscriptionStateSerializer : KSerializer<LatestSubscriptionState> {
-    override val descriptor: SerialDescriptor =
-        PrimitiveSerialDescriptor("LatestSubscriptionState", PrimitiveKind.STRING)
+    @SerialName("billing_retry")
+    BILLING_RETRY,
 
-    override fun serialize(
-        encoder: Encoder,
-        value: LatestSubscriptionState,
-    ) {
-        encoder.encodeString(value.name)
-    }
+    @SerialName("revoked")
+    REVOKED,
 
-    override fun deserialize(decoder: Decoder): LatestSubscriptionState {
-        val value = decoder.decodeString()
-        return LatestSubscriptionState.entries.find {
-            it.name.equals(value, ignoreCase = true)
-        } ?: LatestSubscriptionState.UNKNOWN
-    }
+    @SerialName("unknown")
+    UNKNOWN,
 }

superwall/src/main/java/com/superwall/sdk/store/abstractions/product/receipt/ReceiptManager.kt

@@ -307,8 +307,10 @@ class ReceiptManager(
     private fun determinePeriodType(): String? =
         when (latestSubscriptionPeriodType) {
             LatestPeriodType.TRIAL -> "trial"
+            LatestPeriodType.CODE -> "code"
             LatestPeriodType.SUBSCRIPTION -> "normal"
             LatestPeriodType.PROMOTIONAL -> "intro"
+            LatestPeriodType.WINBACK -> "winback"
             LatestPeriodType.REVOKED -> "revoked"
             null -> null
         }