@adstage/react-native-sdk 1.0.0

package/android/src/main/java/io/nbase/adstage/reactnative/AdStageModule.kt

@@ -0,0 +1,701 @@
+package io.nbase.adstage.reactnative
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import io.nbase.adapter.adstage.AdStage
+import io.nbase.adapter.adstage.models.*
+import io.nbase.adapter.adstage.deeplink.DeeplinkHandler
+import io.nbase.adapter.adstage.promotion.PromotionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/**
+ * AdStage React Native 네이티브 모듈
+ * 
+ * React Native와 AdStage 네이티브 SDK를 연결하는 브릿지입니다.
+ * 
+ * @since 3.0.0
+ */
+class AdStageModule(reactContext: ReactApplicationContext) : 
+    ReactContextBaseJavaModule(reactContext) {
+    
+    companion object {
+        private const val TAG = "AdStageModule"
+        private const val MODULE_NAME = "AdStageModule"
+    }
+    
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    
+    override fun getName(): String = MODULE_NAME
+    
+    // ============================================
+    // Initialization
+    // ============================================
+    
+    @ReactMethod
+    fun initialize(apiKey: String, serverUrl: String, promise: Promise) {
+        try {
+            Log.d(TAG, "Initializing AdStage SDK...")
+            
+            val context = currentActivity ?: reactApplicationContext
+            
+            // serverUrl이 빈 문자열이면 기본값 사용 (iOS와 동일한 처리)
+            if (serverUrl.isEmpty()) {
+                AdStage.initialize(
+                    context = context,
+                    apiKey = apiKey
+                )
+            } else {
+                AdStage.initialize(
+                    context = context,
+                    apiKey = apiKey,
+                    serverUrl = serverUrl
+                )
+            }
+            
+            Log.d(TAG, "AdStage SDK initialized successfully")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to initialize AdStage SDK", e)
+            promise.reject("INIT_ERROR", e.message, e)
+        }
+    }
+    
+    @ReactMethod
+    fun getVersion(promise: Promise) {
+        promise.resolve("3.0.0")
+    }
+    
+    // ============================================
+    // User Attributes
+    // ============================================
+    
+    @ReactMethod
+    fun setUserAttributes(attributes: ReadableMap, promise: Promise) {
+        try {
+            val userAttributes = UserAttributes(
+                gender = attributes.getString("gender"),
+                country = attributes.getString("country"),
+                city = attributes.getString("city"),
+                age = attributes.getString("age"),
+                language = attributes.getString("language")
+            )
+            
+            AdStage.setUserAttributes(userAttributes)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SET_USER_ATTR_ERROR", e.message, e)
+        }
+    }
+    
+    @ReactMethod
+    fun getUserAttributes(promise: Promise) {
+        try {
+            val attrs = AdStage.getUserAttributes()
+            if (attrs != null) {
+                val map = Arguments.createMap().apply {
+                    attrs.gender?.let { putString("gender", it) }
+                    attrs.country?.let { putString("country", it) }
+                    attrs.city?.let { putString("city", it) }
+                    attrs.age?.let { putString("age", it) }
+                    attrs.language?.let { putString("language", it) }
+                }
+                promise.resolve(map)
+            } else {
+                promise.resolve(null)
+            }
+        } catch (e: Exception) {
+            promise.reject("GET_USER_ATTR_ERROR", e.message, e)
+        }
+    }
+    
+    @ReactMethod
+    fun clearUserAttributes(promise: Promise) {
+        try {
+            AdStage.clearUserAttributes()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CLEAR_USER_ATTR_ERROR", e.message, e)
+        }
+    }
+    
+    // ============================================
+    // DeepLink
+    // ============================================
+    
+    @ReactMethod
+    fun setDeepLinkListener() {
+        Log.d(TAG, "Setting deep link listener")
+        
+        AdStage.setDeeplinkListener(object : DeeplinkListener {
+            override fun onDeeplinkReceived(data: DeeplinkData) {
+                Log.d(TAG, "Deep link received: ${data.shortPath}")
+                
+                val params = Arguments.createMap().apply {
+                    putString("linkId", data.deeplinkId)
+                    putString("shortPath", data.shortPath)
+                    putString("source", data.source.value)
+                    putString("eventType", data.eventType.value)
+                    
+                    val parametersMap = Arguments.createMap()
+                    data.parameters.forEach { (key, value) ->
+                        parametersMap.putString(key, value)
+                    }
+                    putMap("parameters", parametersMap)
+                }
+                
+                sendEvent("onDeepLinkReceived", params)
+            }
+            
+            override fun onDeeplinkFailed(error: String, shortPath: String?) {
+                Log.e(TAG, "Deep link failed: $error (shortPath: $shortPath)")
+            }
+        })
+    }
+    
+    @ReactMethod
+    fun removeDeepLinkListener() {
+        AdStage.clearDeeplinkListener()
+    }
+    
+    @ReactMethod
+    fun createDeepLink(request: ReadableMap, promise: Promise) {
+        scope.launch {
+            try {
+                val name = request.getString("name") ?: run {
+                    promise.reject("INVALID_PARAMS", "name is required")
+                    return@launch
+                }
+                
+                val response = AdStage.createDeeplink(name) {
+                    request.getString("description")?.let { description(it) }
+                    request.getString("channel")?.let { channel(it) }
+                    request.getString("subChannel")?.let { subChannel(it) }
+                    request.getString("campaign")?.let { campaign(it) }
+                    request.getString("adGroup")?.let { adGroup(it) }
+                    request.getString("creative")?.let { creative(it) }
+                    request.getString("keyword")?.let { keyword(it) }
+                    
+                    // Redirect Config
+                    request.getMap("redirectConfig")?.let { config ->
+                        redirectConfig {
+                            config.getMap("android")?.let { androidConfig ->
+                                android {
+                                    androidConfig.getString("storeUrl")?.let { storeUrl(it) }
+                                    androidConfig.getString("appScheme")?.let { appScheme(it) }
+                                    androidConfig.getString("webUrl")?.let { webUrl(it) }
+                                }
+                            }
+                            config.getMap("ios")?.let { iosConfig ->
+                                ios {
+                                    iosConfig.getString("storeUrl")?.let { storeUrl(it) }
+                                    iosConfig.getString("appScheme")?.let { appScheme(it) }
+                                    iosConfig.getString("webUrl")?.let { webUrl(it) }
+                                }
+                            }
+                        }
+                    }
+                    
+                    // Parameters
+                    request.getMap("parameters")?.let { params ->
+                        val iterator = params.keySetIterator()
+                        while (iterator.hasNextKey()) {
+                            val key = iterator.nextKey()
+                            params.getString(key)?.let { value ->
+                                parameter(key, value)
+                            }
+                        }
+                    }
+                }
+                
+                val result = Arguments.createMap().apply {
+                    putString("shortUrl", response.shortUrl)
+                    putString("shortPath", response.shortPath)
+                    putString("linkId", response.id)
+                }
+                
+                promise.resolve(result)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to create deep link", e)
+                promise.reject("CREATE_DEEPLINK_ERROR", e.message, e)
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun checkPendingDeepLink() {
+        // Pending 딥링크는 리스너 설정 시 자동으로 전달됨
+        Log.d(TAG, "checkPendingDeepLink called")
+    }
+    
+    @ReactMethod
+    fun handleIntent() {
+        currentActivity?.let { activity ->
+            AdStage.handleIntent(activity, activity.intent)
+        }
+    }
+    
+    // ============================================
+    // Promotion
+    // ============================================
+    
+    @ReactMethod
+    fun getPromotionList(params: ReadableMap, promise: Promise) {
+        scope.launch {
+            try {
+                val listParams = PromotionListParams(
+                    bannerType = params.getString("bannerType"),
+                    targetAudience = params.getString("targetAudience"),
+                    deviceType = params.getString("deviceType"),
+                    region = params.getString("region"),
+                    limit = if (params.hasKey("limit")) params.getInt("limit") else null,
+                    status = params.getString("status"),
+                    partner = params.getString("partner"),
+                    primaryInterest = params.getString("primaryInterest"),
+                    primaryAgeGroup = params.getString("primaryAgeGroup"),
+                    gameGenrePreference = params.getString("gameGenrePreference"),
+                    playerSpendingTier = params.getString("playerSpendingTier"),
+                    playTimePattern = params.getString("playTimePattern")
+                )
+                
+                val response = AdStage.getPromotionList(listParams)
+                
+                val promotionsArray = Arguments.createArray()
+                response.promotions.forEach { promo ->
+                    promotionsArray.pushMap(promotionToMap(promo))
+                }
+                
+                val result = Arguments.createMap().apply {
+                    putInt("totalItems", response.totalItems)
+                    putArray("promotions", promotionsArray)
+                }
+                
+                promise.resolve(result)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to get promotion list", e)
+                promise.reject("GET_PROMOTION_ERROR", e.message, e)
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun handlePromotionClick(promotionMap: ReadableMap, promise: Promise) {
+        scope.launch {
+            try {
+                val context = currentActivity ?: reactApplicationContext
+                
+                // ReadableMap에서 Promotion 객체 복원
+                val promotion = mapToPromotion(promotionMap)
+                
+                val result = AdStage.handlePromotionClick(context, promotion)
+                
+                when (result) {
+                    is PromotionClickResult.Success -> {
+                        val map = Arguments.createMap().apply {
+                            putBoolean("success", true)
+                            putString("storeUrl", result.storeUrl)
+                        }
+                        promise.resolve(map)
+                    }
+                    is PromotionClickResult.Failure -> {
+                        val map = Arguments.createMap().apply {
+                            putBoolean("success", false)
+                            putString("error", result.error)
+                        }
+                        promise.resolve(map)
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to handle promotion click", e)
+                promise.reject("PROMOTION_CLICK_ERROR", e.message, e)
+            }
+        }
+    }
+    
+    // ============================================
+    // Event Tracking
+    // ============================================
+    
+    @ReactMethod
+    fun trackEvent(eventName: String, params: ReadableMap?, promise: Promise) {
+        scope.launch {
+            try {
+                val eventParams = params?.toHashMap() ?: emptyMap<String, Any>()
+                
+                // Unity 래퍼와 동일하게 모든 이벤트 타입을 처리
+                val event = parseAdStageEvent(eventName, eventParams)
+                
+                val response = AdStage.trackEvent(event)
+                
+                val result = Arguments.createMap().apply {
+                    putBoolean("success", true)
+                    putString("eventId", response.id)
+                }
+                
+                promise.resolve(result)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to track event: $eventName", e)
+                promise.reject("TRACK_EVENT_ERROR", e.message, e)
+            }
+        }
+    }
+    
+    /**
+     * React Native params를 AdStageEvent로 변환
+     * Unity 래퍼와 동일한 로직
+     */
+    private fun parseAdStageEvent(eventName: String, params: Map<String, Any?>): AdStageEvent {
+        val safeParams = params.filterValues { it != null }.mapValues { it.value!! }
+        
+        return when (eventName) {
+            // 광고 추적 이벤트
+            "click" -> AdStageEvent.Click(params = safeParams)
+            "view" -> AdStageEvent.View(params = safeParams)
+            "install" -> AdStageEvent.Install(params = safeParams)
+            "custom" -> AdStageEvent.Custom(params = safeParams)
+            
+            // 사용자 라이프사이클
+            "sign_up" -> AdStageEvent.SignUp(
+                method = params["method"]?.toString()
+            )
+            "sign_up_start" -> AdStageEvent.SignUpStart(params = safeParams)
+            "login" -> AdStageEvent.Login(
+                method = params["method"]?.toString()
+            )
+            "logout" -> AdStageEvent.Logout(params = safeParams)
+            "first_open" -> AdStageEvent.FirstOpen(params = safeParams)
+            
+            // 콘텐츠 조회
+            "home_view" -> AdStageEvent.HomeView(params = safeParams)
+            "product_list_view" -> AdStageEvent.ProductListView(
+                itemCategory = params["item_category"]?.toString()
+            )
+            "search_result_view" -> AdStageEvent.SearchResultView(
+                searchTerm = params["search_term"]?.toString()
+            )
+            "product_details_view" -> AdStageEvent.ProductDetailsView(
+                itemId = params["item_id"]?.toString(),
+                itemName = params["item_name"]?.toString()
+            )
+            "page_view" -> AdStageEvent.PageView(
+                pageUrl = params["page_url"]?.toString(),
+                pageTitle = params["page_title"]?.toString(),
+                pagePath = params["page_path"]?.toString(),
+                referrer = params["referrer"]?.toString()
+            )
+            "screen_view" -> AdStageEvent.ScreenView(
+                screenName = params["screen_name"]?.toString(),
+                screenClass = params["screen_class"]?.toString()
+            )
+            
+            // 전자상거래
+            "add_to_cart" -> AdStageEvent.AddToCart(
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString(),
+                items = parseEcommerceItems(params["items"])
+            )
+            "remove_from_cart" -> AdStageEvent.RemoveFromCart(
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString(),
+                items = parseEcommerceItems(params["items"])
+            )
+            "add_to_wishlist" -> AdStageEvent.AddToWishlist(
+                itemId = params["item_id"]?.toString(),
+                itemName = params["item_name"]?.toString()
+            )
+            "add_payment_info" -> AdStageEvent.AddPaymentInfo(
+                paymentType = params["payment_type"]?.toString()
+            )
+            "begin_checkout" -> AdStageEvent.BeginCheckout(
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString(),
+                items = parseEcommerceItems(params["items"])
+            )
+            "purchase" -> AdStageEvent.Purchase(
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString(),
+                transactionId = params["transaction_id"]?.toString(),
+                tax = params["tax"]?.toDoubleOrNull(),
+                shipping = params["shipping"]?.toDoubleOrNull(),
+                coupon = params["coupon"]?.toString(),
+                items = parseEcommerceItems(params["items"])
+            )
+            "refund" -> AdStageEvent.Refund(
+                transactionId = params["transaction_id"]?.toString(),
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString()
+            )
+            
+            // 구독/체험
+            "start_trial" -> AdStageEvent.StartTrial(
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString(),
+                trialDays = params["trial_days"]?.toIntOrNull()
+            )
+            "subscribe" -> AdStageEvent.Subscribe(
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString(),
+                subscriptionId = params["subscription_id"]?.toString()
+            )
+            "unsubscribe" -> AdStageEvent.Unsubscribe(
+                subscriptionId = params["subscription_id"]?.toString()
+            )
+            
+            // 인앱 광고
+            "ad_impression" -> AdStageEvent.AdImpression(
+                adPlatform = params["ad_platform"]?.toString(),
+                adSource = params["ad_source"]?.toString(),
+                adFormat = params["ad_format"]?.toString(),
+                adUnitName = params["ad_unit_name"]?.toString()
+            )
+            "ad_click" -> AdStageEvent.AdClick(
+                adPlatform = params["ad_platform"]?.toString(),
+                adSource = params["ad_source"]?.toString(),
+                adFormat = params["ad_format"]?.toString(),
+                adUnitName = params["ad_unit_name"]?.toString()
+            )
+            
+            // 게임 특화
+            "tutorial_begin" -> AdStageEvent.TutorialBegin(params = safeParams)
+            "tutorial_complete" -> AdStageEvent.TutorialComplete(params = safeParams)
+            "level_up" -> AdStageEvent.LevelUp(
+                level = params["level"]?.toIntOrNull(),
+                character = params["character"]?.toString()
+            )
+            "achievement" -> AdStageEvent.Achievement(
+                achievementId = params["achievement_id"]?.toString()
+            )
+            "game_play" -> AdStageEvent.GamePlay(
+                level = params["level"]?.toIntOrNull(),
+                levelName = params["level_name"]?.toString(),
+                character = params["character"]?.toString(),
+                contentType = params["content_type"]?.toString()
+            )
+            "acquire_bonus" -> AdStageEvent.AcquireBonus(
+                contentType = params["content_type"]?.toString(),
+                itemId = params["item_id"]?.toString(),
+                itemName = params["item_name"]?.toString(),
+                quantity = params["quantity"]?.toIntOrNull()
+            )
+            "select_game_server" -> AdStageEvent.SelectGameServer(
+                contentId = params["content_id"]?.toString(),
+                contentType = params["content_type"]?.toString(),
+                itemName = params["item_name"]?.toString()
+            )
+            "complete_patch" -> AdStageEvent.CompletePatch(
+                contentId = params["content_id"]?.toString(),
+                contentType = params["content_type"]?.toString()
+            )
+            
+            // 상호작용
+            "search" -> AdStageEvent.Search(
+                searchTerm = params["search_term"]?.toString()
+            )
+            "select_content" -> AdStageEvent.SelectContent(
+                contentType = params["content_type"]?.toString(),
+                contentId = params["content_id"]?.toString()
+            )
+            "share" -> AdStageEvent.Share(
+                contentType = params["content_type"]?.toString(),
+                method = params["method"]?.toString()
+            )
+            "like" -> AdStageEvent.Like(
+                contentType = params["content_type"]?.toString(),
+                contentId = params["content_id"]?.toString()
+            )
+            "rate" -> AdStageEvent.Rate(
+                contentType = params["content_type"]?.toString(),
+                contentId = params["content_id"]?.toString(),
+                score = params["score"]?.toDoubleOrNull()
+            )
+            "schedule" -> AdStageEvent.Schedule(params = safeParams)
+            "spend_credits" -> AdStageEvent.SpendCredits(
+                value = params["value"]?.toDoubleOrNull(),
+                itemName = params["item_name"]?.toString()
+            )
+            
+            // 금융 특화
+            "sell_stock" -> AdStageEvent.SellStock(
+                itemId = params["item_id"]?.toString(),
+                itemName = params["item_name"]?.toString(),
+                quantity = params["quantity"]?.toIntOrNull(),
+                price = params["price"]?.toDoubleOrNull(),
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString()
+            )
+            "buy_stock" -> AdStageEvent.BuyStock(
+                itemId = params["item_id"]?.toString(),
+                itemName = params["item_name"]?.toString(),
+                quantity = params["quantity"]?.toIntOrNull(),
+                price = params["price"]?.toDoubleOrNull(),
+                value = params["value"]?.toDoubleOrNull(),
+                currency = params["currency"]?.toString()
+            )
+            "complete_open_account" -> AdStageEvent.CompleteOpenAccount(
+                contentType = params["content_type"]?.toString(),
+                contentId = params["content_id"]?.toString(),
+                method = params["method"]?.toString()
+            )
+            "apply_card" -> AdStageEvent.ApplyCard(
+                contentType = params["content_type"]?.toString(),
+                itemName = params["item_name"]?.toString(),
+                itemId = params["item_id"]?.toString()
+            )
+            
+            // 알 수 없는 이벤트는 Custom으로 처리
+            else -> {
+                Log.w(TAG, "Unknown event name: $eventName, using Custom event")
+                AdStageEvent.Custom(params = safeParams)
+            }
+        }
+    }
+    
+    /**
+     * EcommerceItem 리스트 파싱
+     */
+    @Suppress("UNCHECKED_CAST")
+    private fun parseEcommerceItems(itemsData: Any?): List<EcommerceItem>? {
+        if (itemsData == null) return null
+        
+        return try {
+            when (itemsData) {
+                is List<*> -> itemsData.mapNotNull { item ->
+                    when (item) {
+                        is Map<*, *> -> {
+                            val itemId = (item["item_id"] ?: item["itemId"])?.toString() ?: return@mapNotNull null
+                            val itemName = (item["item_name"] ?: item["itemName"])?.toString() ?: return@mapNotNull null
+                            val price = (item["price"])?.toDoubleOrNull() ?: return@mapNotNull null
+                            val quantity = (item["quantity"])?.toIntOrNull() ?: return@mapNotNull null
+                            
+                            EcommerceItem(
+                                itemId = itemId,
+                                itemName = itemName,
+                                price = price,
+                                quantity = quantity
+                            )
+                        }
+                        else -> null
+                    }
+                }.takeIf { it.isNotEmpty() }
+                
+                is ArrayList<*> -> parseEcommerceItems(itemsData.toList())
+                
+                else -> {
+                    Log.w(TAG, "Unknown items type: ${itemsData::class.java}")
+                    null
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to parse EcommerceItems", e)
+            null
+        }
+    }
+    
+    /**
+     * Any 타입을 Double로 변환
+     */
+    private fun Any?.toDoubleOrNull(): Double? {
+        return when (this) {
+            is Number -> this.toDouble()
+            is String -> this.toDoubleOrNull()
+            else -> null
+        }
+    }
+    
+    /**
+     * Any 타입을 Int로 변환
+     */
+    private fun Any?.toIntOrNull(): Int? {
+        return when (this) {
+            is Number -> this.toInt()
+            is String -> this.toIntOrNull()
+            else -> null
+        }
+    }
+    
+    // ============================================
+    // Helpers
+    // ============================================
+    
+    private fun sendEvent(eventName: String, params: WritableMap) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+    
+    private fun promotionToMap(promo: Promotion): WritableMap {
+        return Arguments.createMap().apply {
+            putString("id", promo.id)
+            putString("partner", promo.partner)
+            putString("appName", promo.appName)
+            putString("bannerUrl", promo.bannerUrl)
+            putString("bannerType", promo.bannerType)
+            putString("appDescription", promo.appDescription)
+            
+            // DeepLink
+            putMap("deeplink", Arguments.createMap().apply {
+                putString("id", promo.deeplink.id)
+                putString("name", promo.deeplink.name)
+                putString("description", promo.deeplink.description)
+                putString("shortPath", promo.deeplink.shortPath)
+                putString("linkType", promo.deeplink.linkType)
+                putString("channel", promo.deeplink.channel)
+                putString("subChannel", promo.deeplink.subChannel)
+                putString("campaign", promo.deeplink.campaign)
+                putString("status", promo.deeplink.status)
+            })
+            
+            // Store URLs
+            promo.storeUrls?.let { urls ->
+                putMap("storeUrls", Arguments.createMap().apply {
+                    putString("android", urls.android)
+                    putString("ios", urls.ios)
+                })
+            }
+        }
+    }
+    
+    private fun mapToPromotion(map: ReadableMap): Promotion {
+        val deeplinkMap = map.getMap("deeplink")
+        
+        return Promotion(
+            id = map.getString("id") ?: "",
+            partner = map.getString("partner") ?: "",
+            appName = map.getString("appName") ?: "",
+            bannerUrl = map.getString("bannerUrl") ?: "",
+            bannerType = map.getString("bannerType") ?: "",
+            appDescription = map.getString("appDescription") ?: "",
+            deeplink = PromotionDeeplink(
+                id = deeplinkMap?.getString("id") ?: "",
+                name = deeplinkMap?.getString("name") ?: "",
+                description = deeplinkMap?.getString("description") ?: "",
+                shortPath = deeplinkMap?.getString("shortPath") ?: "",
+                linkType = deeplinkMap?.getString("linkType") ?: "",
+                channel = deeplinkMap?.getString("channel") ?: "",
+                subChannel = deeplinkMap?.getString("subChannel") ?: "",
+                campaign = deeplinkMap?.getString("campaign") ?: "",
+                status = deeplinkMap?.getString("status") ?: ""
+            ),
+            storeUrls = map.getMap("storeUrls")?.let { urls ->
+                StoreUrls(
+                    android = urls.getString("android") ?: "",
+                    ios = urls.getString("ios") ?: ""
+                )
+            }
+        )
+    }
+    
+    // Required for RN event emitter
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Keep: Required for RN built-in Event Emitter
+    }
+    
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Keep: Required for RN built-in Event Emitter
+    }
+}