zixflow-reactnative 1.0.0

package/android/src/main/java/io/customer/reactnative/sdk/CustomerIOReactNativePackage.kt

@@ -0,0 +1,85 @@
+package io.customer.reactnative.sdk
+
+import com.facebook.react.BaseReactPackage
+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 io.customer.reactnative.sdk.location.NativeLocationModule
+import io.customer.reactnative.sdk.logging.NativeCustomerIOLoggingModule
+import io.customer.reactnative.sdk.messaginginapp.InlineInAppMessageViewManager
+import io.customer.reactnative.sdk.messaginginapp.NativeMessagingInAppModule
+import io.customer.reactnative.sdk.messagingpush.NativeMessagingPushModule
+import io.customer.reactnative.sdk.util.assertNotNull
+
+/**
+ * React Native package for Customer.io SDK that registers all TurboModules and ViewManagers.
+ * Implements new architecture support for React Native.
+ */
+class CustomerIOReactNativePackage : BaseReactPackage() {
+    /**
+     * Creates the list of view managers for the Customer.io React Native SDK.
+     */
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(InlineInAppMessageViewManager())
+    }
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        // Debugging reveals that this method is never called for ViewManagers.
+        // But since ReactNative docs recommend overriding it, we do so here for ViewManagers.
+        // See: https://reactnative.dev/docs/fabric-native-components-introduction?platforms=android#4-write-the-reactwebviewpackage
+        return when (name) {
+            InlineInAppMessageViewManager.NAME -> InlineInAppMessageViewManager()
+            NativeCustomerIOLoggingModule.NAME -> NativeCustomerIOLoggingModule(reactContext)
+            NativeCustomerIOModule.NAME -> NativeCustomerIOModule(reactContext = reactContext)
+            NativeLocationModule.NAME -> if (BuildConfig.CIO_LOCATION_ENABLED) {
+                NativeLocationModule(reactContext)
+            } else null
+            NativeMessagingInAppModule.NAME -> NativeMessagingInAppModule(reactContext)
+            NativeMessagingPushModule.NAME -> NativeMessagingPushModule(reactContext)
+            else -> assertNotNull<NativeModule>(value = null) { "Unknown module name: $name" }
+        }
+    }
+
+    /**
+     * Creates a ReactModuleInfo for React module registration with the given configuration.
+     * Using positional arguments instead of named arguments as named args break on RN 0.76.
+     */
+    private fun createReactModuleInfo(
+        name: String,
+        className: String = name,
+        canOverrideExistingModule: Boolean = false,
+        needsEagerInit: Boolean = false,
+        isCxxModule: Boolean = false,
+        isTurboModule: Boolean = true,
+    ) = ReactModuleInfo(
+        name,
+        className,
+        canOverrideExistingModule,
+        needsEagerInit,
+        isCxxModule,
+        isTurboModule,
+    )
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        // List of all Fabric ViewManagers and TurboModules registered in this package.
+        // Used by React Native to identify and instantiate the modules.
+        // Location module is always registered so TurboModuleRegistry.getEnforcing()
+        // doesn't crash at import time. getModule() returns null when disabled.
+        val moduleNames: List<String> = listOf(
+            InlineInAppMessageViewManager.NAME,
+            NativeCustomerIOLoggingModule.NAME,
+            NativeCustomerIOModule.NAME,
+            NativeLocationModule.NAME,
+            NativeMessagingInAppModule.NAME,
+            NativeMessagingPushModule.NAME,
+        )
+        return ReactModuleInfoProvider {
+            // Register all ViewManagers and TurboModules
+            moduleNames.associateWith { moduleName ->
+                createReactModuleInfo(name = moduleName)
+            }
+        }
+    }
+}

package/android/src/main/java/io/customer/reactnative/sdk/NativeCustomerIOModule.kt

