feat: Implement Jetpack compose

Author: Mansi-mParticle

build.gradle

@@ -48,6 +48,13 @@ android {
             jvmArgs += ['--add-opens', 'java.base/java.lang.reflect=ALL-UNNAMED']
         }
     }
+    buildFeatures {
+        compose true
+    }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = "1.5.2" // or match the app’s version
+    }
 }
 
 repositories {
@@ -59,9 +66,13 @@ dependencies {
     implementation 'androidx.annotation:annotation:1.5.0'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'
     api 'com.rokt:roktsdk:4.10.0'
+    implementation 'androidx.compose.runtime:runtime-android:1.8.3'
 
     testImplementation  files('libs/java-json.jar')
     testImplementation 'com.squareup.assertj:assertj-android:1.2.0'
     testImplementation ("io.mockk:mockk:1.13.4")
     testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
+    implementation 'androidx.compose.ui:ui:1.0.0'
+    implementation 'androidx.compose.material:material:1.0.0'
+    implementation 'androidx.compose.ui:ui-tooling:1.0.0'
 }

src/main/kotlin/com/mparticle/kits/RoktKit.kt

@@ -6,6 +6,7 @@ import android.content.pm.PackageInfo
 import android.content.pm.PackageManager
 import android.graphics.Typeface
 import android.os.Build
+import androidx.compose.runtime.Composable
 import com.mparticle.BuildConfig
 import com.mparticle.MParticle
 import com.mparticle.MParticle.IdentityType
@@ -23,15 +24,20 @@ import com.mparticle.rokt.RoktConfig
 import com.mparticle.rokt.RoktEmbeddedView
 import com.rokt.roktsdk.CacheConfig
 import com.rokt.roktsdk.Rokt
+import com.rokt.roktsdk.Rokt.RoktCallback
 import com.rokt.roktsdk.Rokt.SdkFrameworkType.Android
 import com.rokt.roktsdk.Rokt.SdkFrameworkType.Cordova
 import com.rokt.roktsdk.Rokt.SdkFrameworkType.Flutter
 import com.rokt.roktsdk.Rokt.SdkFrameworkType.ReactNative
 import com.rokt.roktsdk.RoktEvent
 import com.rokt.roktsdk.RoktWidgetDimensionCallBack
 import com.rokt.roktsdk.Widget
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
 import java.lang.ref.WeakReference
 import java.math.BigDecimal
 
@@ -49,10 +55,13 @@ class RoktKit : KitIntegration(), CommerceListener, IdentityListener, RoktListen
 
     override fun getInstance(): RoktKit = this
 
+    private var deferredAttributes: CompletableDeferred<Map<String, String>>? = null
+
     public override fun onKitCreate(
         settings: Map<String, String>,
         ctx: Context
     ): List<ReportingMessage> {
+        register(this)
         applicationContext = ctx.applicationContext
         val roktTagId = settings[ROKT_ACCOUNT_ID]
         if (KitUtils.isEmpty(roktTagId)) {
@@ -189,6 +198,23 @@ class RoktKit : KitIntegration(), CommerceListener, IdentityListener, RoktListen
         }?.toMap()
 
         this.mpRoktEventCallback = mpRoktEventCallback
+        val finalAttributes = prepareFinalAttributes(filterUser, attributes)
+        val roktConfig = mpRoktConfig?.let { mapToRoktConfig(it) }
+        Rokt.execute(
+            viewName,
+            finalAttributes,
+            this,
+            // Pass placeholders and fontTypefaces only if they are not empty or null
+            placeholders.takeIf { it?.isNotEmpty() == true },
+            fontTypefaces.takeIf { it?.isNotEmpty() == true },
+            roktConfig
+        )
+    }
+
+    private fun prepareFinalAttributes(
+        filterUser: FilteredMParticleUser?,
+        attributes: Map<String, String>?
+    ): Map<String, String> {
         val finalAttributes = mutableMapOf<String, String>()
         filterUser?.userAttributes?.let { userAttrs ->
             for ((key, value) in userAttrs) {
@@ -208,16 +234,9 @@ class RoktKit : KitIntegration(), CommerceListener, IdentityListener, RoktListen
             finalAttributes.put(SANDBOX_MODE_ROKT, value)
         }
         verifyHashedEmail(finalAttributes)
-        val roktConfig = mpRoktConfig?.let { mapToRoktConfig(it) }
-        Rokt.execute(
-            viewName,
-            finalAttributes,
-            this,
-            // Pass placeholders and fontTypefaces only if they are not empty or null
-            placeholders.takeIf { it?.isNotEmpty() == true },
-            fontTypefaces.takeIf { it?.isNotEmpty() == true },
-            roktConfig
-        )
+
+
+        return finalAttributes
     }
 
     override fun events(identifier: String): Flow<com.mparticle.RoktEvent> {
@@ -277,6 +296,26 @@ class RoktKit : KitIntegration(), CommerceListener, IdentityListener, RoktListen
         Rokt.close()
     }
 
+    override fun callRoktComposable(attributes: MutableMap<String, String>, user: FilteredMParticleUser?) {
+        val finalAttributes = prepareFinalAttributes(user, attributes)
+        deferredAttributes?.complete(finalAttributes)
+    }
+
+    fun ComposableTest(
+        attributes: Map<String, String>,
+        mpRoktEventCallback: MpRoktEventCallback?,
+        onResult: (Map<String, String>, RoktCallback) -> Unit
+    ) {
+        val instance = MParticle.getInstance()
+        deferredAttributes = CompletableDeferred()
+        instance?.Internal()?.kitManager?.callExecuteForComposable(attributes)
+        this.mpRoktEventCallback = mpRoktEventCallback
+        CoroutineScope(Dispatchers.Default).launch {
+            val resultAttributes = deferredAttributes!!.await()
+            onResult(resultAttributes, this@RoktKit)
+        }
+    }
+
     private fun mapToRoktConfig(config: RoktConfig): com.rokt.roktsdk.RoktConfig {
         val colorMode = when (config.colorMode) {
             RoktConfig.ColorMode.LIGHT -> com.rokt.roktsdk.RoktConfig.ColorMode.LIGHT
@@ -371,6 +410,13 @@ class RoktKit : KitIntegration(), CommerceListener, IdentityListener, RoktListen
     }
 
     companion object {
+        private var instance: RoktKit? = null
+
+        fun register(kit: RoktKit) {
+            instance = kit
+        }
+
+        fun get(): RoktKit? = instance
         const val NAME = "Rokt"
         const val ROKT_ACCOUNT_ID = "accountId"
         const val MPID = "mpid"

src/main/kotlin/com/mparticle/kits/RoktLayout.kt

@@ -0,0 +1,48 @@
+package com.mparticle.kits
+
+import android.graphics.Typeface
+import androidx.annotation.NonNull
+import androidx.annotation.Nullable
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.wrapContentHeight
+import androidx.compose.foundation.layout.wrapContentWidth
+import androidx.compose.material.MaterialTheme.typography
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import com.mparticle.MpRoktEventCallback
+import com.mparticle.rokt.RoktConfig
+import com.mparticle.rokt.RoktEmbeddedView
+import com.rokt.roktsdk.Rokt
+import java.lang.ref.WeakReference
+
+@Composable
+fun RoktLayout(
+    sdkTriggered: Boolean,
+    viewName: String,
+    modifier: Modifier,
+    attributes: Map<String, String>,
+    location: String,
+    mpRoktEventCallback: MpRoktEventCallback?
+) {
+    val instance = RoktKit.get()
+
+    data class RoktResult(val attributes: Map<String, String>, val callback: Rokt.RoktCallback)
+
+    val resultMapState = remember { mutableStateOf<RoktResult?>(null) }
+    val trigger = remember { mutableStateOf(0) }
+    LaunchedEffect(trigger.value) {
+        instance?.ComposableTest(attributes, mpRoktEventCallback, { resultMap, callback ->
+            resultMapState.value = RoktResult(resultMap, callback)
+        })
+    }
+
+    resultMapState.value?.let { resultMap ->
+        com.rokt.roktsdk.RoktLayout(sdkTriggered, viewName, modifier, resultMap.attributes, location)
+    }
+}