react-native-quicktracking-analytics-module 2.0.1 → 2.1.0

package/android/src/main/java/com/quicktrackinganalyticsmodule/utils/QTLog.kt

@@ -0,0 +1,119 @@
+package com.quicktrackinganalyticsmodule.utils
+
+import android.util.Log
+
+object QTLog {
+    private var debug = false
+    private var enableLog = false
+    private var disableSDK = false
+    private const val CHUNK_SIZE = 4000
+
+    fun d(tag: String, msg: String) {
+        if (debug && !disableSDK) {
+            info(tag, msg, null)
+        }
+    }
+
+    fun t(msg: String, vararg args: Any) {
+        if (enableLog && !disableSDK) {
+            i("===TEST===", msg, *args)
+        }
+    }
+
+    fun d(tag: String, msg: String, tr: Throwable?) {
+        if (debug && !disableSDK) {
+            info(tag, msg, tr)
+        }
+    }
+
+    fun i(tag: String, msg: String) {
+        if (enableLog && !disableSDK) {
+            info(tag, msg, null)
+        }
+    }
+
+    fun i(tag: String, tr: Throwable) {
+        if (enableLog && !disableSDK) {
+            info(tag, "", tr)
+        }
+    }
+
+    fun i(tag: String, msg: String, tr: Throwable?) {
+        if (enableLog && !disableSDK) {
+            info(tag, msg, tr)
+        }
+    }
+
+    fun i(tag: String, msg: String, vararg args: Any) {
+        if (enableLog && !disableSDK) {
+            info(tag, String.format(msg, *args), null)
+        }
+    }
+
+    private fun info(tag: String, msg: String?, tr: Throwable?) {
+        try {
+            if (msg != null && msg.isNotEmpty()) {
+                val bytes = msg.toByteArray()
+                val length = bytes.size
+                if (length <= CHUNK_SIZE) {
+                    Log.i(tag, msg, tr)
+                } else {
+                    var index = 0
+                    var lastIndexOfLF = 0
+                    //当最后一次剩余值小于 CHUNK_SIZE 时，不需要再截断
+                    while (index < length - CHUNK_SIZE) {
+                        lastIndexOfLF = lastIndexOfLF(bytes, index)
+                        val chunkLength = lastIndexOfLF - index
+                        Log.i(tag, String(bytes, index, chunkLength), null)
+                        index = if (chunkLength < CHUNK_SIZE) {
+                            //跳过换行符
+                            lastIndexOfLF + 1
+                        } else {
+                            lastIndexOfLF
+                        }
+                    }
+                    if (length > index) {
+                        Log.i(tag, String(bytes, index, length - index), tr)
+                    }
+                }
+            } else {
+                Log.i(tag, null, tr)
+            }
+        } catch (e: Exception) {
+            printStackTrace(e)
+        }
+    }
+
+    private fun lastIndexOfLF(bytes: ByteArray, fromIndex: Int): Int {
+        val index = minOf(fromIndex + CHUNK_SIZE, bytes.size - 1)
+        for (i in index downTo index - CHUNK_SIZE) {
+            //返回换行符的位置
+            if (bytes[i] == 10.toByte()) {
+                return i
+            }
+        }
+        return index
+    }
+
+    fun printStackTrace(e: Exception) {
+        if (enableLog && !disableSDK) {
+            Log.e("QuickTracking Exception", "", e)
+        }
+    }
+
+    fun setDebug(isDebug: Boolean) {
+        debug = isDebug
+    }
+
+    fun setEnableLog(isEnableLog: Boolean) {
+        enableLog = isEnableLog
+    }
+
+    fun setDisableSDK(configDisableSDK: Boolean) {
+        disableSDK = configDisableSDK
+    }
+
+    fun isLogEnabled(): Boolean = enableLog
+
+    fun isDebug(): Boolean = debug
+}

package/android/src/main/java/com/quicktrackinganalyticsmodule/utils/RNPropertyManager.kt