@@ -0,0 +1,201 @@
+package io.customer.reactnative.sdk
+
+import android.app.Application
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.customer.datapipelines.config.ScreenView
+import io.customer.reactnative.sdk.constant.Keys
+import io.customer.reactnative.sdk.extension.getTypedValue
+import io.customer.reactnative.sdk.extension.toMap
+import io.customer.reactnative.sdk.location.NativeLocationModule
+import io.customer.reactnative.sdk.messaginginapp.NativeMessagingInAppModule
+import io.customer.reactnative.sdk.messagingpush.NativeMessagingPushModule
+import io.customer.reactnative.sdk.util.assertNotNull
+import io.customer.sdk.CustomerIO
+import io.customer.sdk.CustomerIOBuilder
+import io.customer.sdk.core.di.SDKComponent
+import io.customer.sdk.core.util.CioLogLevel
+import io.customer.sdk.core.util.Logger
+import io.customer.sdk.data.model.Region
+import io.customer.sdk.events.Metric
+import io.customer.sdk.events.TrackMetric
+import io.customer.sdk.events.serializedName
+
+/**
+ * React Native module implementation for Customer.io Native SDK
+ * using TurboModules with new architecture.
+ */
+class NativeCustomerIOModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeCustomerIOSpec(reactContext) {
+    private val logger: Logger
+        get() = SDKComponent.logger
+
+    // Returns CustomerIO instance if initialized, null otherwise, with configurable failure handling.
+    private inline fun getSDKInstanceOrNull(
+        onFailure: (exception: Throwable) -> Unit = {}
+    ): CustomerIO? = runCatching {
+        // If the SDK is not initialized, `CustomerIO.instance()` throws an exception
+        CustomerIO.instance()
+    }.onFailure(onFailure).getOrNull()
+
+    // Returns CustomerIO instance if initialized, null otherwise, logging error on failure.
+    private fun requireSDKInstance(): CustomerIO? = getSDKInstanceOrNull {
+        logger.error("CustomerIO SDK is not initialized. Please call initialize() first.")
+    }
+
+
+    override fun initialize(config: ReadableMap?, args: ReadableMap?, promise: Promise?) {
+        // Skip initialization if already initialized
+        if (getSDKInstanceOrNull() != null) {
+            logger.info("CustomerIO SDK is already initialized. Skipping initialization.")
+            promise?.resolve(true)
+            return
+        }
+
+        try {
+            val packageConfig = config.toMap()
+            val cdpApiKey = packageConfig.getTypedValue<String>(
+                Keys.Config.CDP_API_KEY
+            ) ?: throw IllegalArgumentException("CDP API Key is required to initialize Customer.io")
+
+            val logLevelRawValue = packageConfig.getTypedValue<String>(Keys.Config.LOG_LEVEL)
+            val regionRawValue = packageConfig.getTypedValue<String>(Keys.Config.REGION)
+            val region = regionRawValue.let { Region.getRegion(it) }
+            val screenViewRawValue =
+                packageConfig.getTypedValue<String>(Keys.Config.SCREEN_VIEW_USE)
+
+            CustomerIOBuilder(
+                applicationContext = reactContext.applicationContext as Application,
+                cdpApiKey = cdpApiKey
+            ).apply {
+                logLevelRawValue?.let { logLevel(CioLogLevel.getLogLevel(it)) }
+                regionRawValue?.let { region(region) }
+                screenViewRawValue?.let { screenViewUse(ScreenView.getScreenView(it)) }
+
+                packageConfig.getTypedValue<Boolean>(Keys.Config.AUTO_TRACK_DEVICE_ATTRIBUTES)
+                    ?.let { autoTrackDeviceAttributes(it) }
+                packageConfig.getTypedValue<String>(Keys.Config.MIGRATION_SITE_ID)
+                    ?.let { migrationSiteId(it) }
+                packageConfig.getTypedValue<Int>(Keys.Config.FLUSH_AT)
+                    ?.let { flushAt(it) }
+                packageConfig.getTypedValue<Int>(Keys.Config.FLUSH_INTERVAL)
+                    ?.let { flushInterval(it) }
+                packageConfig.getTypedValue<Boolean>(Keys.Config.TRACK_APP_LIFECYCLE_EVENTS)
+                    ?.let { trackApplicationLifecycleEvents(it) }
+                packageConfig.getTypedValue<String>(Keys.Config.API_HOST)
+                    ?.let { apiHost(it) }
+                packageConfig.getTypedValue<String>(Keys.Config.CDN_HOST)
+                    ?.let { cdnHost(it) }
+
+                // Configure push messaging module based on config provided by customer app
+                packageConfig.getTypedValue<Map<String, Any>>(key = "push").let { pushConfig ->
+                    NativeMessagingPushModule.addNativeModuleFromConfig(
+                        builder = this,
+                        config = pushConfig ?: emptyMap()
+                    )
+                }
+                // Configure in-app messaging module based on config provided by customer app
+                packageConfig.getTypedValue<Map<String, Any>>(key = "inApp")?.let { inAppConfig ->
+                    NativeMessagingInAppModule.addNativeModuleFromConfig(
+                        builder = this,
+                        config = inAppConfig,
+                        region = region
+                    )
+                }
+                // Configure location module if enabled via gradle property
+                if (BuildConfig.CIO_LOCATION_ENABLED) {
+                    packageConfig.getTypedValue<Map<String, Any>>(key = "location")?.let { locationConfig ->
+                        NativeLocationModule.addNativeModuleFromConfig(
+                            builder = this,
+                            config = locationConfig
+                        )
+                    }
+                }
+            }.build()
+
+            logger.info("Customer.io instance initialized successfully from app")
+            promise?.resolve(true)
+        } catch (ex: Exception) {
+            logger.error("Failed to initialize Customer.io instance from app, ${ex.message}")
+            promise?.reject(ex)
+        }
+    }
+
+    override fun identify(params: ReadableMap?) {
+        val userId = params?.getString("userId")
+        val traits = params?.getMap("traits")
+
+        if (userId == null && traits == null) {
+            logger.error("Either userId or traits must be provided for identify")
+            return
+        }
+
+        userId?.let {
+            requireSDKInstance()?.identify(userId, traits.toMap())
+        } ?: run {
+            requireSDKInstance()?.setProfileAttributes(traits.toMap())
+        }
+    }
+
+    override fun clearIdentify() {
+        requireSDKInstance()?.clearIdentify()
+    }
+
+    override fun track(name: String?, properties: ReadableMap?) {
+        val eventName = assertNotNull(name) ?: return
+
+        requireSDKInstance()?.track(eventName, properties.toMap())
+    }
+
+    override fun screen(title: String?, properties: ReadableMap?) {
+        val screenTitle = assertNotNull(title) ?: return
+
+        requireSDKInstance()?.screen(screenTitle, properties.toMap())
+    }
+
+    override fun setProfileAttributes(attributes: ReadableMap?) {
+        requireSDKInstance()?.setProfileAttributes(attributes.toMap())
+    }
+
+    override fun setDeviceAttributes(attributes: ReadableMap?) {
+        requireSDKInstance()?.setDeviceAttributes(attributes.toMap())
+    }
+
+    override fun registerDeviceToken(token: String?) {
+        val deviceToken = assertNotNull(token) ?: return
+
+        requireSDKInstance()?.registerDeviceToken(deviceToken)
+    }
+
+    override fun trackMetric(deliveryID: String?, deviceToken: String?, event: String?) {
+        try {
+            if (deliveryID == null || deviceToken == null || event == null) {
+                throw IllegalArgumentException("Missing required parameters")
+            }
+
+            val metric = Metric.values().find {
+                it.serializedName.equals(event, true)
+            } ?: throw IllegalArgumentException("Invalid metric event name")
+
+            requireSDKInstance()?.trackMetric(
+                event = TrackMetric.Push(
+                    deliveryId = deliveryID,
+                    deviceToken = deviceToken,
+                    metric = metric
+                )
+            )
+        } catch (e: Exception) {
+            logger.error("Error tracking push metric: ${e.message}")
+        }
+    }
+
+    override fun deleteDeviceToken() {
+        requireSDKInstance()?.deleteDeviceToken()
+    }
+
+    companion object {
+        internal const val NAME = "NativeCustomerIO"
+    }
+}

