SDKS-4679 & SDKS-4681: Add Polling and QR Code collectors for DaVinci flows

davinci/src/main/kotlin/com/pingidentity/davinci/CollectorRegistry.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * Copyright (c) 2024 - 2026 Ping Identity Corporation. All rights reserved.
  *
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
@@ -15,6 +15,8 @@ import com.pingidentity.davinci.collector.LabelCollector
 import com.pingidentity.davinci.collector.MultiSelectCollector
 import com.pingidentity.davinci.collector.PasswordCollector
 import com.pingidentity.davinci.collector.PhoneNumberCollector
+import com.pingidentity.davinci.collector.PollingCollector
+import com.pingidentity.davinci.collector.QRCodeCollector
 import com.pingidentity.davinci.collector.SingleSelectCollector
 import com.pingidentity.davinci.collector.SubmitCollector
 import com.pingidentity.davinci.collector.TextCollector
@@ -54,5 +56,8 @@ internal class CollectorRegistry : ModuleInitializer() {
         CollectorFactory.register("DEVICE_REGISTRATION", ::DeviceRegistrationCollector)
         CollectorFactory.register("DEVICE_AUTHENTICATION", ::DeviceAuthenticationCollector)
         CollectorFactory.register("PHONE_NUMBER", ::PhoneNumberCollector)
+
+        CollectorFactory.register("POLLING", ::PollingCollector)
+        CollectorFactory.register("QR_CODE", ::QRCodeCollector)
     }
 }

davinci/src/main/kotlin/com/pingidentity/davinci/collector/QRCodeCollector.kt

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2026 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+package com.pingidentity.davinci.collector
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import com.pingidentity.davinci.plugin.Collector
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlin.io.encoding.Base64
+
+/**
+ * A collector that handles QR code display in DaVinci authentication flows.
+ *
+ * The QRCodeCollector is used to display QR codes to users for authentication scenarios such as:
+ * - Device pairing
+ * - Multi-factor authentication setup
+ * - Out-of-band authentication
+ * - Cross-device authentication flows
+ *
+ * The QR code content is typically provided as a Base64-encoded image string that can be
+ * decoded and displayed as a bitmap.
+ *
+ * ## Content Format
+ *
+ * The [content] field typically contains a data URI string with Base64-encoded image data:
+ * ```
+ * data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...
+ * ```
+ *
+ * @see Collector
+ * @see bitmap
+ */
+class QRCodeCollector : Collector<Nothing> {
+
+    /**
+     * The QR code content as a Base64-encoded data URI string.
+     *
+     * This typically contains the full data URI including the MIME type and Base64 prefix:
+     * `data:image/png;base64,{base64-encoded-data}`
+     *
+     * The [bitmap] method extracts and decodes this content to create a displayable bitmap.
+     */
+    lateinit var content: String
+        private set
+
+    /**
+     * Fallback text to display when the QR code cannot be rendered.
+     *
+     * This text provides an alternative way for users to complete the authentication
+     * if the QR code cannot be displayed or scanned. It may contain:
+     * - A manual entry code
+     * - Instructions for alternative authentication methods
+     * - Error or help information
+     */
+    lateinit var fallbackText: String
+        private set
+
+    /**
+     * Initializes the QRCodeCollector with configuration from the input JSON.
+     *
+     * Extracts and sets the following parameters:
+     * - [content]: QR code content as Base64-encoded data URI (default: "")
+     * - [fallbackText]: Alternative text if QR code cannot be displayed (default: "")
+     *
+     * @param input JSON object containing the collector configuration with fields:
+     *              - `content`: The Base64-encoded QR code image data
+     *              - `fallbackText`: Alternative text for display
+     * @return This QRCodeCollector instance for method chaining
+     *
+     * @see Collector.init
+     */
+    override fun init(input: JsonObject): QRCodeCollector {
+        super.init(input)
+        content = input["content"]?.jsonPrimitive?.content ?: ""
+        fallbackText = input["fallbackText"]?.jsonPrimitive?.content ?: ""
+        return this
+    }
+
+    /**
+     * Converts the Base64-encoded QR code content to a displayable Bitmap.
+     *
+     * This method:
+     * 1. Extracts the Base64 data from the [content] string (after "base64,")
+     * 2. Decodes the Base64 string to a byte array
+     * 3. Converts the byte array to a Bitmap using BitmapFactory
+     *
+     * ## Content Format
+     *
+     * The method expects [content] to be in data URI format:
+     * ```
+     * data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...
+     * ```
+     *
+     * The substring after "base64," is extracted and decoded.
+     *
+     * @return A Bitmap representation of the QR code, or `null` if decoding fails
+     *
+     * @see content
+     * @see fallbackText
+     */
+    fun bitmap(): Bitmap? {
+        return try {
+            // Decode Base64 content and convert to Bitmap
+            val decodedBytes = Base64.decode(content.substringAfter("base64,"))
+            BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.size)
+        } catch (e: Exception) {
+            // Return null if decoding fails
+            null
+        }
+    }
+}

