tagworks-sdk-v1-react 1.1.20 → 1.1.22

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

@@ -6,421 +6,395 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.obzen.tagworks.TagWorks
-import com.obzen.tagworks.data.DataBundle
-import com.obzen.tagworks.data.DimensionType
-import com.obzen.tagworks.util.Logger
+import com.obzen.tagworks.event.data.DataBundle
+import com.obzen.tagworks.event.data.DimensionType
 import org.json.JSONArray
 import org.json.JSONObject
 
 class DataBundleModule(context: ReactApplicationContext):ReactContextBaseJavaModule(context) {
 
-  private var eventData= DataBundle()
-
-  override fun getName(): String {
-    return "DataBundleModule"
-  }
-
-  /**
-   * DataBundle 초기화 함수
-   */
-  @ReactMethod
-  override fun initialize() {
-    super.initialize()
-    eventData.dataBundle.clear()
-    eventData.dimensions.clear()
-    eventData.dynamicDimensions.clear()
-  }
-
-  @ReactMethod
-  fun initDataBundle(jsonString: String?) {
-    initialize()
-    Logger.d(TAG, "DataBundle initialize from : $jsonString")
-
-    try {
-      val jsonObject = JSONObject(jsonString)
-
-      val dataDictionary = jsonObject.optJSONObject("dataDictionary")
-      if (dataDictionary != null) {
-        val keys = dataDictionary.keys()
-        while (keys.hasNext()) {
-          val key = keys.next()
-          val value = dataDictionary.getString(key)
-          eventData.dataBundle.putString(key,value)
-        }
-      }
-
-      val eventDimensions = jsonObject.optJSONArray("eventDimensions")
-      if (eventDimensions != null) {
-        for (i in 0 until eventDimensions.length()) {
-          val dimensionObject = eventDimensions.getJSONObject(i)
-
-          val general = dimensionObject.optJSONObject("General")
-          if (general != null) {
-            val keys = general.keys()
-            while (keys.hasNext()) {
-              val key = keys.next()
-              val value = general.getString(key)
-              if(TagWorks.getInstance().isUseDynamicParameter) {
-                eventData.setDynamicDimension(key,value)
-              } else {
-                eventData.setDimension(key.toInt(),value)
-              }
+    private var eventData= DataBundle()
+
+    override fun getName(): String {
+        return "DataBundleModule"
+    }
+
+    /**
+     * DataBundle 초기화 함수
+     */
+    @ReactMethod
+    override fun initialize() {
+        super.initialize()
+        eventData.dataBundle.clear()
+        eventData.dimensions.clear()
+        eventData.dynamicDimensions.clear()
+    }
+
+    @ReactMethod
+    fun initDataBundle(jsonString: String?) {
+        initialize()
+
+        try {
+            val jsonObject = JSONObject(jsonString)
+
+            val dataDictionary = jsonObject.optJSONObject("dataDictionary")
+            if (dataDictionary != null) {
+                val keys = dataDictionary.keys()
+                while (keys.hasNext()) {
+                    val key = keys.next()
+                    val value = dataDictionary.getString(key)
+                    eventData.dataBundle.putString(key,value)
+                }
             }
-          }
-
-          val fact = dimensionObject.optJSONObject("Fact")
-          if (fact != null) {
-            val keys = fact.keys()
-            while (keys.hasNext()) {
-              val key = keys.next()
-              val value = fact.getString(key)
-              if(TagWorks.getInstance().isUseDynamicParameter) {
-                eventData.setDynamicDimension(key,value.toDouble())
-              } else {
-                eventData.setDimension(key.toInt(),value.toDouble())
-              }
+
+            val eventDimensions = jsonObject.optJSONArray("eventDimensions")
+            if (eventDimensions != null) {
+                for (i in 0 until eventDimensions.length()) {
+                    val dimensionObject = eventDimensions.getJSONObject(i)
+
+                    val general = dimensionObject.optJSONObject("General")
+                    if (general != null) {
+                        val keys = general.keys()
+                        while (keys.hasNext()) {
+                            val key = keys.next()
+                            val value = general.getString(key)
+                            if(TagWorks.getInstance().isUseDynamicParameter) {
+                                eventData.setDynamicDimension(key,value)
+                            } else {
+                                eventData.setDimension(key.toInt(),value)
+                            }
+                        }
+                    }
+
+                    val fact = dimensionObject.optJSONObject("Fact")
+                    if (fact != null) {
+                        val keys = fact.keys()
+                        while (keys.hasNext()) {
+                            val key = keys.next()
+                            val value = fact.getString(key)
+                            if(TagWorks.getInstance().isUseDynamicParameter) {
+                                eventData.setDynamicDimension(key,value.toDouble())
+                            } else {
+                                eventData.setDimension(key.toInt(),value.toDouble())
+                            }
+                        }
+                    }
+
+                }
             }
-          }
+        }catch (e: Exception) {
+            e.printStackTrace()
+            println("Error parsing JSON: ${e.message}")
+        }
+
+    }
+    /**
+     * DataBundle putString() 함수 - 개별
+     */
+    @ReactMethod
+    fun putString(key:String,value:String){
+        eventData.dataBundle.putString(key,value)
+    }
+
+
+    @ReactMethod
+    fun getDataBundle(callback: Callback) {
+        val mDataBundle = Arguments.createMap()
+
+        val dimensionsArray  = Arguments.createArray()
+
+        for (dimension in eventData.dimensions) {
+            val dimensionMap = Arguments.createMap()
+            dimensionMap.putInt("index",dimension.index)
+            dimensionMap.putString("type",dimension.type.name)
+            if (dimension.type == DimensionType.GENERAL_TYPE) dimensionMap.putString("value",dimension.value)
+            else dimensionMap.putDouble("numValue",dimension.numValue)
+
+            dimensionsArray.pushMap(dimensionMap)
+        }
+
+        for (dimension in eventData.dynamicDimensions) {
+            val dimensionMap = Arguments.createMap()
+            dimensionMap.putString("key",dimension.key)
+            dimensionMap.putString("type",dimension.type.name)
+            if(dimension.type == DimensionType.GENERAL_TYPE) dimensionMap.putString("value",dimension.value)
+            else dimensionMap.putDouble("numValue",dimension.numValue)
 
+            dimensionsArray.pushMap(dimensionMap)
         }
-      }
-    }catch (e: Exception) {
-      e.printStackTrace()
-      println("Error parsing JSON: ${e.message}")
+
+        mDataBundle.putArray("dimensions", dimensionsArray)
+
+        val bundleMap = Arguments.createMap()
+        for (key in eventData.dataBundle.keySet()) {
+            bundleMap.putString(key, eventData.dataBundle.get(key) as String)
+        }
+        mDataBundle.putMap("dataBundle", bundleMap)
+        callback.invoke(mDataBundle)
     }
 
-  }
-  /**
-   * DataBundle putString() 함수 - 개별
-   */
-  @ReactMethod
-  fun putString(key:String,value:String){
-    eventData.dataBundle.putString(key,value)
-  }
+    /**
+     * dimension 설정
+     */
 
+    @ReactMethod
+    fun putDimensionWithString(index: Int, value: String) {
+        eventData.setDimension(index, value)
+    }
 
-  @ReactMethod
-  fun getDataBundle(callback: Callback) {
-    val mDataBundle = Arguments.createMap()
+    @ReactMethod
+    fun putDimensionWithDouble(index: Int, value: Double) {
+        eventData.setDimension(index, value)
+    }
+
+    @ReactMethod
+    fun putDynamicDimensionWithString(key: String, value: String) {
+        eventData.setDynamicDimension(key, value)
+    }
+
+    @ReactMethod
+    fun putDynamicDimensionWithDouble(key: String, numValue:Double) {
+        eventData.setDynamicDimension(key, numValue)
+    }
 
-    val dimensionsArray  = Arguments.createArray()
 
-    for (dimension in eventData.dimensions) {
-      val dimensionMap = Arguments.createMap()
-      dimensionMap.putInt("index",dimension.index)
-      dimensionMap.putString("type",dimension.type.name)
-      if (dimension.type == DimensionType.GENERAL_TYPE) dimensionMap.putString("value",dimension.value)
-      else dimensionMap.putDouble("numValue",dimension.numValue)
+    @ReactMethod
+    fun getDimensions(callback: Callback) {
+        try {
 
-      dimensionsArray.pushMap(dimensionMap)
+            val generalDimensions = JSONObject()
+            val factDimensions = JSONObject()
+
+            eventData.dimensions.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)
+                }
+            }
+
+            eventData.dynamicDimensions.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)
+        }
     }
 
-    for (dimension in eventData.dynamicDimensions) {
-      val dimensionMap = Arguments.createMap()
-      dimensionMap.putString("key",dimension.key)
-      dimensionMap.putString("type",dimension.type.name)
-      if(dimension.type == DimensionType.GENERAL_TYPE) dimensionMap.putString("value",dimension.value)
-      else dimensionMap.putDouble("numValue",dimension.numValue)
+    @ReactMethod
+    fun getDynamicDimensions(callback: Callback){
+        try {
 
-      dimensionsArray.pushMap(dimensionMap)
+            val generalDimensions = JSONObject()
+            val factDimensions = JSONObject()
+
+            eventData.dimensions.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)
+                }
+            }
+
+            eventData.dynamicDimensions.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)
+        }
     }
 
