react-native-mparticle 2.7.12 → 2.8.0

package/android/src/main/java/com/mparticle/react/MParticlePackage.kt

@@ -0,0 +1,68 @@
+package com.mparticle.react
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.ModuleSpec
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import com.mparticle.react.rokt.MPRoktModule
+import com.mparticle.react.rokt.MPRoktModuleImpl
+import com.mparticle.react.rokt.RoktLayoutViewManager
+
+class MParticlePackage : TurboReactPackage() {
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? =
+        when (name) {
+            MParticleModule.MODULE_NAME -> {
+                MParticleModule(reactContext)
+            }
+
+            MPRoktModuleImpl.MODULE_NAME -> {
+                MPRoktModule(reactContext)
+            }
+
+            else -> null
+        }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = listOf(RoktLayoutViewManager())
+
+    override fun getReactModuleInfoProvider() =
+        ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> =
+                HashMap()
+            moduleInfos.put(
+                MParticleModule.MODULE_NAME,
+                ReactModuleInfo(
+                    MParticleModule.MODULE_NAME,
+                    MParticleModule.MODULE_NAME,
+                    true, // canOverrideExistingModule
+                    false, // needsEagerInit
+                    true, // hasConstants
+                    false, // isCxxModule
+                    BuildConfig.IS_NEW_ARCHITECTURE_ENABLED, // isTurboModule
+                ),
+            )
+            moduleInfos.put(
+                MPRoktModuleImpl.MODULE_NAME,
+                ReactModuleInfo(
+                    MPRoktModuleImpl.MODULE_NAME,
+                    MPRoktModuleImpl.MODULE_NAME,
+                    true, // canOverrideExistingModule
+                    false, // needsEagerInit
+                    true, // hasConstants
+                    false, // isCxxModule
+                    BuildConfig.IS_NEW_ARCHITECTURE_ENABLED, // isTurboModule
+                ),
+            )
+            moduleInfos.toMap()
+        }
+
+    override fun getViewManagers(reactContext: ReactApplicationContext): List<ModuleSpec> =
+        listOf(
+            ModuleSpec.viewManagerSpec { RoktLayoutViewManager() },
+        )
+}

package/android/src/main/java/com/mparticle/react/rokt/MPRoktModuleImpl.kt