@@ -0,0 +1,35 @@
+package com.quicktrackinganalyticsmodule.utils
+
+import org.json.JSONObject
+import java.util.concurrent.CopyOnWriteArrayList
+
+object RNPropertyManager {
+    private val interceptors = CopyOnWriteArrayList<Interceptor>()
+
+    @Synchronized
+    fun addInterceptor(interceptor: Interceptor) {
+        interceptors.add(interceptor)
+    }
+
+    fun mergeProperty(properties: JSONObject?): JSONObject {
+        return mergeProperty(properties ?: JSONObject(), false)
+    }
+
+    fun mergeProperty(properties: JSONObject, isAuto: Boolean): JSONObject {
+        var result = properties
+        try {
+            for (interceptor in interceptors) {
+                result = interceptor.proceed(result, isAuto)
+            }
+        } catch (e: Exception) {
+            QTLog.printStackTrace(e)
+            // 如果处理过程中出现异常，返回原始properties
+            return properties
+        }
+        return result
+    }
+
+    interface Interceptor {
+        fun proceed(properties: JSONObject, isAuto: Boolean): JSONObject
+    }
+}

package/android/src/main/java/com/quicktrackinganalyticsmodule/utils/RNTouchTargetHelper.kt

@@ -0,0 +1,162 @@
+package com.quicktrackinganalyticsmodule.utils
+
+import android.annotation.SuppressLint
+import android.graphics.Matrix
+import android.graphics.PointF
+import android.graphics.Rect
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.touch.ReactHitSlopView
+import com.facebook.react.uimanager.PointerEvents
+import com.facebook.react.uimanager.ReactCompoundView
+import com.facebook.react.uimanager.ReactCompoundViewGroup
+import com.facebook.react.uimanager.ReactPointerEventsView
+
+object RNTouchTargetHelper {
+    private val mEventCoords = FloatArray(2)
+    private val mInverseMatrix = Matrix()
+    private val mMatrixTransformCoords = FloatArray(2)
+    private val mTempPoint = PointF()
+
+    fun findTargetTagForTouch(eventX: Float, eventY: Float, viewGroup: ViewGroup): Int {
+        return findTargetTagAndCoordinatesForTouch(eventX, eventY, viewGroup, mEventCoords)
+    }
+
+    fun findTargetTagAndCoordinatesForTouch(
+        eventX: Float,
+        eventY: Float,
+        viewGroup: ViewGroup,
+        viewCoords: FloatArray
+    ): Int {
+        UiThreadUtil.assertOnUiThread()
+        val targetTag = viewGroup.id
+        viewCoords[0] = eventX
+        viewCoords[1] = eventY
+        val nativeTargetView = findTouchTargetView(viewCoords, viewGroup)
+        val reactTargetView = findClosestReactAncestor(nativeTargetView)
+        return if (reactTargetView != null) {
+            getTouchTargetForView(reactTargetView, viewCoords[0], viewCoords[1])
+        } else {
+            targetTag
+        }
+    }
+
+    @SuppressLint("ResourceType")
+    fun findClosestReactAncestor(view: View?): View? {
+        var currentView = view
+        while (currentView != null && currentView.id <= 0) {
+            currentView = currentView.parent as? View
+        }
+        return currentView
+    }
+
+    fun findTouchTargetView(eventCoords: FloatArray, viewGroup: ViewGroup): View {
+        for (i in viewGroup.childCount - 1 downTo 0) {
+            val child = viewGroup.getChildAt(i)
+            val childPoint = mTempPoint
+            if (isTransformedTouchPointInView(eventCoords[0], eventCoords[1], viewGroup, child, childPoint)) {
+                val restoreX = eventCoords[0]
+                val restoreY = eventCoords[1]
+                eventCoords[0] = childPoint.x
+                eventCoords[1] = childPoint.y
+                val targetView = findTouchTargetViewWithPointerEvents(eventCoords, child)
+                if (targetView != null) {
+                    return targetView
+                }
+                eventCoords[0] = restoreX
+                eventCoords[1] = restoreY
+            }
+        }
+        return viewGroup
+    }
+
+    private fun isTransformedTouchPointInView(
+        x: Float,
+        y: Float,
+        parent: ViewGroup,
+        child: View,
+        outLocalPoint: PointF
+    ): Boolean {
+        var localX = (parent.scrollX + x) - child.left
+        var localY = (parent.scrollY + y) - child.top
+        val matrix = child.matrix
+        if (!matrix.isIdentity) {
+            val localXY = mMatrixTransformCoords
+            localXY[0] = localX
+            localXY[1] = localY
+            val inverseMatrix = mInverseMatrix
+            matrix.invert(inverseMatrix)
+            inverseMatrix.mapPoints(localXY)
+            localX = localXY[0]
+            localY = localXY[1]
+        }
+
+        return when {
+            child is ReactHitSlopView && child.hitSlopRect != null -> {
+                val hitSlopRect = child.hitSlopRect
+                if (localX < -hitSlopRect!!.left ||
+                    localX >= (child.right - child.left + hitSlopRect.right) ||
+                    localY < -hitSlopRect.top ||
+                    localY >= (child.bottom - child.top + hitSlopRect.bottom)) {
+                    false
+                } else {
+                    outLocalPoint.set(localX, localY)
+                    true
+                }
+            }
+            localX < 0f || localX >= (child.right - child.left) ||
+            localY < 0f || localY >= (child.bottom - child.top) -> false
+            else -> {
+                outLocalPoint.set(localX, localY)
+                true
+            }
+        }
+    }
+
+    private fun findTouchTargetViewWithPointerEvents(eventCoords: FloatArray, view: View): View? {
+        val pointerEvents = if (view is ReactPointerEventsView) {
+            view.pointerEvents
+        } else {
+            PointerEvents.AUTO
+        }
+
+        return when (pointerEvents) {
+            PointerEvents.NONE -> null
+            PointerEvents.BOX_ONLY -> view
+            PointerEvents.BOX_NONE -> {
+                if (view is ViewGroup) {
+                    val targetView = findTouchTargetView(eventCoords, view)
+                    if (targetView != view) {
+                        return targetView
+                    }
+                    if (view !is ReactCompoundView ||
+                        view.reactTagForTouch(eventCoords[0], eventCoords[1]) == view.id) {
+                        return null
+                    }
+                    return view
+                }
+                null
+            }
+            PointerEvents.AUTO -> {
+                if ((view !is ReactCompoundViewGroup ||
+                    !view.interceptsTouchEvent(eventCoords[0], eventCoords[1])) &&
+                    view is ViewGroup) {
+                    findTouchTargetView(eventCoords, view)
+                } else {
+                    view
+                }
+            }
+            else -> throw JSApplicationIllegalArgumentException("Unknown pointer event type: $pointerEvents")
+        }
+    }
+
+    fun getTouchTargetForView(targetView: View, eventX: Float, eventY: Float): Int {
+        return if (targetView is ReactCompoundView) {
+            targetView.reactTagForTouch(eventX, eventY)
+        } else {
+            targetView.id
+        }
+    }
+}