package/android/src/main/java/io/customer/reactnative/sdk/constant/Keys.kt

@@ -0,0 +1,20 @@
+package io.customer.reactnative.sdk.constant
+
+internal object Keys {
+    object Config {
+        const val LOG_LEVEL = "logLevel"
+        const val REGION = "region"
+        const val AUTO_TRACK_DEVICE_ATTRIBUTES = "autoTrackDeviceAttributes"
+        const val CDP_API_KEY = "cdpApiKey"
+        const val SITE_ID = "siteId"
+        const val MIGRATION_SITE_ID = "migrationSiteId"
+        const val TRACK_APP_LIFECYCLE_EVENTS = "trackApplicationLifecycleEvents"
+        const val FLUSH_AT = "flushAt"
+        const val FLUSH_INTERVAL = "flushInterval"
+        const val SCREEN_VIEW_USE = "screenViewUse"
+        const val API_HOST = "apiHost"
+        const val CDN_HOST = "cdnHost"
+        // Push messaging
+        const val PUSH_CLICK_BEHAVIOR = "pushClickBehavior"
+    }
+}

package/android/src/main/java/io/customer/reactnative/sdk/extension/MapExtensions.kt

@@ -0,0 +1,92 @@
+package io.customer.reactnative.sdk.extension
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+
+// Converts ReadableMap to Kotlin Map, filtering out null values.
+internal fun ReadableMap?.toMap(): Map<String, Any> {
+    return this?.toHashMap()?.filterValues {
+        it != null
+    }?.mapValues { it.value as Any } ?: emptyMap()
+}
+
+// Retrieves a typed value from the map using reified type parameter.
+internal inline fun <reified V> Map<String, Any?>?.getTypedValue(key: String): V? {
+    return this?.get(key) as? V
+}
+
+/**
+ * Converts Kotlin Map to WritableMap for React Native, handling nested maps/arrays recursively.
+ * Long values are converted to Double since JavaScript doesn't have type Long.
+ */
+internal fun Map<String, Any?>.toWritableMap(): WritableMap {
+    val writableMap = Arguments.createMap()
+
+    for ((key, value) in this) {
+        when (value) {
+            null -> writableMap.putNull(key)
+            is String -> writableMap.putString(key, value)
+            is Int -> writableMap.putInt(key, value)
+            is Double -> writableMap.putDouble(key, value)
+            is Float -> writableMap.putDouble(key, value.toDouble())
+            is Boolean -> writableMap.putBoolean(key, value)
+            is Long -> writableMap.putDouble(key, value.toDouble()) // JS has no Long
+            is Map<*, *> -> {
+                @Suppress("UNCHECKED_CAST")
+                writableMap.putMap(key, (value as Map<String, Any?>).toWritableMap())
+            }
+
+            is List<*> -> writableMap.putArray(key, value.toWritableArray())
+            else -> {
+                // Fallback — convert to string
+                writableMap.putString(key, value.toString())
+            }
+        }
+    }
+
+    return writableMap
+}
+
+/**
+ * Converts Kotlin List to WritableArray for React Native, handling nested lists/maps recursively.
+ * Long values are converted to Double since JavaScript doesn't have type Long.
+ */
+internal fun List<*>.toWritableArray(): WritableArray {
+    val writableArray = Arguments.createArray()
+
+    for (value in this) {
+        when (value) {
+            null -> writableArray.pushNull()
+            is String -> writableArray.pushString(value)
+            is Int -> writableArray.pushInt(value)
+            is Double -> writableArray.pushDouble(value)
+            is Float -> writableArray.pushDouble(value.toDouble())
+            is Boolean -> writableArray.pushBoolean(value)
+            is Long -> writableArray.pushDouble(value.toDouble())
+            is Map<*, *> -> {
+                @Suppress("UNCHECKED_CAST")
+                writableArray.pushMap((value as Map<String, Any?>).toWritableMap())
+            }
+
+            is List<*> -> writableArray.pushArray(value.toWritableArray())
+            else -> writableArray.pushString(value.toString())
+        }
+    }
+
+    return writableArray
+}
+
+// Puts a value into WritableMap, calling putNull if value is null, otherwise executing putBlock.
+internal inline fun <T> WritableMap.putOrNull(
+    key: String,
+    value: T?,
+    putBlock: WritableMap.(String, T) -> Unit,
+) {
+    if (value == null) {
+        putNull(key)
+    } else {
+        putBlock(key, value)
+    }
+}