@@ -0,0 +1,251 @@
+package com.mparticle.react.rokt
+
+import android.app.Activity
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.mparticle.MParticle
+import com.mparticle.MpRoktEventCallback
+import com.mparticle.RoktEvent
+import com.mparticle.UnloadReasons
+import com.mparticle.WrapperSdk
+import com.mparticle.rokt.CacheConfig
+import com.mparticle.rokt.RoktConfig
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.launch
+
+class MPRoktModuleImpl(
+    private val reactContext: ReactApplicationContext,
+) {
+    init {
+        MParticle.getInstance()?.setWrapperSdk(WrapperSdk.WrapperSdkReactNative, "")
+    }
+
+    private var roktEventHandler: MpRoktEventCallback? = null
+
+    private val eventSubscriptions = mutableMapOf<String, Job?>()
+    private val listeners: MutableMap<Long, MpRoktEventCallback> =
+        object : LinkedHashMap<Long, MpRoktEventCallback>() {
+            override fun removeEldestEntry(eldest: Map.Entry<Long, MpRoktEventCallback>): Boolean = this.size > MAX_LISTENERS
+        }
+
+    fun getName(): String = MODULE_NAME
+
+    fun purchaseFinalized(
+        placementId: String,
+        catalogItemId: String,
+        success: Boolean,
+    ) {
+        MParticle.getInstance()?.Rokt()?.purchaseFinalized(placementId, catalogItemId, success)
+    }
+
+    fun setRoktEventHandler(roktEventHandler: MpRoktEventCallback) {
+        this.roktEventHandler = roktEventHandler
+    }
+
+    fun createRoktCallback(): MpRoktEventCallback {
+        val callback: MpRoktEventCallback =
+            object : MpRoktEventCallback {
+                override fun onLoad() {
+                    sendCallback("onLoad", null)
+                }
+
+                override fun onUnload(reason: UnloadReasons) {
+                    sendCallback("onUnLoad", reason.toString())
+                }
+
+                override fun onShouldShowLoadingIndicator() {
+                    sendCallback("onShouldShowLoadingIndicator", null)
+                }
+
+                override fun onShouldHideLoadingIndicator() {
+                    sendCallback("onShouldHideLoadingIndicator", null)
+                }
+            }
+        listeners[System.currentTimeMillis()] = callback
+        return callback
+    }
+
+    fun sendCallback(
+        eventValue: String,
+        reason: String?,
+    ) {
+        val params = Arguments.createMap()
+        params.putString("callbackValue", eventValue)
+        if (reason != null) {
+            params.putString("reason", reason)
+        }
+        sendEvent(reactContext, "RoktCallback", params)
+    }
+
+    fun sendEvent(
+        reactContext: ReactContext?,
+        eventName: String,
+        params: WritableMap?,
+    ) {
+        reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(eventName, params)
+    }
+
+    fun readableMapToMapOfStrings(attributes: ReadableMap?): Map<String, String> =
+        attributes?.toHashMap()?.filter { it.value is String }?.mapValues { it.value as String }
+            ?: emptyMap()
+
+    fun String.toColorMode(): RoktConfig.ColorMode =
+        when (this) {
+            "dark" -> RoktConfig.ColorMode.DARK
+            "light" -> RoktConfig.ColorMode.LIGHT
+            else -> RoktConfig.ColorMode.SYSTEM
+        }
+
+    fun buildRoktConfig(roktConfig: ReadableMap?): RoktConfig {
+        val builder = RoktConfig.Builder()
+        val configMap: Map<String, String> = readableMapToMapOfStrings(roktConfig)
+        configMap["colorMode"]?.let {
+            builder.colorMode(it.toColorMode())
+        }
+        roktConfig?.getMap("cacheConfig")?.let {
+            builder.cacheConfig(buildCacheConfig(it))
+        }
+        return builder.build()
+    }
+
+    fun buildCacheConfig(cacheConfigMap: ReadableMap?): CacheConfig {
+        val cacheDurationInSeconds =
+            if (cacheConfigMap?.hasKey("cacheDurationInSeconds") == true) {
+                cacheConfigMap.getDouble("cacheDurationInSeconds").toLong()
+            } else {
+                0L
+            }
+        val cacheAttributes =
+            if (cacheConfigMap?.hasKey("cacheAttributes") == true) {
+                cacheConfigMap.getMap("cacheAttributes")?.toHashMap()?.mapValues { it.value as String }
+            } else {
+                null
+            }
+        return CacheConfig(
+            cacheDurationInSeconds = cacheDurationInSeconds,
+            cacheAttributes = cacheAttributes,
+        )
+    }
+
+    fun startRoktEventListener(
+        flow: Flow<RoktEvent>,
+        currentActivity: Activity?,
+        viewName: String? = null,
+    ) {
+        val activeJob = eventSubscriptions[viewName.orEmpty()]?.takeIf { it.isActive }
+        if (activeJob != null) {
+            return
+        }
+        val job =
+            (currentActivity as? LifecycleOwner)?.lifecycleScope?.launch {
+                (currentActivity as LifecycleOwner).repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    flow.collect { event ->
+                        val params = Arguments.createMap()
+                        var eventName: String
+                        val placementId: String? =
+                            when (event) {
+                                is RoktEvent.FirstPositiveEngagement -> {
+                                    eventName = "FirstPositiveEngagement"
+                                    event.placementId
+                                }
+
+                                RoktEvent.HideLoadingIndicator -> {
+                                    eventName = "HideLoadingIndicator"
+                                    null
+                                }
+
+                                is RoktEvent.OfferEngagement -> {
+                                    eventName = "OfferEngagement"
+                                    event.placementId
+                                }
+
+                                is RoktEvent.PlacementClosed -> {
+                                    eventName = "PlacementClosed"
+                                    event.placementId
+                                }
+
+                                is RoktEvent.PlacementCompleted -> {
+                                    eventName = "PlacementCompleted"
+                                    event.placementId
+                                }
+
+                                is RoktEvent.PlacementFailure -> {
+                                    eventName = "PlacementFailure"
+                                    event.placementId
+                                }
+
+                                is RoktEvent.PlacementInteractive -> {
+                                    eventName = "PlacementInteractive"
+                                    event.placementId
+                                }
+
+                                is RoktEvent.PlacementReady -> {
+                                    eventName = "PlacementReady"
+                                    event.placementId
+                                }
+
+                                is RoktEvent.PositiveEngagement -> {
+                                    eventName = "PositiveEngagement"
+                                    event.placementId
+                                }
+
+                                RoktEvent.ShowLoadingIndicator -> {
+                                    eventName = "ShowLoadingIndicator"
+                                    null
+                                }
+
+                                is RoktEvent.InitComplete -> {
+                                    eventName = "InitComplete"
+                                    params.putString("status", event.success.toString())
+                                    null
+                                }
+
+                                is RoktEvent.OpenUrl -> {
+                                    eventName = "OpenUrl"
+                                    params.putString("url", event.url)
+                                    event.placementId
+                                }
+
+                                is RoktEvent.CartItemInstantPurchase -> {
+                                    eventName = "CartItemInstantPurchase"
+                                    params.putString("cartItemId", event.cartItemId)
+                                    params.putString("catalogItemId", event.catalogItemId)
+                                    params.putString("currency", event.currency)
+                                    params.putString("description", event.description)
+                                    params.putString("linkedProductId", event.linkedProductId)
+                                    params.putDouble("totalPrice", event.totalPrice)
+                                    params.putInt("quantity", event.quantity)
+                                    params.putDouble("unitPrice", event.unitPrice)
+                                    event.placementId
+                                }
+
+                                else -> {
+                                    eventName = "Unknown"
+                                    null
+                                }
+                            }
+
+                        placementId?.let { params.putString("placementId", it) }
+                        params.putString("event", eventName)
+                        viewName?.let { params.putString("viewName", it) }
+                        sendEvent(reactContext, "RoktEvents", params)
+                    }
+                }
+            }
+        eventSubscriptions[viewName.orEmpty()] = job
+    }
+
+    companion object {
+        const val MAX_LISTENERS = 5
+        const val MODULE_NAME = "RNMPRokt"
+    }
+}