-    mDataBundle.putArray("dimensions", dimensionsArray)
+    @ReactMethod
+    fun getDimensionsOfArrayIndex(callback: Callback) {
+        try {
+            val dimensions = JSONArray()
+
+            eventData.dimensions.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 bundleMap = Arguments.createMap()
-    for (key in eventData.dataBundle.keySet()) {
-      bundleMap.putString(key, eventData.dataBundle.get(key) as String)
+            val jsonString = dimensions.toString(4)
+            callback.invoke(jsonString)
+        } catch (e:Exception) {
+            callback.invoke(null)
+        }
     }
-    mDataBundle.putMap("dataBundle", bundleMap)
-    callback.invoke(mDataBundle)
-  }
-
-  /**
-   * dimension 설정
-   */
-
-  @ReactMethod
-  fun putDimensionWithString(index: Int, value: String) {
-    eventData.setDimension(index, value)
-  }
-
-  @ReactMethod
-  fun putDimensionWithDouble(index: Int, value: Double) {
-    eventData.setDimension(index, value)
-  }
-
-  @ReactMethod
-  fun putDynamicDimensionWithString(key: String, value: String) {
-    eventData.setDynamicDimension(key, value)
-  }
-
-  @ReactMethod
-  fun putDynamicDimensionWithDouble(key: String, numValue:Double) {
-    eventData.setDynamicDimension(key, numValue)
-  }
-
-
-  @ReactMethod
-  fun getDimensions(callback: Callback) {
-    try {
-
-      val generalDimensions = JSONObject()
-      val factDimensions = JSONObject()
-
-      eventData.dimensions.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 getDimensionWithString(index: Int, callback: Callback) {
+        val mDimension = eventData.dimensions.firstOrNull { it.type == DimensionType.GENERAL_TYPE && it.index == index }
+
+        if (mDimension != null) {
+            callback.invoke(mDimension.value)
+        } else {
+            callback.invoke(null)
         }
-      }
+    }
 
-      eventData.dynamicDimensions.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 getDimensionWithDouble(index: Int, callback: Callback) {
+        val mDimension = eventData.dimensions.firstOrNull { it.type == DimensionType.FACT_TYPE && it.index == index }
+
+        if (mDimension != null) {
+            callback.invoke(mDimension.numValue)
+        } else {
+            callback.invoke(null)
         }
-      }
-
-      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 getDynamicDimensions(callback: Callback){
-    try {
+    @ReactMethod
+    fun getDynamicDimension(key: String,callback: Callback) {
+        val mDimension = eventData.dynamicDimensions.firstOrNull { it.key == key }
+
+        if(mDimension != null) {
+            callback.invoke(if(mDimension.type== DimensionType.GENERAL_TYPE)mDimension.value else mDimension.numValue)
+        } else {
+            callback.invoke(null)
+        }
+    }
 
-      val generalDimensions = JSONObject()
-      val factDimensions = JSONObject()
+    @ReactMethod
+    fun getDynamicDimensionsOfArrayIndex(callback: Callback) {
+        try {
+            val dimensions = JSONArray()
+
+            eventData.dynamicDimensions.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)
+            }
 
-      eventData.dimensions.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)
+            val jsonString = dimensions.toString(4)
+            callback.invoke(jsonString)
+        } catch (e:Exception) {
+            callback.invoke(null)
         }
-      }
+    }
 