package/android/src/main/java/com/quicktrackinganalyticsmodule/utils/RNUtils.kt

@@ -0,0 +1,170 @@
+package com.quicktrackinganalyticsmodule.utils
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableNativeMap
+import com.facebook.react.bridge.WritableMap
+import org.json.JSONArray
+import org.json.JSONObject
+import java.security.MessageDigest
+
+object RNUtils {
+    const val TAG = "QuickTracking == "
+
+    /**
+     * ReadableMap 转换成 JSONObject
+     */
+    fun convertToJSONObject(params: ReadableMap?): JSONObject? {
+        if (params == null) {
+            return null
+        }
+        var json: JSONObject? = null
+        var nativeMap: ReadableNativeMap? = null
+        try {
+            nativeMap = params as ReadableNativeMap
+            json = JSONObject(params.toString()).getJSONObject("NativeMap")
+        } catch (e: Exception) {
+            Log.e(TAG, "JSON 解析失败！", e)
+            val superName = nativeMap?.javaClass?.superclass?.simpleName
+            try {
+                json = JSONObject(params.toString()).getJSONObject(superName!!)
+            } catch (e1: Exception) {
+                Log.e(TAG, "JSON 解析失败！", e1)
+            }
+        }
+        return json
+    }
+
+    /**
+     * JSONObject 转换成 WritableMap
+     */
+    fun convertToWritableMap(json: JSONObject?): WritableMap? {
+        if (json == null || json.length() == 0) {
+            return null
+        }
+        val writableMap = Arguments.createMap()
+        val it = json.keys()
+        while (it.hasNext()) {
+            try {
+                val key = it.next()
+                writableMap.putString(key, json.optString(key))
+            } catch (e: Exception) {
+                QTLog.i(TAG, "JSON to WritableMap 解析失败！", e as Any)
+            }
+        }
+        return writableMap
+    }
+
+    /**
+     * ReadableMap 转换成 HashMap
+     */
+    fun convertToHashMap(params: ReadableMap?): HashMap<String, Any?>? {
+        if (params == null) {
+            return null
+        }
+        var map: HashMap<String, Any?>? = null
+        try {
+            map = (params as ReadableNativeMap).toHashMap()
+        } catch (e: Exception) {
+            Log.e(TAG, "ReadableMap to HashMap 解析失败！", e)
+        }
+        return map
+    }
+
+    /**
+     * merge JSONObject
+     */
+    fun mergeJSONObject(source: JSONObject, dest: JSONObject) {
+        try {
+            val sourceIterator = source.keys()
+            while (sourceIterator.hasNext()) {
+                val key = sourceIterator.next()
+                val value = source.get(key)
+                dest.put(key, value)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "JSONObject Merge失败！", e)
+        }
+    }
+
+    fun convertToMap(jsonObject: JSONObject): Map<String, Any>? {
+        return try {
+            val map = HashMap<String, Any>()
+            val keys = jsonObject.keys()
+            while (keys.hasNext()) {
+                val key = keys.next()
+                val value = jsonObject.get(key)
+                map[key] = when (value) {
+                    is JSONArray -> toList(value)
+                    is JSONObject -> toMap(value)
+                    else -> value
+                } ?: continue
+            }
+            map
+        } catch (e: Exception) {
+            QTLog.printStackTrace(e)
+            null
+        }
+    }
+
+    fun toList(jsonArray: JSONArray): List<Any>? {
+        return try {
+            val list = ArrayList<Any>()
+            for (i in 0 until jsonArray.length()) {
+                val obj = jsonArray.get(i)
+                val processedObj = when (obj) {
+                    is JSONArray -> toList(obj)
+                    is JSONObject -> toMap(obj)
+                    else -> obj
+                } ?: continue
+                list.add(processedObj)
+            }
+            list
+        } catch (e: Exception) {
+            QTLog.printStackTrace(e)
+            null
+        }
+    }
+
+    fun toMap(jsonObject: JSONObject): Map<String, Any>? {
+        return try {
+            val map = HashMap<String, Any>()
+            val keysItr = jsonObject.keys()
+            while (keysItr.hasNext()) {
+                val key = keysItr.next()
+                val value = jsonObject.get(key)
+                map[key] = when (value) {
+                    is JSONArray -> toList(value)
+                    is JSONObject -> toMap(value)
+                    else -> value
+                } ?: continue
+            }
+            map
+        } catch (e: Exception) {
+            QTLog.printStackTrace(e)
+            null
+        }
+    }
+
+    fun MD5(str: String?): String? {
+        if (str == null) return null
+        return try {
+            val defaultBytes = str.toByteArray()
+            val algorithm = MessageDigest.getInstance("MD5")
+            algorithm.reset()
+            algorithm.update(defaultBytes)
+            val messageDigest = algorithm.digest()
+            val hexString = StringBuilder()
+            for (b in messageDigest) {
+                hexString.append(String.format("%02X", b))
+            }
+            hexString.toString()
+        } catch (e: Exception) {
+            str.replace(Regex("[^a-zA-Z0-9._]"), "")
+        } catch (e: Throwable) {
+            Log.e(TAG, "MD5 e is $e")
+            null
+        }
+    }
+}