package/android/src/main/java/com/mparticle/react/rokt/RoktLayoutViewManagerImpl.kt

@@ -0,0 +1,79 @@
+package com.mparticle.react.rokt
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.mparticle.rokt.RoktEmbeddedView
+import com.mparticle.rokt.RoktLayoutDimensionCallBack
+
+class RoktLayoutViewManagerImpl {
+    companion object {
+        const val REACT_CLASS = "RoktNativeLayout"
+        const val EVENT_HEIGHT_CHANGED = "onLayoutHeightChanged"
+        const val EVENT_MARGIN_CHANGED = "onLayoutMarginChanged"
+    }
+
+    fun getName(): String = REACT_CLASS
+
+    fun createViewInstance(reactContext: ThemedReactContext): RoktEmbeddedView {
+        val widget = RoktEmbeddedView(reactContext)
+        setUpWidgetListeners(widget)
+        return widget
+    }
+
+    fun setPlaceholderName(
+        view: RoktEmbeddedView?,
+        value: String?,
+    ) {
+        view?.tag = value
+    }
+
+    private fun setUpWidgetListeners(widget: RoktEmbeddedView) {
+        widget.dimensionCallBack =
+            object : RoktLayoutDimensionCallBack {
+                override fun onHeightChanged(height: Int) {
+                    changeHeight(widget.context as ReactContext, height, widget.id)
+                }
+
+                override fun onMarginChanged(
+                    start: Int,
+                    top: Int,
+                    end: Int,
+                    bottom: Int,
+                ) {
+                    changeMargin(widget.context as ReactContext, widget.id, start, top, end, bottom)
+                }
+            }
+    }
+
+    fun changeHeight(
+        context: ReactContext,
+        height: Int,
+        id: Int,
+    ) {
+        val event = Arguments.createMap()
+        event.putString("height", height.toString())
+        context
+            .getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(id, EVENT_HEIGHT_CHANGED, event)
+    }
+
+    fun changeMargin(
+        context: ReactContext,
+        id: Int,
+        start: Int,
+        top: Int,
+        end: Int,
+        bottom: Int,
+    ) {
+        val event = Arguments.createMap()
+        event.putString("marginLeft", start.toString())
+        event.putString("marginTop", top.toString())
+        event.putString("marginRight", end.toString())
+        event.putString("marginBottom", bottom.toString())
+        context
+            .getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(id, EVENT_MARGIN_CHANGED, event)
+    }
+}

package/android/src/newarch/java/com/mparticle/react/rokt/MPRoktModule.kt