davinci/src/main/kotlin/com/pingidentity/davinci/module/Transform.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * Copyright (c) 2024 - 2026 Ping Identity Corporation. All rights reserved.
  *
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
@@ -11,8 +11,10 @@ import com.pingidentity.davinci.collector.Form
 import com.pingidentity.davinci.plugin.Collector
 import com.pingidentity.davinci.plugin.CollectorFactory
 import com.pingidentity.davinci.plugin.DaVinci
+import com.pingidentity.davinci.plugin.collectors
 import com.pingidentity.exception.ApiException
 import com.pingidentity.oidc.exception.AuthorizeException
+import com.pingidentity.orchestrate.ContinueNode
 import com.pingidentity.orchestrate.ErrorNode
 import com.pingidentity.orchestrate.FailureNode
 import com.pingidentity.orchestrate.FlowContext
@@ -116,6 +118,22 @@ private fun transform(
         )
     }
 
+    val eventName = json["eventName"]?.jsonPrimitive?.content
+    if (eventName == "rewindStateToLastRenderedUI" || eventName == "rewindStateToSpecificRenderedUI") {
+        val existing = context.flowContext.getValue<ContinueNode>(CONTINUE_NODE)
+            ?: return FailureNode(IllegalStateException("Rewind state to last rendered UI failed."))
+        // Create a new Connector instance with the same so that Jetpack Compose
+        // sees a different object reference and triggers recomposition and its collectors.
+        return Connector(
+            existing.context,
+            (existing as Connector).daVinci,
+            existing.input,
+            existing.collectors,
+        ).apply {
+            CollectorFactory.inject(this)
+        }
+    }
+
     val collectors = mutableListOf<Collector<*>>()
     if ("form" in json) collectors.addAll(Form.parse(daVinci, json))
 

davinci/src/test/kotlin/com/pingidentity/davinci/CollectorRegistryTest.kt

