2.8.3

.github/workflows/pullfrog.yml

@@ -0,0 +1,79 @@
+# PULLFROG ACTION — DO NOT EDIT EXCEPT WHERE INDICATED
+name: Pullfrog
+run-name: ${{ inputs.name || github.workflow }}
+on:
+  workflow_dispatch:
+    inputs:
+      prompt:
+        type: string
+        description: Agent prompt
+      name:
+        type: string
+        description: Run name
+
+permissions:
+  contents: read
+
+jobs:
+  pullfrog:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 1
+      - name: Run agent
+        uses: pullfrog/pullfrog@v0
+        with:
+          prompt: ${{ inputs.prompt }}
+        env:
+          # add at least one provider API key
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          GOOGLE_GENERATIVE_AI_API_KEY:
+            ${{ secrets.GOOGLE_GENERATIVE_AI_API_KEY }}
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          XAI_API_KEY: ${{ secrets.XAI_API_KEY }}
+          DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
+          MOONSHOT_API_KEY: ${{ secrets.MOONSHOT_API_KEY }}
+          KIMI_API_KEY: ${{ secrets.KIMI_API_KEY }}
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+          AI_GATEWAY_API_KEY: ${{ secrets.AI_GATEWAY_API_KEY }}
+          OPENCODE_API_KEY: ${{ secrets.OPENCODE_API_KEY }}
+
+          # for Amazon Bedrock (https://docs.pullfrog.com/bedrock)
+          # AWS_BEARER_TOKEN_BEDROCK: ${{ secrets.AWS_BEARER_TOKEN_BEDROCK }}
+          # AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          # AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          # AWS_REGION: us-east-1
+          # BEDROCK_MODEL_ID: <bedrock-model-id>
+
+          # for Google Vertex AI (https://docs.pullfrog.com/vertex)
+          # VERTEX_SERVICE_ACCOUNT_JSON: >-
+          #   ${{ secrets.VERTEX_SERVICE_ACCOUNT_JSON }}
+          # GOOGLE_CLOUD_PROJECT: my-project
+          # VERTEX_LOCATION: global
+          # VERTEX_MODEL_ID: <vertex-model-id>
+
+          # for Azure OpenAI (https://docs.pullfrog.com/azure)
+          # AZURE_RESOURCE_NAME is the <name> in https://<name>.openai.azure.com
+          # AZURE_DEPLOYMENT is your deployment's name, not the model it serves
+          # AZURE_RESOURCE_NAME: my-resource
+          # AZURE_API_KEY: ${{ secrets.AZURE_API_KEY }}
+          # AZURE_DEPLOYMENT: <deployment-name>
+          # both limits are required — set them to the real limits of that model
+          # AZURE_CONTEXT: "400000"
+          # AZURE_MAX_OUTPUT: "128000"
+
+          # for any OpenAI-compatible endpoint — LiteLLM, Cloudflare AI Gateway,
+          # self-hosted vLLM (https://docs.pullfrog.com/openai-compatible)
+          # OPENAI_COMPATIBLE_BASE_URL: https://litellm.example.com/v1
+          # OPENAI_COMPATIBLE_API_KEY: ${{ secrets.OPENAI_COMPATIBLE_API_KEY }}
+          # OPENAI_COMPATIBLE_MODEL: <model-id>
+          # both limits are required — set them to the real limits of that model
+          # OPENAI_COMPATIBLE_CONTEXT: "128000"
+          # OPENAI_COMPATIBLE_MAX_OUTPUT: "16384"

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 The changelog for `Superwall`. Also see the [releases](https://github.com/superwall/Superwall-Android/releases) on GitHub.
 
+## 2.8.3
+
+## Fixes
+- Web purchase redemption now exposes the full checkout product in `didRedeemLink`, tracks `freeTrial_start` once per code, and schedules the active paywall's trial reminders from the checkout timestamp. Notification permission waits no longer block access or drop a late grant; ambiguous or already-elapsed reminders are skipped.
+- Fix multi-page paywalls only reporting the entry page view. `paywall_open` now waits for an in-flight `template_variables` send, so the runtime does not treat a late template payload as a fresh load and drop later `page_view`s.
+- Fix an active paywall not being reopened after its webview process crashes and is recreated. Recovery cancels template work for the old document and sends the open after the replacement loads, only if the same presentation is still active.
+- Fix prices not showing when product/offers are fetched from cache
+- Fix video loading and playing in the background on preloaded paywalls
+- Fix a JSON null in placement parameters or user attributes reaching audience filters as the text `"null"`, so a filter checking whether a field is null never matched.
+
 ## 2.8.2
 
 ## Enhancements

app/src/main/java/com/superwall/superapp/test/UITestHandler.kt

@@ -47,9 +47,7 @@ object UITestHandler {
                                     "${it.id}"
                                 }.joinToString(separator = ", "),
                         )