-      eventData.dynamicDimensions.forEach { dimension ->
-        when(dimension.type) {
-          DimensionType.GENERAL_TYPE ->generalDimensions.put(dimension.key,dimension.value)
-          DimensionType.FACT_TYPE -> factDimensions.put(dimension.key,dimension.numValue)
+    /**
+     * Dimension 삭제
+     */
+
+    @ReactMethod
+    fun removeDimensionInGeneralType(index: Int) {
+        val iterator = this.eventData.dimensions.iterator()
+        while (iterator.hasNext()) {
+            val dimension = iterator.next()
+            if (dimension.type == DimensionType.GENERAL_TYPE && dimension.index == index) {
+                iterator.remove()
+            }
         }
-      }
-
-      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 getDimensionsOfArrayIndex(callback: Callback) {
-    try {
-      val dimensions = JSONArray()
-
-      eventData.dimensions.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 removeDimensionInFactType(index: Int) {
+        val iterator = this.eventData.dimensions.iterator()
+        while (iterator.hasNext()) {
+            val dimension = iterator.next()
+            if (dimension.type == DimensionType.FACT_TYPE && dimension.index == index) {
+                iterator.remove()
+            }
         }
-        dimensions.put(dimensionObject)
-      }
+    }
 
-      val jsonString = dimensions.toString(4)
-      callback.invoke(jsonString)
-    } catch (e:Exception) {
-      callback.invoke(null)
+    @ReactMethod
+    fun removeDynamicDimension(key: String) {
+        val iterator = this.eventData.dynamicDimensions.iterator()
+        while (iterator.hasNext()) {
+            if (iterator.next().key == key) {
+                iterator.remove()
+            }
+        }
     }
-  }
 
-  @ReactMethod
-  fun getDimensionWithString(index: Int, callback: Callback) {
-    val mDimension = eventData.dimensions.firstOrNull { it.type == DimensionType.GENERAL_TYPE && it.index == index }
+    @ReactMethod
+    fun removeDimensionWithArrayIndex(arrayIndex: Int) {
+        this.eventData.dimensions.removeAt(arrayIndex)
+    }
 
-    if (mDimension != null) {
-      callback.invoke(mDimension.value)
-    } else {
-      callback.invoke(null)
+    @ReactMethod
+    fun removeDynamicDimensionWithArrayIndex(arrayIndex: Int) {
+        this.eventData.dynamicDimensions.removeAt(arrayIndex)
     }
-  }
 
-  @ReactMethod
-  fun getDimensionWithDouble(index: Int, callback: Callback) {
-    val mDimension = eventData.dimensions.firstOrNull { it.type == DimensionType.FACT_TYPE && it.index == index }
+    @ReactMethod
+    fun removeAllDimension() {
+        this.eventData.dimensions.clear()
+        this.eventData.dynamicDimensions.clear()
+    }
 
-    if (mDimension != null) {
-      callback.invoke(mDimension.numValue)
-    } else {
-      callback.invoke(null)
+    @ReactMethod
+    fun removeAllDynamicDimension() {
+        this.eventData.dimensions.clear()
+        this.eventData.dynamicDimensions.clear()
     }
-  }
 
-  @ReactMethod
-  fun getDynamicDimension(key: String,callback: Callback) {
-    val mDimension = eventData.dynamicDimensions.firstOrNull { it.key == key }
 
-    if(mDimension != null) {
-      callback.invoke(if(mDimension.type==DimensionType.GENERAL_TYPE)mDimension.value else mDimension.numValue)
-    } else {
-      callback.invoke(null)
+    @ReactMethod
+    fun isParameterEmpty(callback: Callback) {
+        callback.invoke(this.eventData.dataBundle.isEmpty)
+    }
+
+    @ReactMethod
+    fun isDimensionEmpty(callback: Callback) {
+        callback.invoke(this.eventData.dimensions.isEmpty() && this.eventData.dynamicDimensions.isEmpty())
     }
-  }
-
-  @ReactMethod
-  fun getDynamicDimensionsOfArrayIndex(callback: Callback) {
-    try {
-      val dimensions = JSONArray()
-
-      eventData.dynamicDimensions.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 parameterCount(callback: Callback) {
+        callback.invoke(this.eventData.dataBundle.size())
     }
-  }
-
-  /**
-   * Dimension 삭제
-   */
-
-  @ReactMethod
-  fun removeDimensionInGeneralType(index: Int) {
-    val iterator = this.eventData.dimensions.iterator()
-    while (iterator.hasNext()) {
-      val dimension = iterator.next()
-      if (dimension.type == DimensionType.GENERAL_TYPE && dimension.index == index) {
-        iterator.remove()
-      }
+
+    @ReactMethod
+    fun dimensionCount(callback: Callback) {
+        callback.invoke(this.eventData.dimensions.size+this.eventData.dynamicDimensions.size)
     }
-  }
-
-  @ReactMethod
-  fun removeDimensionInFactType(index: Int) {
-    val iterator = this.eventData.dimensions.iterator()
-    while (iterator.hasNext()) {
-      val dimension = iterator.next()
-      if (dimension.type == DimensionType.FACT_TYPE && dimension.index == index) {
-        iterator.remove()
-      }
+
+
+    override fun getConstants(): MutableMap<String, Any> {
+        return mutableMapOf(
+            "EVENT_TAG_NAME" to DataBundle.EVENT_TAG_NAME,
+            "EVENT_TAG_PARAM_PAGE_PATH" to DataBundle.EVENT_TAG_PARAM_PAGE_PATH,
+            "EVENT_TAG_PARAM_TITLE" to DataBundle.EVENT_TAG_PARAM_TITLE,
+            "EVENT_TAG_PARAM_KEYWORD" to DataBundle.EVENT_TAG_PARAM_KEYWORD,
+            "EVENT_TAG_PARAM_CUSTOM_PATH" to DataBundle.EVENT_TAG_PARAM_CUSTOM_PATH
+        )
     }
-  }
-
-  @ReactMethod
-  fun removeDynamicDimension(key: String) {
-    val iterator = this.eventData.dynamicDimensions.iterator()
-    while (iterator.hasNext()) {
-      if (iterator.next().key == key) {
-        iterator.remove()
-      }
+
+    companion object{
+        const val TAG="DataBundleModule"
     }
-  }
-
-  @ReactMethod
-  fun removeDimensionWithArrayIndex(arrayIndex: Int) {
-    this.eventData.dimensions.removeAt(arrayIndex)
-  }
-
-  @ReactMethod
-  fun removeDynamicDimensionWithArrayIndex(arrayIndex: Int) {
-    this.eventData.dynamicDimensions.removeAt(arrayIndex)
-  }
-
-  @ReactMethod
-  fun removeAllDimension() {
-    this.eventData.dimensions.clear()
-    this.eventData.dynamicDimensions.clear()
-  }
-
-  @ReactMethod
-  fun removeAllDynamicDimension() {
-    this.eventData.dimensions.clear()
-    this.eventData.dynamicDimensions.clear()
-  }
-
-
-  @ReactMethod
-  fun isParameterEmpty(callback: Callback) {
-    callback.invoke(this.eventData.dataBundle.isEmpty)
-  }
-
-  @ReactMethod
-  fun isDimensionEmpty(callback: Callback) {
-    callback.invoke(this.eventData.dimensions.isEmpty() && this.eventData.dynamicDimensions.isEmpty())
-  }
-
-  @ReactMethod
-  fun parameterCount(callback: Callback) {
-    callback.invoke(this.eventData.dataBundle.size())
-  }
-
-  @ReactMethod
-  fun dimensionCount(callback: Callback) {
-    callback.invoke(this.eventData.dimensions.size+this.eventData.dynamicDimensions.size)
-  }
-
-
-  override fun getConstants(): MutableMap<String, Any> {
-    return mutableMapOf(
-      "EVENT_TAG_NAME" to DataBundle.EVENT_TAG_NAME,
-      "EVENT_TAG_PARAM_PAGE_PATH" to DataBundle.EVENT_TAG_PARAM_PAGE_PATH,
-      "EVENT_TAG_PARAM_TITLE" to DataBundle.EVENT_TAG_PARAM_TITLE,
-      "EVENT_TAG_PARAM_KEYWORD" to DataBundle.EVENT_TAG_PARAM_KEYWORD,
-      "EVENT_TAG_PARAM_CUSTOM_PATH" to DataBundle.EVENT_TAG_PARAM_CUSTOM_PATH
-    )
-  }
-
-  companion object{
-    const val TAG="DataBundleModule"
-  }
 }