@@ -1,15 +1,20 @@
 /*
- * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * Copyright (c) 2024 - 2026 Ping Identity Corporation. All rights reserved.
  *
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
 
 import com.pingidentity.davinci.CollectorRegistry
+import com.pingidentity.davinci.collector.DeviceAuthenticationCollector
+import com.pingidentity.davinci.collector.DeviceRegistrationCollector
 import com.pingidentity.davinci.collector.FlowCollector
 import com.pingidentity.davinci.collector.LabelCollector
 import com.pingidentity.davinci.collector.MultiSelectCollector
 import com.pingidentity.davinci.collector.PasswordCollector
+import com.pingidentity.davinci.collector.PhoneNumberCollector
+import com.pingidentity.davinci.collector.PollingCollector
+import com.pingidentity.davinci.collector.QRCodeCollector
 import com.pingidentity.davinci.collector.SingleSelectCollector
 import com.pingidentity.davinci.collector.SubmitCollector
 import com.pingidentity.davinci.collector.TextCollector
@@ -61,9 +66,15 @@ class CollectorRegistryTest {
             add(buildJsonObject { put("inputType", "SINGLE_SELECT") })
             add(buildJsonObject { put("inputType", "MULTI_SELECT") })
             add(buildJsonObject { put("inputType", "MULTI_SELECT") })
+            add(buildJsonObject { put("inputType", "DEVICE_REGISTRATION") })
+            add(buildJsonObject { put("inputType", "DEVICE_AUTHENTICATION") })
+            add(buildJsonObject { put("inputType", "PHONE_NUMBER") })
+            add(buildJsonObject { put("type", "POLLING") })
+            add(buildJsonObject { put("type", "QR_CODE") })
         }
 
         val collectors = CollectorFactory.collector(mockk(), jsonArray)
+        assertEquals(16, collectors.size)
         assertEquals(TextCollector::class.java, collectors[0]::class.java)
         assertEquals(PasswordCollector::class.java, collectors[1]::class.java)
         assertEquals(PasswordCollector::class.java, collectors[2]::class.java)
@@ -75,6 +86,11 @@ class CollectorRegistryTest {
         assertEquals(SingleSelectCollector::class.java, collectors[8]::class.java)
         assertEquals(MultiSelectCollector::class.java, collectors[9]::class.java)
         assertEquals(MultiSelectCollector::class.java, collectors[10]::class.java)
+        assertEquals(DeviceRegistrationCollector::class.java, collectors[11]::class.java)
+        assertEquals(DeviceAuthenticationCollector::class.java, collectors[12]::class.java)
+        assertEquals(PhoneNumberCollector::class.java, collectors[13]::class.java)
+        assertEquals(PollingCollector::class.java, collectors[14]::class.java)
+        assertEquals(QRCodeCollector::class.java, collectors[15]::class.java)
     }
 
     @TestRailCase(21280)
@@ -88,10 +104,11 @@ class CollectorRegistryTest {
             add(buildJsonObject { put("type", "SUBMIT_BUTTON") })
             add(buildJsonObject { put("inputType", "ACTION") })
             add(buildJsonObject { put("type", "UNKNOWN") })
+            add(buildJsonObject { put("type", "QR_CODE") })
         }
 
         val collectors = CollectorFactory.collector(mockk(), jsonArray)
-        assertEquals(4, collectors.size)
+        assertEquals(5, collectors.size)
     }
 
 }

davinci/src/test/kotlin/com/pingidentity/davinci/DaVinciTest.Response.kt

@@ -203,6 +203,20 @@ fun customHTMLTemplateWithInvalidPassword() = ByteReadChannel(
 )
 
 
+fun rewindStateToLastRenderedUIResponse() =
+    ByteReadChannel(
+        "{\n" +
+                "    \"eventName\": \"rewindStateToLastRenderedUI\"\n" +
+                "}",
+    )
+
+fun rewindStateToSpecificRenderedUIResponse() =
+    ByteReadChannel(
+        "{\n" +
+                "    \"eventName\": \"rewindStateToSpecificRenderedUI\"\n" +
+                "}",
+    )
+
 fun tokeErrorResponse() =
     ByteReadChannel(
         "{\n" +

davinci/src/test/kotlin/com/pingidentity/davinci/DaVinciTest.kt

@@ -59,6 +59,7 @@ import kotlin.test.Test
 import kotlin.test.assertContains
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
+import kotlin.test.assertNotSame
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
@@ -551,4 +552,92 @@ class DaVinciTest {
             "expires_in": 60
         }
         """.trimIndent()
+
+    @Test
+    fun `DaVinci rewindStateToLastRenderedUI returns previous ContinueNode`() = runTest {
+        // Override the mock engine so /customHTMLTemplate returns a rewind event
+        mockEngine = MockEngine { request ->
+            when (request.url.encodedPath) {
+                "/.well-known/openid-configuration" ->
+                    respond(openIdConfigurationResponse(), HttpStatusCode.OK, headers)
+                "/authorize" ->
+                    respond(authorizeResponse(), HttpStatusCode.OK, authorizeResponseHeaders)
+                "/customHTMLTemplate" ->
+                    respond(rewindStateToLastRenderedUIResponse(), HttpStatusCode.OK, customHTMLTemplateHeaders)
+                else ->
+                    respond(ByteReadChannel(""), HttpStatusCode.InternalServerError)
+            }
+        }
+
+        val daVinci = DaVinci {
+            httpClient = KtorHttpClient(HttpClient(mockEngine))
+            module(Oidc) {
+                clientId = "test"
+                discoveryEndpoint = "http://localhost/.well-known/openid-configuration"
+                scopes = mutableSetOf("openid", "email", "address")
+                redirectUri = "http://localhost:8080"
+                storage = { MemoryStorage() }
+            }
+            module(Cookie) {
+                storage = { MemoryStorage() }
+            }
+        }
+
+        // start() stores the returned ContinueNode in FlowContext via the ContinueNode module
+        val firstNode = daVinci.start()
+        assertTrue(firstNode is ContinueNode)
+
+        // next() receives rewindStateToLastRenderedUI → transform retrieves the stored ContinueNode
+        val rewindNode = firstNode.next()
+
+        assertTrue(rewindNode is ContinueNode)
+        // Must be the exact same instance that was stored in FlowContext
+        assertNotSame(firstNode, rewindNode)
+        assertEquals(firstNode.id, rewindNode.id)
+        assertEquals(firstNode.name, rewindNode.name)
+    }
+
+    @Test
+    fun `DaVinci rewindStateToSpecificRenderedUI returns previous ContinueNode`() = runTest {
+        // Override the mock engine so /customHTMLTemplate returns a rewind event
+        mockEngine = MockEngine { request ->
+            when (request.url.encodedPath) {
+                "/.well-known/openid-configuration" ->
+                    respond(openIdConfigurationResponse(), HttpStatusCode.OK, headers)
+                "/authorize" ->
+                    respond(authorizeResponse(), HttpStatusCode.OK, authorizeResponseHeaders)
+                "/customHTMLTemplate" ->
+                    respond(rewindStateToSpecificRenderedUIResponse(), HttpStatusCode.OK, customHTMLTemplateHeaders)
+                else ->
+                    respond(ByteReadChannel(""), HttpStatusCode.InternalServerError)
+            }
+        }
+
+        val daVinci = DaVinci {
+            httpClient = KtorHttpClient(HttpClient(mockEngine))
+            module(Oidc) {
+                clientId = "test"
+                discoveryEndpoint = "http://localhost/.well-known/openid-configuration"
+                scopes = mutableSetOf("openid", "email", "address")
+                redirectUri = "http://localhost:8080"
+                storage = { MemoryStorage() }
+            }
+            module(Cookie) {
+                storage = { MemoryStorage() }
+            }
+        }
+
+        // start() stores the returned ContinueNode in FlowContext via the ContinueNode module
+        val firstNode = daVinci.start()
+        assertTrue(firstNode is ContinueNode)
+
+        // next() receives rewindStateToSpecificRenderedUI → transform retrieves the stored ContinueNode
+        val rewindNode = firstNode.next()
+
+        assertTrue(rewindNode is ContinueNode)
+        // Must be the exact same instance that was stored in FlowContext
+        assertNotSame(firstNode, rewindNode)
+        assertEquals(firstNode.id, rewindNode.id)
+        assertEquals(firstNode.name, rewindNode.name)
+    }
 }