tagworks-sdk-v1-react 1.1.20 → 1.1.22

package/android/src/main/java/com/tagworkssdkv1/TagWorksModule.kt

@@ -5,446 +5,487 @@ import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
 import com.obzen.tagworks.TagWorks
 import com.obzen.tagworks.TagWorksConfig
-import com.obzen.tagworks.data.DataBundle
-import com.obzen.tagworks.data.Dimension
-import com.obzen.tagworks.data.DimensionType
-import com.obzen.tagworks.util.Logger
-import com.obzen.tagworks.util.Logger.Companion.d
-import com.obzen.tagworks.util.WebAppInterface.Companion.MessageHandlerName
+import com.obzen.tagworks.common.Logger
+import com.obzen.tagworks.event.data.DataBundle
+import com.obzen.tagworks.event.data.Dimension
+import com.obzen.tagworks.event.data.DimensionType
+import com.obzen.tagworks.web.WebAppInterface
+import com.obzen.tagworks.web.WebAppInterface.Companion.MessageHandlerName
+import com.obzen.tagworks.web.WebAppOnCmsInterface
 import org.json.JSONArray
 import org.json.JSONObject
 
 class TagWorksModule(reactContext: ReactApplicationContext):ReactContextBaseJavaModule(reactContext) {
 
-  /**
-   * js에서 호출하는 TagWorksModule 네이밍
-   */
-  override fun getName(): String {
-    return "TagWorksModule"
-  }
-
-  /**
-   * config SDK 초기화 함수
-   */
-  @ReactMethod
-  fun initializeTagWorks(
-    siteId:String,
-    baseUrl:String,
-    isUseIntervals:Boolean,
-    dispatchInterval:Double,
-    sessionTimeout:Double,
-    isManualDispatch:Boolean,
-    appVersion:String?,
-    appName:String?,
-    isUseDynamicParameter:Boolean
-  ) {
-    val config = TagWorksConfig.Builder()
-      .setSiteId(siteId)
-      .setBaseUrl(baseUrl)
-      .setDispatchInterval(dispatchInterval.toLong())
-      .setSessionTimeOut(sessionTimeout.toLong()*1000)
-      .setAppVersion(appVersion)
-      .setAppName(appName)
-      .setManualDispatch(isManualDispatch)
-      .setIsUseIntervals(isUseIntervals)
-      .setIsUseDynamicParameter(isUseDynamicParameter)
-      .build()
-
-    TagWorks.initializeSdk(reactApplicationContext, config)
-
-  }
-
-
-  /**
-   * siteId, baseUrl SDK 초기화 함수
-   */
-  @ReactMethod
-  fun initTagWorksWithSiteIdAndBaseUrl(siteId: String,baseUrl: String) {
-    TagWorks.initializeSdk(reactApplicationContext,siteId,baseUrl)
-  }
-
-
-  @ReactMethod
-  fun setLogLevel(level:Int) {
-    TagWorks.getInstance().setLogLevel(level)
-  }
-
-  @ReactMethod
-  fun setOptOut(isOptOut:Boolean) {
-    TagWorks.getInstance().optOut = isOptOut
-  }
-
-  @ReactMethod
-  fun setUserId(userId:String) {
-    TagWorks.getInstance().userId = userId
-  }
-
-  @ReactMethod
-  fun setVisitorId(visitorId:String) {
-    TagWorks.getInstance().visitorId =visitorId
-  }
-
-  @ReactMethod
-  fun setAdId(adId:String) {
-    TagWorks.getInstance().adId = adId
-  }
-
-  @ReactMethod
-  fun getAdId(callback: Callback) {
-    try {
-      callback.invoke(TagWorks.getInstance().adId)
-    }catch (e:Exception) {
-      callback.invoke("error :",e.message)
-    }
-  }
-
-  @ReactMethod
-  fun getVisitorId(callback: Callback) {
-    try {
-      callback.invoke(TagWorks.getInstance().visitorId)
-    }catch (e:Exception) {
-      callback.invoke("error :",e.message)
-    }
-  }
-
-  @ReactMethod
-  fun getSiteId(callback: Callback) {
-    try {
-      callback.invoke(TagWorks.getInstance().siteId)
-    } catch (e:Exception) {
-      callback.invoke("error :",e.message)
-    }
-  }
-
-
-  /**
-   * 공용 dimension 설정
-   */
-
-
-  @ReactMethod
-  fun setCommonDimensionWithDouble(index: Int,numValue:Double) {
-    TagWorks.getInstance().setCommonDimension(index,numValue)
-  }
-
-  @ReactMethod
-  fun setCommonDimensionWithString(index: Int,value:String) {
-    TagWorks.getInstance().setCommonDimension(index,value)
-  }
-
-  @ReactMethod
-  fun setDynamicCommonDimensionWithDouble(key:String, numValue: Double) {
-    TagWorks.getInstance().setDynamicCommonDimension(key,numValue)
-  }
-
-  @ReactMethod
-  fun setDynamicCommonDimensionWithString(key: String, value:String) {
-    TagWorks.getInstance().setDynamicCommonDimension(key,value)
-  }
-
-
-  @ReactMethod
-  fun getCommonDimensions(callback: Callback) {
-
-    try {
-      val cDimensions = TagWorks.getInstance().getCommonDimensions()
-      val cDynamicDimensions = TagWorks.getInstance().getDynamicCommonDimensions()
+    /**
+     * js에서 호출하는 TagWorksModule 네이밍
+     */
+    override fun getName(): String {
+        return "TagWorksModule"
+    }
 
-      val generalDimensions = JSONObject()
-      val factDimensions = JSONObject()
+    /**
+     * config SDK 초기화 함수
+     */
+    @ReactMethod
+    fun initializeTagWorks(
+        siteId:String,
+        baseUrl:String,
+        isUseIntervals:Boolean,
+        dispatchInterval:Double,
+        sessionTimeout:Double,
+        isManualDispatch:Boolean,
+        appVersion:String?,
+        appName:String?,
+        isUseDynamicParameter:Boolean,
+        deeplinkServerUrl: String
+    ) {
+        val config = TagWorksConfig.Builder()
+            .setSiteId(siteId)
+            .setBaseUrl(baseUrl)
+            .setDispatchInterval(dispatchInterval.toLong())
+            .setSessionTimeOut(sessionTimeout.toLong()*1000)
+            .setAppVersion(appVersion)
+            .setAppName(appName)
+            .setManualDispatch(isManualDispatch)
+            .setIsUseIntervals(isUseIntervals)
+            .setIsUseDynamicParameter(isUseDynamicParameter)
+            .setDeeplinkServerUrl(deeplinkServerUrl)
+            .build()
+
+        TagWorks.initializeSdk(reactApplicationContext, config)
 
-      cDimensions.forEach { dimension ->
-        when (dimension.type) {
-          DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.index.toString(),dimension.value)
-          DimensionType.FACT_TYPE -> factDimensions.put(dimension.index.toString(),dimension.numValue)
-        }
-      }
+    }
 
-      cDynamicDimensions.forEach { dimension ->
-        when (dimension.type) {
-          DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.key,dimension.value)
-          DimensionType.FACT_TYPE -> factDimensions.put(dimension.key,dimension.numValue)
-        }
-      }
 
-      val generalWrapper = JSONObject().apply {
-        put("General", generalDimensions)
-      }
+    /**
+     * siteId, baseUrl SDK 초기화 함수
+     */
+    @ReactMethod
+    fun initTagWorksWithSiteIdAndBaseUrl(siteId: String,baseUrl: String) {
+        TagWorks.initializeSdk(reactApplicationContext,siteId,baseUrl)
+    }
 
-      val factWrapper = JSONObject().apply {
-        put("Fact", factDimensions)
-      }
 
-      val dimensionsArray = JSONArray().apply {
-        put(generalWrapper)
-        put(factWrapper)
-      }
+    @ReactMethod
+    fun setLogLevel(level:Int) {
+        TagWorks.getInstance().setLogLevel(level)
+    }
 
-      val result = JSONObject().apply {
-        put("Dimensions", dimensionsArray)
-      }
+    @ReactMethod
+    fun setOptOut(isOptOut:Boolean) {
+        TagWorks.getInstance().optOut = isOptOut
+    }
 
-      val jsonString = result.toString(4)
+    @ReactMethod
+    fun setUserId(userId:String) {
+        TagWorks.getInstance().userId = userId
+    }
 
-      callback.invoke(jsonString)
-    } catch (e: Exception) {
-      // 오류 처리
-      e.printStackTrace()
-      callback.invoke(null)
+    @ReactMethod
+    fun setVisitorId(visitorId:String) {
+        TagWorks.getInstance().visitorId =visitorId
     }
 
+    @ReactMethod
+    fun setAutoTrackingPage(autoTrackingPage: Boolean) {
+        TagWorks.getInstance().autoTrackingPage = autoTrackingPage
+    }
 
-  }
+    @ReactMethod
+    fun setAdId(adId:String) {
+        TagWorks.getInstance().adId = adId
+    }
 