@@ -0,0 +1,130 @@
+package com.mparticle.react.rokt
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.UIManagerHelper
+import com.mparticle.MParticle
+import com.mparticle.WrapperSdk
+import com.mparticle.react.NativeMPRoktSpec
+import com.mparticle.rokt.RoktEmbeddedView
+import com.mparticle.internal.Logger
+import java.lang.ref.WeakReference
+import java.util.concurrent.CountDownLatch
+
+class MPRoktModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeMPRoktSpec(reactContext) {
+
+    private val impl = MPRoktModuleImpl(reactContext)
+
+    override fun getName(): String = impl.getName()
+
+    @ReactMethod
+    override fun selectPlacements(
+        identifier: String,
+        attributes: ReadableMap?,
+        placeholders: ReadableMap?,
+        roktConfig: ReadableMap?,
+        fontFilesMap: ReadableMap?,
+    ) {
+        if (identifier.isBlank()) {
+            Logger.warning("selectPlacements failed. identifier cannot be empty")
+            return
+        }
+        MParticle.getInstance()?.Rokt()?.events(identifier)?.let {
+            impl.startRoktEventListener(it, reactContext.currentActivity, identifier)
+        }
+
+        // Process placeholders for Fabric
+        val placeholdersMap = processPlaceholders(placeholders)
+        val config = roktConfig?.let { impl.buildRoktConfig(it) }
+
+        MParticle.getInstance()?.Rokt()?.selectPlacements(
+            identifier = identifier,
+            attributes = impl.readableMapToMapOfStrings(attributes),
+            callbacks = impl.createRoktCallback(),
+            embeddedViews = placeholdersMap,
+            fontTypefaces = null, // TODO
+            config = config,
+        )
+    }
+
+    @ReactMethod
+    override fun purchaseFinalized(
+        placementId: String,
+        catalogItemId: String,
+        success: Boolean,
+    ) {
+        impl.purchaseFinalized(placementId, catalogItemId, success)
+    }
+
+
+    /**
+     * Process placeholders from ReadableMap to a map of Widgets for use with Rokt.
+     * This method handles the Fabric-specific view resolution.
+     */
+    private fun processPlaceholders(placeholders: ReadableMap?): Map<String, WeakReference<RoktEmbeddedView>> {
+        val placeholdersMap = HashMap<String, WeakReference<RoktEmbeddedView>>()
+
+        if (placeholders != null) {
+            // Use CountDownLatch to wait for UI thread processing
+            val latch = CountDownLatch(1)
+
+            // Run view resolution on UI thread
+            UiThreadUtil.runOnUiThread {
+                try {
+                    val iterator = placeholders.keySetIterator()
+                    while (iterator.hasNextKey()) {
+                        val key = iterator.nextKey()
+                        try {
+                            // Get the tag value as an integer
+                            val reactTag =
+                                when {
+                                    placeholders.getType(key) == ReadableType.Number ->
+                                        placeholders.getDouble(key).toInt()
+
+                                    else -> {
+                                        Logger.warning("Invalid view tag for key: $key")
+                                        continue
+                                    }
+                                }
+
+                            // Get the UIManager for this specific tag
+                            val uiManager =
+                                UIManagerHelper.getUIManagerForReactTag(reactContext, reactTag)
+                            if (uiManager == null) {
+                                Logger.warning("UIManager not found for tag: $reactTag")
+                                continue
+                            }
+
+                            // Resolve the view using the manager (now on UI thread)
+                            val view = uiManager.resolveView(reactTag)
+                            if (view is RoktEmbeddedView) {
+                                placeholdersMap[key] = WeakReference(view)
+                                Logger.debug("Successfully found Widget for key: $key with tag: $reactTag")
+                            } else {
+                                Logger.warning("View with tag $reactTag is not a Widget: ${view?.javaClass?.simpleName}")
+                            }
+                        } catch (e: Exception) {
+                            Logger.warning("Error processing placeholder for key $key: ${e.message}")
+                        }
+                    }
+                } finally {
+                    latch.countDown()
+                }
+            }
+
+            try {
+                // Wait for UI thread to finish processing
+                latch.await()
+            } catch (e: InterruptedException) {
+                Logger.warning("Interrupted while waiting for UI thread: ${e.message}")
+            }
+        }
+
+        return placeholdersMap
+    }
+}

package/android/src/newarch/java/com/mparticle/react/rokt/RoktLayoutViewManager.kt

@@ -0,0 +1,22 @@
+package com.mparticle.react.rokt
+
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RoktNativeLayoutManagerInterface
+import com.mparticle.rokt.RoktEmbeddedView
+
+class RoktLayoutViewManager : SimpleViewManager<RoktEmbeddedView>(),
+    RoktNativeLayoutManagerInterface<RoktEmbeddedView> {
+    private val impl = RoktLayoutViewManagerImpl()
+
+    override fun getName(): String = impl.getName()
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RoktEmbeddedView =
+        impl.createViewInstance(reactContext)
+
+    @ReactProp(name = "placeholderName")
+    override fun setPlaceholderName(view: RoktEmbeddedView?, value: String?) {
+        impl.setPlaceholderName(view, value)
+    }
+}

package/android/src/oldarch/java/com/mparticle/react/NativeMPRoktSpec.kt

@@ -0,0 +1,29 @@
+package com.mparticle.react
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableMap
+
+abstract class NativeMPRoktSpec(
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    companion object {
+        private const val MODULE_NAME = "RNMPRokt"
+    }
+
+    override fun getName(): String = MODULE_NAME
+
+    abstract fun selectPlacements(
+        identifier: String,
+        attributes: ReadableMap?,
+        placeholders: ReadableMap?,
+        roktConfig: ReadableMap?,
+        fontFilesMap: ReadableMap?,
+    )
+
+    abstract fun purchaseFinalized(
+        placementId: String,
+        catalogItemId: String,
+        success: Boolean,
+    )
+}