package/android/src/main/java/io/customer/reactnative/sdk/extension/ReactExtensions.kt

@@ -0,0 +1,11 @@
+package io.customer.reactnative.sdk.extension
+
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+
+/**
+ * Extension property to get [ReactContext] from a View.
+ * Casts the view's context to ReactContext for React Native integration.
+ */
+internal val View.reactContext: ReactContext
+    get() = context as ReactContext

package/android/src/main/java/io/customer/reactnative/sdk/extension/StringExtensions.kt

@@ -0,0 +1,3 @@
+package io.customer.reactnative.sdk.extension
+
+internal fun String.takeIfNotBlank(): String? = takeIf { it.isNotBlank() }

package/android/src/main/java/io/customer/reactnative/sdk/extension/ViewExtensions.kt

@@ -0,0 +1,34 @@
+package io.customer.reactnative.sdk.extension
+
+import android.view.View
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Extension function to send UI events from native Android views to React JS.
+ * Retrieves the event dispatcher and dispatches the event to React Native bridge.
+ *
+ * @param eventName The name of the event to be sent to React JS
+ * @param payload Optional data payload to include with the event
+ */
+internal fun View.sendUIEventToReactJS(
+    eventName: String,
+    payload: WritableMap? = null,
+) {
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+    eventDispatcher?.dispatchEvent(UIStateEvent(this, eventName, payload))
+}
+
+/**
+ * Event class for sending UI state changes from Android views to React Native.
+ * Extends the React Native Event class to provide a bridge for native-to-JS communication.
+ */
+private class UIStateEvent(
+    view: View,
+    private val name: String,
+    private val payload: WritableMap? = null
+) : Event<UIStateEvent>(UIManagerHelper.getSurfaceId(view.reactContext), view.id) {
+    override fun getEventName() = name
+    override fun getEventData(): WritableMap? = payload
+}