-  @ReactMethod
-  fun getDynamicCommonDimensions(callback: Callback) {
-    try {
-      val cDimensions = TagWorks.getInstance().getCommonDimensions()
-      val cDynamicDimensions = TagWorks.getInstance().getDynamicCommonDimensions()
+    @ReactMethod
+    fun getAdId(callback: Callback) {
+        try {
+            callback.invoke(TagWorks.getInstance().adId)
+        }catch (e:Exception) {
+            callback.invoke("error :",e.message)
+        }
+    }
 
-      val generalDimensions = JSONObject()
-      val factDimensions = JSONObject()
+    @ReactMethod
+    fun getVisitorId(callback: Callback) {
+        try {
+            callback.invoke(TagWorks.getInstance().visitorId)
+        }catch (e:Exception) {
+            callback.invoke("error :",e.message)
+        }
+    }
 
-      cDimensions.forEach { dimension ->
-        when (dimension.type) {
-          DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.index.toString(),dimension.value)
-          DimensionType.FACT_TYPE -> factDimensions.put(dimension.index.toString(),dimension.numValue)
+    @ReactMethod
+    fun getSiteId(callback: Callback) {
+        try {
+            callback.invoke(TagWorks.getInstance().siteId)
+        } catch (e:Exception) {
+            callback.invoke("error :",e.message)
         }
-      }
+    }
 
-      cDynamicDimensions.forEach { dimension ->
-        when (dimension.type) {
-          DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.key,dimension.value)
-          DimensionType.FACT_TYPE -> factDimensions.put(dimension.key,dimension.numValue)
+    @ReactMethod
+    fun getDeeplinkServerUrl(callback: Callback) {
+        try {
+            callback.invoke(TagWorks.getInstance().deeplinkServerUrl)
+        } catch (e:Exception) {
+            callback.invoke("error :",e.message)
         }
-      }
-
-      val generalWrapper = JSONObject().apply {
-        put("General", generalDimensions)
-      }
-
-      val factWrapper = JSONObject().apply {
-        put("Fact", factDimensions)
-      }
-
-      val dimensionsArray = JSONArray().apply {
-        put(generalWrapper)
-        put(factWrapper)
-      }
-
-      val result = JSONObject().apply {
-        put("Dimensions", dimensionsArray)
-      }
-
-      val jsonString = result.toString(4)
-
-      callback.invoke(jsonString)
-    } catch (e: Exception) {
-      // 오류 처리
-      e.printStackTrace()
-      callback.invoke(null)
-    }
-  }
-
-  @ReactMethod
-  fun getCommonDimensionsOfArrayIndex(callback: Callback) {
-    try {
-      val cDimensions = TagWorks.getInstance().getCommonDimensions()
-      val dimensions = JSONArray()
-
-      cDimensions.forEach { dimension ->
-        val dimensionObject = JSONObject()
-        if (dimension.type == DimensionType.FACT_TYPE) {
-          dimensionObject.put("Fact_${dimension.index}", dimension.numValue)
-        } else if (dimension.type == DimensionType.GENERAL_TYPE) {
-          dimensionObject.put("General_${dimension.index}", dimension.value)
+    }
+
+    @ReactMethod
+    fun enableTestTool(isTestMode: Boolean) {
+        val currentActivity = reactApplicationContext.currentActivity  ?: return
+        if (isTestMode) TagWorks.getInstance().enableTestTool(currentActivity)
+    }
+
+    @ReactMethod
+    fun excludeAutoTrackingPages(pageNames: ReadableArray?) {
+        if (pageNames == null) return
+
+        val classList = mutableListOf<Class<*>>()
+
+        for (i in 0 until pageNames.size()) {
+            val name = pageNames.getString(i)
+
+            try {
+                val clazz = Class.forName(name)
+                classList.add(clazz)
+            } catch (e: ClassNotFoundException) {
+                e.printStackTrace()
+            }
         }
-        dimensions.put(dimensionObject)
-      }
-      val jsonString = dimensions.toString(4)
-      callback.invoke(jsonString)
-    }catch (e:Exception) {
-      callback.invoke(null)
-    }
-  }
-
-  @ReactMethod
-  fun getCommonDimensionWithString(index: Int,callback: Callback) {
-    val mCommonDimension = TagWorks.getInstance().getCommonDimension(DimensionType.GENERAL_TYPE,index)
-    if (mCommonDimension != null) callback.invoke(mCommonDimension.value)
-    else callback.invoke(null)
-  }
-
-  @ReactMethod
-  fun getCommonDimensionWithDouble(index: Int,callback: Callback) {
-    val mCommonDimension = TagWorks.getInstance().getCommonDimension(DimensionType.FACT_TYPE,index)
-    if (mCommonDimension != null) callback.invoke(mCommonDimension.numValue)
-    else callback.invoke(null)
-  }
-
-  @ReactMethod
-  fun getDynamicCommonDimension(key: String, callback: Callback) {
-    val mCommonDimension = TagWorks.getInstance().getDynamicCommonDimension(key)
-    if(mCommonDimension != null) callback.invoke(if(mCommonDimension.type==DimensionType.GENERAL_TYPE) mCommonDimension.value else mCommonDimension.numValue)
-    else callback.invoke(null)
-  }
-
-  @ReactMethod
-  fun getDynamicCommonDimensionsOfArrayIndex(callback: Callback) {
-    try {
-      val cDynamicDimensions = TagWorks.getInstance().getDynamicCommonDimensions()
-      val dimensions = JSONArray()
-
-      cDynamicDimensions.forEach { dimension ->
-        val dimensionObject = JSONObject()
-        if (dimension.type == DimensionType.GENERAL_TYPE) {
-          dimensionObject.put(dimension.key,dimension.value)
-        }else{
-          dimensionObject.put(dimension.key,dimension.numValue)
+
+        if (classList.isNotEmpty()) {
+            TagWorks.getInstance().excludeAutoTrackingPages(classList)
         }
-        dimensions.put(dimensionObject)
-      }
-      val jsonString = dimensions.toString(4)
-      callback.invoke(jsonString)
-    }catch (e:Exception) {
-      callback.invoke(null)
     }
-  }
 
 
-  @ReactMethod
-  fun removeCommonDimensionInGeneralType(index: Int) {
-    TagWorks.getInstance().removeCommonDimension(DimensionType.GENERAL_TYPE,index)
-  }
+    /**
+     * 공용 dimension 설정
+     */
 
-  @ReactMethod
-  fun removeCommonDimensionInFactType(index: Int) {
-    TagWorks.getInstance().removeCommonDimension(DimensionType.FACT_TYPE,index)
-  }
 
-  @ReactMethod
-  fun removeDynamicCommonDimension(key: String) {
-    TagWorks.getInstance().removeDynamicCommonDimension(key)
-  }
+    @ReactMethod
+    fun setCommonDimensionWithDouble(index: Int,numValue:Double) {
+        TagWorks.getInstance().setCommonDimension(index,numValue)
+    }
 
-  @ReactMethod
-  fun removeCommonDimensionWithArrayIndex(index:Int) {
-    TagWorks.getInstance().removeCommonDimensionWithArrayIndex(index)
-  }
+    @ReactMethod
+    fun setCommonDimensionWithString(index: Int,value:String) {
+        TagWorks.getInstance().setCommonDimension(index,value)
+    }
 
-  @ReactMethod
-  fun removeDynamicCommonDimensionWithArrayIndex(index: Int) {
-    TagWorks.getInstance().removeDynamicCommonDimensionWithArrayIndex(index)
-  }
+    @ReactMethod
+    fun setDynamicCommonDimensionWithDouble(key:String, numValue: Double) {
+        TagWorks.getInstance().setDynamicCommonDimension(key,numValue)
+    }
 
-  @ReactMethod
-  fun removeAllCommonDimension() {
-    TagWorks.getInstance().removeAllCommonDimension()
-  }
+    @ReactMethod
+    fun setDynamicCommonDimensionWithString(key: String, value:String) {
+        TagWorks.getInstance().setDynamicCommonDimension(key,value)
+    }
+
+
+    @ReactMethod
+    fun getCommonDimensions(callback: Callback) {
 
-  @ReactMethod
-  fun removeAllDynamicCommonDimension() {
-    TagWorks.getInstance().removeAllCommonDimension()
-  }
+        try {
+            val cDimensions = TagWorks.getInstance().getCommonDimensions()
+            val cDynamicDimensions = TagWorks.getInstance().getDynamicCommonDimensions()
 
-  @ReactMethod
-  fun dispatch(callback: Callback) {
-    val result = TagWorks.getInstance().dispatch()
-    callback.invoke(result)
-  }
+            val generalDimensions = JSONObject()
+            val factDimensions = JSONObject()
 
-  @ReactMethod
-  fun sendReferrerEventWithOpenUrlString(openUrl: String) {
-    TagWorks.getInstance().sendReferrerEvent(openUrl)
-  }
+            cDimensions.forEach { dimension ->
+                when (dimension.type) {
+                    DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.index.toString(),dimension.value)
+                    DimensionType.FACT_TYPE -> factDimensions.put(dimension.index.toString(),dimension.numValue)
+                }
+            }
 
+            cDynamicDimensions.forEach { dimension ->
+                when (dimension.type) {
+                    DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.key,dimension.value)
+                    DimensionType.FACT_TYPE -> factDimensions.put(dimension.key,dimension.numValue)
+                }
+            }
 
-  @ReactMethod
-  fun logEvent(eventType:String,data:ReadableMap,callback: Callback) {
+            val result = JSONObject().apply {
+                put("General", generalDimensions)
+                put("Fact", factDimensions)
+            }
+
+            val jsonString = result.toString(4)
+
+            callback.invoke(jsonString)
+        } catch (e: Exception) {
+            // 오류 처리
+            e.printStackTrace()
+            callback.invoke(null)
+        }
 
-    val bundle = DataBundle()
 
-    val dataBundleMap = data.getMap("dataBundle")
-    dataBundleMap?.let {
-      val keySetIterator = it.keySetIterator()
-      while (keySetIterator.hasNextKey()) {
-        val key = keySetIterator.nextKey()
-        bundle.putString(key,it.getString(key))
-      }
     }
 
-    val dimensionsArray = data.getArray("dimensions")
-    dimensionsArray?.let {
-      for (i in 0 until it.size()) {
-        val dimensionMap = it.getMap(i)
+    @ReactMethod
+    fun getDynamicCommonDimensions(callback: Callback) {
+        try {
+            val cDimensions = TagWorks.getInstance().getCommonDimensions()
+            val cDynamicDimensions = TagWorks.getInstance().getDynamicCommonDimensions()
+
+            val generalDimensions = JSONObject()
+            val factDimensions = JSONObject()
+
+            cDimensions.forEach { dimension ->
+                when (dimension.type) {
+                    DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.index.toString(),dimension.value)
+                    DimensionType.FACT_TYPE -> factDimensions.put(dimension.index.toString(),dimension.numValue)
+                }
+            }
+
+            cDynamicDimensions.forEach { dimension ->
+                when (dimension.type) {
+                    DimensionType.GENERAL_TYPE -> generalDimensions.put(dimension.key,dimension.value)
+                    DimensionType.FACT_TYPE -> factDimensions.put(dimension.key,dimension.numValue)
+                }
+            }
+
+            val result = JSONObject().apply {
+                put("General", generalDimensions)
+                put("Fact", factDimensions)
+            }
+
+            val jsonString = result.toString(4)
+            callback.invoke(jsonString)
+        } catch (e: Exception) {
+            // 오류 처리
+            e.printStackTrace()
+            callback.invoke(null)
+        }
+    }
 
-        val type = dimensionMap.getString("type")
-        val index = if (dimensionMap.hasKey("index")) dimensionMap.getInt("index") else -1
-        val key = if(dimensionMap.hasKey("key")) dimensionMap.getString("key") else index.toString()
-        val value = if(dimensionMap.hasKey("value")) dimensionMap.getString("value") else ""
-        val numValue = if(dimensionMap.hasKey("numValue")) dimensionMap.getDouble("numValue") else 0.0
+    @ReactMethod
+    fun getCommonDimensionsOfArrayIndex(callback: Callback) {
+        try {
+            val cDimensions = TagWorks.getInstance().getCommonDimensions()
+            val dimensions = JSONArray()
+
+            cDimensions.forEach { dimension ->
+                val dimensionObject = JSONObject()
+                if (dimension.type == DimensionType.FACT_TYPE) {
+                    dimensionObject.put("Fact_${dimension.index}", dimension.numValue)
+                } else if (dimension.type == DimensionType.GENERAL_TYPE) {
+                    dimensionObject.put("General_${dimension.index}", dimension.value)
+                }
+                dimensions.put(dimensionObject)
+            }
+            val jsonString = dimensions.toString(4)
+            callback.invoke(jsonString)
+        }catch (e:Exception) {
+            callback.invoke(null)
+        }
+    }
 
-        bundle.setDimension(Dimension(DimensionType.valueOf(type!!),index,key!!,value!!,numValue))
-      }
+    @ReactMethod
+    fun getCommonDimensionWithString(index: Int,callback: Callback) {
+        val mCommonDimension = TagWorks.getInstance().getCommonDimension(DimensionType.GENERAL_TYPE,index)
+        if (mCommonDimension != null) callback.invoke(mCommonDimension.value)
+        else callback.invoke(null)
     }
 
-    Log.d(TAG, "logEvent: ${bundle.dataBundle} + ${bundle.dimensions}")
-    try {
+    @ReactMethod
+    fun getCommonDimensionWithDouble(index: Int,callback: Callback) {
+        val mCommonDimension = TagWorks.getInstance().getCommonDimension(DimensionType.FACT_TYPE,index)
+        if (mCommonDimension != null) callback.invoke(mCommonDimension.numValue)
+        else callback.invoke(null)
+    }
 
-      val result = TagWorks.getInstance().logEvent(eventType, bundle)
-      callback.invoke(result)
+    @ReactMethod
+    fun getDynamicCommonDimension(key: String, callback: Callback) {
+        val mCommonDimension = TagWorks.getInstance().getDynamicCommonDimension(key)
+        if(mCommonDimension != null) callback.invoke(if(mCommonDimension.type== DimensionType.GENERAL_TYPE) mCommonDimension.value else mCommonDimension.numValue)
+        else callback.invoke(null)
+    }
 
-    }catch (e:Exception) {
-      Log.d(TAG, "log event error: ${e.message}")
+    @ReactMethod
+    fun getDynamicCommonDimensionsOfArrayIndex(callback: Callback) {
+        try {
+            val cDynamicDimensions = TagWorks.getInstance().getDynamicCommonDimensions()
+            val dimensions = JSONArray()
+
+            cDynamicDimensions.forEach { dimension ->
+                val dimensionObject = JSONObject()
+                if (dimension.type == DimensionType.GENERAL_TYPE) {
+                    dimensionObject.put(dimension.key,dimension.value)
+                }else{
+                    dimensionObject.put(dimension.key,dimension.numValue)
+                }
+                dimensions.put(dimensionObject)
+            }
+            val jsonString = dimensions.toString(4)
+            callback.invoke(jsonString)
+        }catch (e:Exception) {
+            callback.invoke(null)
+        }
     }
 
 
-  }
+    @ReactMethod
+    fun removeCommonDimensionInGeneralType(index: Int) {
+        TagWorks.getInstance().removeCommonDimension(DimensionType.GENERAL_TYPE,index)
+    }
 
-  @ReactMethod
-  fun webInterfaceDidReceive(jsonEventString: String) {
-    d(MessageHandlerName,jsonEventString)
-    try {
-      val jsonObj = JSONObject(jsonEventString)
+    @ReactMethod
+    fun removeCommonDimensionInFactType(index: Int) {
+        TagWorks.getInstance().removeCommonDimension(DimensionType.FACT_TYPE,index)
+    }
 
-      val sender = if (jsonObj.isNull("e_a")) null else jsonObj.getString("e_a")
-      if ( sender == "obzen") {
+    @ReactMethod
+    fun removeDynamicCommonDimension(key: String) {
+        TagWorks.getInstance().removeDynamicCommonDimension(key)
+    }
+
+    @ReactMethod
+    fun removeCommonDimensionWithArrayIndex(index:Int) {
+        TagWorks.getInstance().removeCommonDimensionWithArrayIndex(index)
+    }
 
-        val idSite = if (jsonObj.isNull("idsite")) null else jsonObj.getString("idsite")
-        val url = if (jsonObj.isNull("url")) null else jsonObj.getString("url")
-        val urlref = if (jsonObj.isNull("urlref")) null else jsonObj.getString("urlref")
-        var eventCategory = if (jsonObj.isNull("e_c")) null else jsonObj.getString("e_c")
+    @ReactMethod
+    fun removeDynamicCommonDimensionWithArrayIndex(index: Int) {
+        TagWorks.getInstance().removeDynamicCommonDimensionWithArrayIndex(index)
+    }
+
+    @ReactMethod
+    fun removeAllCommonDimension() {
+        TagWorks.getInstance().removeAllCommonDimension()
+    }
 
-        if (eventCategory != null) {
-          eventCategory =
-            eventCategory.replace("{{vstor_id}}", TagWorks.getInstance().visitorId)
+    @ReactMethod
+    fun removeAllDynamicCommonDimension() {
+        TagWorks.getInstance().removeAllCommonDimension()
+    }
+
+    @ReactMethod
+    fun dispatch(callback: Callback) {
+        val result = TagWorks.getInstance().dispatch()
+        callback.invoke(result)
+    }
+
+    @ReactMethod
+    fun sendReferrerEventWithOpenUrlString(openUrl: String) {
+        TagWorks.getInstance().sendReferrerEvent(openUrl)
+    }
+
+
+    @ReactMethod
+    fun logEvent(eventType:String,data:ReadableMap,callback: Callback) {
+
+        val bundle = DataBundle()
+
+        val dataBundleMap = data.getMap("dataBundle")
+        dataBundleMap?.let {
+            val keySetIterator = it.keySetIterator()
+            while (keySetIterator.hasNextKey()) {
+                val key = keySetIterator.nextKey()
+                bundle.putString(key,it.getString(key))
+            }
         }
 
-        if (idSite != null && idSite != TagWorks.getInstance().siteId) {
-          Logger.i(MessageHandlerName, "WebView siteid is not equal App siteid!!")
+        val dimensionsArray = data.getArray("dimensions")
+        dimensionsArray?.let {
+            for (i in 0 until it.size()) {
+                val dimensionMap = it.getMap(i)
+
+                val type = dimensionMap?.getString("type")
+                val index = if (dimensionMap?.hasKey("index") == true) dimensionMap?.getInt("index") else -1
+                val key = if(dimensionMap?.hasKey("key") == true) dimensionMap?.getString("key") else index.toString()
+                val value = if(dimensionMap?.hasKey("value") == true) dimensionMap?.getString("value") else ""
+                val numValue = if(dimensionMap?.hasKey("numValue") == true) dimensionMap?.getDouble("numValue") else 0.0
+
+                bundle.setDimension(Dimension(DimensionType.valueOf(type!!),index!!,key!!,value!!,numValue!!))
+            }
         }
 
-        TagWorks.getInstance().webInterfaceLogEventPush(
-          idSite, url, urlref, eventCategory
-        )
-      }
+        Log.d(TAG, "logEvent: ${bundle.dataBundle} + ${bundle.dimensions}")
+        try {
+
+            val result = TagWorks.getInstance().logEvent(eventType, bundle)
+            callback.invoke(result)
+
+        }catch (e:Exception) {
+            Log.d(TAG, "log event error: ${e.message}")
+        }
 
-    } catch (t: Throwable) {
-      Logger.e(MessageHandlerName, "Could not parse malformed JSON: \"$jsonEventString\"");
+
+    }
+
+    @ReactMethod
+    fun isInitialize(callback: Callback) {
+        try {
+            callback.invoke(TagWorks.getInstance().isInitialize.toString())
+        } catch (e:Exception) {
+            callback.invoke("error :",e.message)
+        }
+    }
+
+    @ReactMethod
+    fun saveErrorReport(errorType: String, errorMessage: String) {
+        TagWorks.getInstance().saveErrorReport(errorType, errorMessage)
     }
-  }
 
-  override fun getConstants(): MutableMap<String, Any> {
-    return mutableMapOf(
-      "EVENT_TYPE_PAGE" to TagWorks.EVENT_TYPE_PAGE,
-      "EVENT_TYPE_USER_EVENT" to TagWorks.EVENT_TYPE_USER_EVENT,
-    )
-  }
+    @ReactMethod
+    fun webInterfaceDidReceive(jsonEventString: String) {
+        Logger.d(TagWorks.getInstance().tag,jsonEventString)
+        try {
+
+            val jsonObj = JSONObject(jsonEventString)
+            val sender = if (jsonObj.isNull("e_a")) null else jsonObj.getString("e_a")
+
+            if ( sender == "obzen") {
+
+                WebAppInterface().TagWorksWebEvent(jsonEventString)
+
+            } else if ( sender == "obzenoncms") {
+
+                val currentActivity = reactApplicationContext.currentActivity  ?: return
 
-  companion object {
-    const val TAG = "TagWorksModule"
-  }
+                if (currentActivity == null) {
+                    Logger.d(TagWorks.getInstance().tag, "currentActivity is null; cannot show popup yet")
+                    return
+                }
+                val hasCommand = jsonObj.has("command")
+
+                UiThreadUtil.runOnUiThread {
+                    val onCms = WebAppOnCmsInterface(currentActivity)
+                    if (hasCommand) {
+                        onCms.commandPopup(jsonEventString)
+                    } else {
+                        onCms.showPopup(jsonEventString)
+                    }
+                }
+
+            }
+
+        } catch (t: Throwable) {
+            Logger.e(MessageHandlerName, "Could not parse malformed JSON: \"$jsonEventString\"");
+        }
+    }
+
+    override fun getConstants(): MutableMap<String, Any> {
+        return mutableMapOf(
+            "EVENT_TYPE_PAGE" to TagWorks.EVENT_TYPE_PAGE,
+            "EVENT_TYPE_USER_EVENT" to TagWorks.EVENT_TYPE_USER_EVENT,
+        )
+    }
+
+    companion object {
+        const val TAG = "TagWorksModule"
+    }
 }