-                        Superwall.instance.setUserAttributes(mapOf("is_user_eligible_for_dd_offer" to true))
                         Superwall.instance.register(placement = "swtest")
-                        Superwall.instance.setUserAttributes(mapOf("is_user_eligible_for_dd_offer" to null))
                     },
                 ),
                 UITestInfo(

superwall/build.gradle.kts

@@ -85,6 +85,10 @@ android {
         buildConfig = true
     }
 
+    testOptions {
+        unitTests.isIncludeAndroidResources = true
+    }
+
     kotlinOptions {
         jvmTarget = "17"
     }

superwall/src/androidTest/java/com/superwall/sdk/paywall/view/webview/MediaPlaybackScriptTest.kt

@@ -0,0 +1,133 @@
+package com.superwall.sdk.paywall.view.webview
+
+import android.util.Base64
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+
+/** Exercises the injected script against real HTML video elements and Chromium playback. */
+@RunWith(AndroidJUnit4::class)
+class MediaPlaybackScriptTest {
+    private val instrumentation = InstrumentationRegistry.getInstrumentation()
+    private lateinit var webView: WebView
+
+    @Before
+    fun setUp() {
+        val video = instrumentation.context.assets.open("media-playback.mp4").use { it.readBytes() }
+        val source = "data:video/mp4;base64," + Base64.encodeToString(video, Base64.NO_WRAP)
+        val loaded = CountDownLatch(1)
+        instrumentation.runOnMainSync {
+            webView = WebView(instrumentation.targetContext)
+            webView.settings.javaScriptEnabled = true
+            webView.settings.mediaPlaybackRequiresUserGesture = false
+            webView.webViewClient =
+                object : WebViewClient() {
+                    override fun onPageFinished(view: WebView, url: String) {
+                        loaded.countDown()
+                    }
+                }
+            webView.loadDataWithBaseURL(
+                "https://localhost/",
+                """
+                <html><body>
+                <video id="playing" muted loop playsinline src="$source"></video>
+                <video id="manual" muted loop playsinline src="$source"></video>
+                </body></html>
+                """.trimIndent(),
+                "text/html",
+                "UTF-8",
+                null,
+            )
+        }
+        assertTrue("Page did not load", loaded.await(10, TimeUnit.SECONDS))
+        await("document.getElementById('playing').readyState >= 3")
+    }
+
+    @After
+    fun tearDown() {
+        instrumentation.runOnMainSync { webView.destroy() }
+    }
+
+    @Test
+    fun pausesAndResumesOnlyPreviouslyPlayingVideo() {
+        evaluate("document.getElementById('playing').play()")
+        await("document.getElementById('playing').currentTime > 0")
+        evaluate(MediaPlaybackScript.build(false))
+        evaluate(MediaPlaybackScript.build(false)) // Repeated lifecycle callbacks must preserve the set.
+        assertEquals("true", evaluate("document.getElementById('playing').paused"))
+        val pausedTime = evaluate("document.getElementById('playing').currentTime")
+        Thread.sleep(150)
+        assertEquals(pausedTime, evaluate("document.getElementById('playing').currentTime"))
+        evaluate(MediaPlaybackScript.build(true))
+        await("!document.getElementById('playing').paused")
+        await("document.getElementById('playing').currentTime !== $pausedTime")
+        assertEquals("true", evaluate("document.getElementById('manual').paused"))
+    }
+
+    @Test
+    fun blocksLateAutoplayUntilPresentation() {
+        evaluate(MediaPlaybackScript.build(false))
+        evaluate(
+            """
+            window.late = document.getElementById('playing').cloneNode();
+            late.id = 'late';
+            late.autoplay = true;
+            document.body.appendChild(late);
+            """.trimIndent(),
+        )
+        await("window.__swMediaPlayback.suspended.has(late) && late.paused")
+        evaluate(MediaPlaybackScript.build(true))
+        await("!late.paused && late.currentTime > 0")
+    }
+
+    @Test
+    fun doesNotResumeRemovedOrManuallyPausedMedia() {
+        evaluate(MediaPlaybackScript.build(true))
+        evaluate("document.getElementById('playing').play()")
+        await("document.getElementById('playing').currentTime > 0")
+        evaluate("document.getElementById('playing').pause()")
+        evaluate(MediaPlaybackScript.build(false))
+        evaluate(MediaPlaybackScript.build(true))
+        assertEquals("true", evaluate("document.getElementById('playing').paused"))
+
+        evaluate("document.getElementById('playing').play()")
+        await("!document.getElementById('playing').paused")
+        evaluate(MediaPlaybackScript.build(false))
+        evaluate("window.removed = document.getElementById('playing'); removed.remove()")
+        evaluate(MediaPlaybackScript.build(true))
+        assertEquals("true", evaluate("removed.paused"))
+        assertEquals("0", evaluate("window.__swMediaPlayback.suspended.size"))
+    }
+
+    private fun evaluate(script: String): String {
+        val done = CountDownLatch(1)
+        val result = AtomicReference<String>()
+        instrumentation.runOnMainSync {
+            webView.evaluateJavascript(script) {
+                result.set(it)
+                done.countDown()
+            }
+        }
+        assertTrue("JavaScript callback timed out", done.await(5, TimeUnit.SECONDS))
+        return result.get()
+    }
+
+    private fun await(condition: String) {
+        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
+        while (System.nanoTime() < deadline) {
+            if (evaluate(condition) == "true") return
+            Thread.sleep(50)
+        }
+        assertEquals(condition, "true", evaluate(condition))
+    }
+}

superwall/src/androidTest/java/com/superwall/sdk/paywall/view/webview/templating/CachedProductPricesWebViewTest.kt

@@ -0,0 +1,105 @@
+package com.superwall.sdk.paywall.view.webview.templating
+
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.superwall.sdk.models.config.Config
+import com.superwall.sdk.models.paywall.Paywall
+import com.superwall.sdk.models.product.ProductItem
+import com.superwall.sdk.models.product.ProductVariable
+import com.superwall.sdk.network.JsonFactory
+import com.superwall.sdk.paywall.view.webview.templating.models.Variables
+import kotlinx.serialization.json.jsonPrimitive
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Uses the real config and template serializers and a real emulator WebView.
+ * The HTML is a minimal price-binding fixture, not the customer's hosted paywall runtime.
+ */
+@RunWith(AndroidJUnit4::class)
+class CachedProductPricesWebViewTest {
+    private val json = JsonFactory.JSON
+
+    @Test
+    fun freshConfigDisplaysOfferPrice() {
+        assertEquals("€23.99", renderOfferPrice(cached = false))
+    }
+
+    @Test
+    fun diskCachedConfigDisplaysOfferPrice() {
+        // Fails on 2.8.2: price data exists but the "offer" binding is absent.
+        assertEquals("€23.99", renderOfferPrice(cached = true))
+    }
+
+    private fun renderOfferPrice(cached: Boolean): String {
+        val item =
+            json.decodeFromString<ProductItem>(
+                """{"reference_name":"offer","store_product":{"store":"PLAY_STORE",
+            "product_identifier":"yearly19_3_dc","base_plan_identifier":"p1y",
+            "offer":{"type":"SPECIFIED","offer_identifier":"introprice"}}}""",
+            )
+        val paywall = Paywall.stub().copy(productVariables = null, swProductVariablesTemplate = null)
+        paywall.productItems = listOf(item)
+        val fresh = Config.stub().copy(paywalls = listOf(paywall))
+        val config = if (cached) json.decodeFromString(Config.serializer(), json.encodeToString(Config.serializer(), fresh)) else fresh
+        val product =
+            config.paywalls
+                .single()
+                .productItems
+                .single()
+        val variables =
+            Variables(
+                listOf(ProductVariable(product.name, mapOf("price" to "€23.99"))),
+                emptyMap(),
+                emptyMap(),
+                emptyMap(),
+            )
+        val payload = json.encodeToString(Variables.serializer(), variables)
+        val instrumentation = InstrumentationRegistry.getInstrumentation()
+        val finished = CountDownLatch(1)
+        val output = AtomicReference<String>()
+        lateinit var webView: WebView
+        instrumentation.runOnMainSync {
+            webView = WebView(instrumentation.targetContext)
+            webView.settings.javaScriptEnabled = true
+            webView.webViewClient =
+                object : WebViewClient() {
+                    override fun onPageFinished(
+                        view: WebView,
+                        url: String?,
+                    ) {
+                        view.evaluateJavascript("document.getElementById('price').textContent") {
+                            output.set(it)
+                            finished.countDown()
+                        }
+                    }
+                }
+            webView.loadDataWithBaseURL(
+                "https://localhost/",
+                """
+                <html><body><span id="price"></span><script>
+                const variables = $payload;
+                const products = Object.assign({}, ...variables.products);
+                document.getElementById('price').textContent = products.offer?.price ?? '';
+                </script></body></html>
+                """.trimIndent(),
+                "text/html",
+                "UTF-8",
+                null,
+            )
+        }
+        try {
+            assertTrue("WebView did not finish loading", finished.await(20, TimeUnit.SECONDS))
+            return json.parseToJsonElement(output.get()).jsonPrimitive.content
+        } finally {
+            instrumentation.runOnMainSync { webView.destroy() }
+        }
+    }
+}