package/android/src/main/java/io/customer/reactnative/sdk/location/NativeLocationModule.kt

@@ -0,0 +1,66 @@
+package io.customer.reactnative.sdk.location
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import io.customer.location.LocationModuleConfig
+import io.customer.location.LocationTrackingMode
+import io.customer.location.ModuleLocation
+import io.customer.reactnative.sdk.NativeCustomerIOLocationSpec
+import io.customer.reactnative.sdk.extension.getTypedValue
+import io.customer.sdk.CustomerIOBuilder
+import io.customer.sdk.core.di.SDKComponent
+import io.customer.sdk.core.util.Logger
+
+/**
+ * React Native module implementation for Customer.io Location Native SDK
+ * using TurboModules with new architecture.
+ */
+@ReactModule(name = NativeLocationModule.NAME)
+class NativeLocationModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeCustomerIOLocationSpec(reactContext) {
+    private val logger: Logger
+        get() = SDKComponent.logger
+
+    private fun getLocationServices() = runCatching {
+        ModuleLocation.instance().locationServices
+    }.onFailure {
+        logger.error("Location module is not initialized. Ensure location config is provided during SDK initialization.")
+    }.getOrNull()
+
+    override fun setLastKnownLocation(latitude: Double, longitude: Double) {
+        getLocationServices()?.setLastKnownLocation(latitude, longitude)
+    }
+
+    override fun requestLocationUpdate() {
+        getLocationServices()?.requestLocationUpdate()
+    }
+
+    companion object {
+        const val NAME = "NativeCustomerIOLocation"
+
+        /**
+         * Adds location module to native Android SDK based on the configuration provided by
+         * customer app.
+         *
+         * @param builder instance of CustomerIOBuilder to add location module.
+         * @param config configuration provided by customer app for location module.
+         */
+        internal fun addNativeModuleFromConfig(
+            builder: CustomerIOBuilder,
+            config: Map<String, Any>
+        ) {
+            val trackingModeValue = config.getTypedValue<String>("trackingMode")
+            val trackingMode = trackingModeValue?.let { value ->
+                runCatching { enumValueOf<LocationTrackingMode>(value) }.getOrNull()
+            } ?: LocationTrackingMode.MANUAL
+
+            val module = ModuleLocation(
+                LocationModuleConfig.Builder()
+                    .setLocationTrackingMode(trackingMode)
+                    .build()
+            )
+            builder.addCustomerIOModule(module)
+        }
+    }
+}

package/android/src/main/java/io/customer/reactnative/sdk/logging/NativeCustomerIOLoggingModule.kt

@@ -0,0 +1,90 @@
+package io.customer.reactnative.sdk.logging
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.customer.reactnative.sdk.NativeCustomerIOLoggingSpec
+import io.customer.sdk.core.di.SDKComponent
+import io.customer.sdk.core.util.CioLogLevel
+
+/**
+ * React Native module implementation for Customer.io Logging Native SDK
+ * using TurboModules with new architecture.
+ */
+class NativeCustomerIOLoggingModule(
+    reactContext: ReactApplicationContext,
+) : NativeCustomerIOLoggingSpec(reactContext) {
+    override fun getName(): String = NAME
+
+    // Log event emitter function to send events to React Native layer
+    private var logEventEmitter: ((ReadableMap) -> Unit)? = null
+
+    /**
+     * Executes the given block and logs any uncaught exceptions using Android logger to protect
+     * against unexpected crashes and failures.
+     */
+    private fun runWithTryCatch(action: () -> Unit) {
+        try {
+            action()
+        } catch (ex: Exception) {
+            // Use Android logger to avoid cyclic calls from internal SDK logging
+            Log.e("[CIO]", "Error in NativeCustomerIOLoggingModule: ${ex.message}", ex)
+        }
+    }
+
+    override fun initialize() {
+        runWithTryCatch {
+            super.initialize()
+            setLogEventEmitter { data ->
+                emitOnCioLogEvent(data)
+            }
+        }
+    }
+
+    override fun invalidate() {
+        runWithTryCatch {
+            cleanupLogEventEmitter()
+            super.invalidate()
+        }
+    }
+
+    private fun cleanupLogEventEmitter() {
+        runWithTryCatch {
+            // Clear log dispatcher to prevent memory leaks and further events
+            SDKComponent.logger.setLogDispatcher(null)
+            this.logEventEmitter = null
+        }
+    }
+
+    // Sets the event emitter function used to send log events to React Native.
+    private fun setLogEventEmitter(emitter: ((ReadableMap) -> Unit)?) {
+        if (emitter == null) {
+            // Clear log dispatcher if emitter is null
+            cleanupLogEventEmitter()
+            return
+        }
+
+        SDKComponent.logger.setLogDispatcher { level, message ->
+            emitLogEvent(level, message)
+        }
+        this.logEventEmitter = emitter
+    }
+
+    // Converts native SDK log events to React Native compatible format and emits them.
+    private fun emitLogEvent(level: CioLogLevel, message: String) {
+        // Defensive check: only emit if emitter is available
+        val emitter = logEventEmitter ?: return
+
+        val data = buildMap {
+            put("logLevel", level.name.lowercase())
+            put("message", message)
+        }
+
+        emitter.invoke(Arguments.makeNativeMap(data))
+    }
+
+    companion object {
+        internal const val NAME = "NativeCustomerIOLogging"
+    }
+}

package/android/src/main/java/io/customer/reactnative/sdk/messaginginapp/InlineInAppMessageViewManager.kt

@@ -0,0 +1,56 @@
+package io.customer.reactnative.sdk.messaginginapp
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.InlineMessageNativeManagerDelegate
+import com.facebook.react.viewmanagers.InlineMessageNativeManagerInterface
+import io.customer.messaginginapp.ui.bridge.WrapperPlatformDelegate
+
+/**
+ * Base view manager for inline in-app message components.
+ *
+ * Provides common functionality for both old and new React Native architecture
+ * implementations, including view creation, event handling, and property management.
+ */
+@ReactModule(name = InlineInAppMessageViewManager.NAME)
+class InlineInAppMessageViewManager :
+    InlineMessageNativeManagerInterface<ReactInlineInAppMessageView>,
+    SimpleViewManager<ReactInlineInAppMessageView>() {
+    private val delegate = InlineMessageNativeManagerDelegate(this)
+
+    override fun getName() = NAME
+    override fun getDelegate(): ViewManagerDelegate<ReactInlineInAppMessageView> = delegate
+
+    override fun createViewInstance(reactContext: ThemedReactContext): ReactInlineInAppMessageView {
+        return ReactInlineInAppMessageView(reactContext)
+    }
+
+    /**
+     * This method exports custom direct event types for the inline message view.
+     * It registers two custom events:
+     * - onSizeChange: Triggered when the size of the inline message changes.
+     * - onStateChange: Triggered when the state of the inline message changes.
+     */
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String?, Any?> {
+        val customEvents = super.getExportedCustomDirectEventTypeConstants() ?: mutableMapOf()
+        val registerCustomEvent = { eventName: String ->
+            customEvents.put(eventName, mapOf("registrationName" to eventName))
+        }
+        registerCustomEvent(WrapperPlatformDelegate.ON_SIZE_CHANGE)
+        registerCustomEvent(WrapperPlatformDelegate.ON_STATE_CHANGE)
+        registerCustomEvent(ReactInAppPlatformDelegate.ON_ACTION_CLICK)
+        return customEvents
+    }
+
+    @ReactProp(name = "elementId")
+    override fun setElementId(view: ReactInlineInAppMessageView?, value: String?) {
+        view?.elementId = value
+    }
+
+    companion object {
+        internal const val NAME = "InlineMessageNative"
+    }
+}