sparkling-method 2.0.0-rc.0 → 2.0.0-rc.1

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/interceptor/BridgeMockInterceptor.kt

@@ -0,0 +1,30 @@
+// Copyright (c) 2022 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.interceptor
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+import org.json.JSONObject
+
+/**
+ * use for JSB Mock, only invoke in Debug mode
+ */
+open class BridgeMockInterceptor {
+    open fun interceptBridgeCall(originCall: BridgeCall): BridgeCall {
+        return originCall
+    }
+    open fun interceptBridgeResult(jsbCall: BridgeCall, originResult: BridgeResult): BridgeResult {
+        return originResult
+    }
+    /**
+     * skip real jsb call and invoke callback to FE when the BridgeResult != null
+     */
+    open fun invokeBridgeResult(originCall: BridgeCall): BridgeResult? {
+        return null
+    }
+    open fun interceptJSBEvent(context: BridgeContext, event: String, data: JSONObject?) {}
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/lifecycle/fe/FeCallMonitorModel.kt

@@ -0,0 +1,66 @@
+// Copyright (c) 2024 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.lifecycle.fe
+
+import android.view.View
+import com.tiktok.sparkling.method.protocol.utils.MonitorUtils
+import org.json.JSONObject
+
+/**
+ */
+class FeCallMonitorModel {
+
+    companion object {
+        const val _JSB_CALLER_INFO = "_jsb_caller_info"
+        const val _JSB_PERF_METRICS = "_jsb_perf_metrics"
+        const val JSB_FUNC_CALL_END = "jsb_func_call_end"
+        const val JSB_FUNC_CALL_START = "jsb_func_call_start"
+        const val JS_JSSDK = "js_jssdk"
+        const val JS_CANCEL_CALLBACK = "js_cancel_callback"
+        const val CALLER_PREFIX = "caller_"
+
+        private const val JSB_FUNC_CALL = "jsb_func_call"
+        private const val JSB_CALLBACK_CALL = "jsb_callback_call"
+        private const val JSB_CALL = "jsb_call"
+        private const val JSB_CLIENT_CALL = "jsb_client_call"
+        private const val BRIDGE_METHOD_NAME = "bridge_method_name"
+    }
+
+    val JSB_FE_CALL_MONITOR_EVENT = "jsb_fe_call_monitor"
+    var view: View? = null
+    var bridgeName: String? = null
+    var containerID: String? = null
+
+    var jsbFuncCallStart: Long = 0
+    var jsbFuncCallEnd: Long = 0
+    var jsbCallbackStart: Long = 0
+    var jsbCallbackEnd: Long = 0
+    var jsbNativeCallStart: Long = 0
+
+
+    private var category = JSONObject()
+
+    fun addCategory(key: String, value: Any) {
+        category.put(key, value)
+    }
+
+    fun reportFeCallInfo() {
+        MonitorUtils.customReport(
+            JSB_FE_CALL_MONITOR_EVENT, JSONObject().apply {
+                put(BRIDGE_METHOD_NAME, bridgeName)
+
+                if (jsbFuncCallStart == 0L) {
+                    put(JSB_FUNC_CALL, -1)
+                    put(JSB_CALL, -1)
+                } else {
+                    put(JSB_FUNC_CALL, jsbFuncCallEnd - jsbFuncCallStart)
+                    put(JSB_CALL, jsbCallbackEnd - jsbFuncCallStart)
+                }
+                put(JSB_CALLBACK_CALL, jsbCallbackEnd - jsbCallbackStart)
+                put(JSB_CLIENT_CALL, jsbCallbackEnd - jsbNativeCallStart)
+            })
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/lynx/LynxBridgeDelegateModule.kt

@@ -0,0 +1,31 @@
+// Copyright (c) 2022 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.lynx
+
+import com.lynx.jsbridge.LynxContextModule
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.ReadableMap
+import com.lynx.tasm.behavior.LynxContext
+
+class LynxBridgeDelegateModule(val context: LynxContext, val obj: Any?) :
+    LynxContextModule(context, obj) {
+    constructor(context: LynxContext) : this(context, null)
+
+    private val TAG = "LynxBridgeDelegateModule"
+
+    private val realLynxBridgeDelegate : RealLynxBridgeDelegate = RealLynxBridgeDelegate(obj)
+
+    companion object {
+        // here is the protocol of the front end of lynx, don't change it casually
+        const val NAME = "spkPipe"
+    }
+
+    @LynxMethod
+    fun call(bridgeName: String, params: ReadableMap? = null, callback: Callback? = null) {
+        realLynxBridgeDelegate.call(bridgeName, params, callback, "Lynx")
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/lynx/LynxBridgeProtol.kt

@@ -0,0 +1,69 @@
+// Copyright (c) 2022 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+package com.tiktok.sparkling.method.protocol.impl.lynx
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeProtocol
+import com.tiktok.sparkling.method.protocol.utils.BridgeConverter
+import com.lynx.react.bridge.JavaOnlyArray
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import org.json.JSONObject
+
+class LynxBridgeProtocol(val context: BridgeContext) : IBridgeProtocol(context) {
+
+    override fun sendEvent(name: String, params: Any?) {
+        if(params is JavaOnlyArray){
+            context.bridgeLifeClientImp.onBridgeEventStart(name, params)
+            sendEvent(name, (params as? JavaOnlyArray))
+            context.bridgeLifeClientImp.onBridgeEventEnd(name, params)
+        }else if (params is JSONObject?){
+            var array = JavaOnlyArray().apply {
+                pushMap(BridgeConverter.convertJSONObject2JavaOnlyMap(JSONObject().apply {
+                    put("data",params)
+                    put("containerID",context.containerId)
+                    put("protocolVersion","1.0")
+                    put("code", 1)
+                }))
+            }
+            context.bridgeLifeClientImp.onBridgeEventStart(name, array)
+            sendEvent(name,array)
+            context.bridgeLifeClientImp.onBridgeEventEnd(name, array)
+        }
+    }
+
+    override fun sendJSRuntimeEvent(name: String, params: Any?) {
+        if(params is JavaOnlyArray){
+            context.bridgeLifeClientImp.onBridgeEventStart(name, params)
+            sendJSRuntimeEvent(name, (params as? JavaOnlyArray))
+            context.bridgeLifeClientImp.onBridgeEventEnd(name, params)
+        }else if (params is JSONObject?){
+            var array = JavaOnlyArray().apply {
+                pushMap(BridgeConverter.convertJSONObject2JavaOnlyMap(JSONObject().apply {
+                    put("data",params)
+                    put("containerID",context.containerId)
+                    put("protocolVersion","1.0")
+                    put("code", 1)
+                }))
+            }
+            context.bridgeLifeClientImp.onBridgeEventStart(name, array)
+            sendJSRuntimeEvent(name,array)
+            context.bridgeLifeClientImp.onBridgeEventEnd(name, array)
+        }
+    }
+
+    private fun sendJSRuntimeEvent(method: String, params: JavaOnlyArray?) {
+        context.lynxBackgroundRuntime?.sendGlobalEvent(method, params)
+    }
+
+    private fun sendEvent(method: String, params: JavaOnlyArray?) {
+        context.lynxView?.sendGlobalEvent(method, params)
+    }
+
+    override fun init() {}
+
+    override fun createBridgeCall(msg: String): BridgeCall {
+        return BridgeCall(context)
+    }
+
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/lynx/LynxRuntimeBridgeDelegateModule.kt

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.lynx
+
+import android.content.Context
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.jsbridge.LynxModule
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.ReadableMap
+
+/**
+ */
+class LynxRuntimeBridgeDelegateModule(val context: Context, val obj: Any?) :
+    LynxModule(context, obj) {
+
+    private val TAG = "LynxRuntimeBridgeDelegateModule"
+    private val realLynxBridgeDelegate : RealLynxBridgeDelegate = RealLynxBridgeDelegate(obj)
+    companion object {
+        // here is the protocol of the front end of lynx, don't change it casually
+        const val NAME = "runtimeBridge"
+    }
+
+    @LynxMethod
+    fun call(bridgeName: String, params: ReadableMap? = null, callback: Callback? = null) {
+        realLynxBridgeDelegate.call(bridgeName, params, callback, "LynxRuntime")
+    }
+
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/lynx/LynxViewImpl.kt

@@ -0,0 +1,29 @@
+// Copyright (c) 2022 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.lynx
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.lynx.tasm.LynxBackgroundRuntimeOptions
+import com.lynx.tasm.LynxViewBuilder
+
+class LynxViewImpl(context: BridgeContext){
+    private val TAG = "LynxViewImpl"
+    private val BRIDGE_NAME = "spkPipe"
+    private val mContext = context
+
+    /**
+     * The correct LynxViewBuilder needs to be registered here
+     */
+    fun init(builder: LynxViewBuilder):LynxViewBuilder{
+        builder.registerModule(BRIDGE_NAME, LynxBridgeDelegateModule::class.java,mContext)
+        return builder
+    }
+
+    fun initJSRuntime(options: LynxBackgroundRuntimeOptions): LynxBackgroundRuntimeOptions {
+        options.registerModule(LynxRuntimeBridgeDelegateModule.NAME, LynxRuntimeBridgeDelegateModule::class.java, mContext)
+        return options
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/lynx/RealLynxBridgeDelegate.kt

@@ -0,0 +1,147 @@
+// Copyright (c) 2024 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.lynx
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.impl.monitor.BridgeSDKMonitor
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeCallback
+import com.tiktok.sparkling.method.protocol.utils.BridgeConverter
+import com.tiktok.sparkling.method.protocol.utils.LogUtils
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.core.model.context.BridgeCallThreadTypeConfig
+import com.tiktok.sparkling.method.registry.core.model.context.threadStringToThreadTypeEnum
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.JavaOnlyMap
+import com.lynx.react.bridge.ReadableMap
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+import com.tiktok.sparkling.method.protocol.handler.BridgeThreadDispatcher
+import org.json.JSONObject
+
+/**
+ *
+ */
+class RealLynxBridgeDelegate(val obj: Any?) {
+    private val TAG = "RealLynxBridgeDelegate"
+
+    private val bridgeThreadDispatcher: BridgeThreadDispatcher = SparklingBridge.bridgeThreadDispatcher
+
+    fun call(
+        bridgeName: String,
+        params: ReadableMap? = null,
+        callback: Callback? = null,
+        fromEngine: String
+    ) {
+        if (obj is BridgeContext) {
+            val call = BridgeCall(obj).apply {
+                this.callbackId = "lynx"
+                this.bridgeName = bridgeName
+                this.params = params
+                this.platform = BridgeCall.PlatForm.Lynx
+                this.jsbEngine = fromEngine
+                this.url = obj.getCurrentUrl() ?: ""
+                params?.let {
+                    this.timestamp = it.getLong("__timestamp", System.currentTimeMillis())
+
+                    try {
+                        val threadTypeParam =
+                            if (params.getMap("data")?.hasKey("threadType") == true) {
+                                params.getMap("data").getString("threadType", "")
+                            } else {
+                                params.getString("threadType", "")
+                            }
+                        if (threadTypeParam.isNotEmpty()) {
+                            this.bridgeCallThreadType =
+                                threadStringToThreadTypeEnum(threadTypeParam)
+                        }
+                    } catch (e: Exception) {
+                        this.jsbSDKErrorReportModel.putJsbExtension(
+                            "jsb_thread_type_getter_error",
+                            e.message
+                        )
+                    }
+                    // the params priority is higher than the BridgeCallThreadTypeConfig
+                    if (this.bridgeCallThreadType == null) {
+                        val threadConfig =
+                            obj.sparklingBridge?.getBridgeSDKContext()?.getObject(
+                                BridgeCallThreadTypeConfig::class.java
+                            )
+                        this.bridgeCallThreadType =
+                            threadConfig?.getBridgeCallThreadType(this.bridgeName, this)
+                    }
+                }
+            }
+
+            if (obj.defaultCallHandler.isReleased()) {
+                LogUtils.d(TAG, "Bridge is released. bridgeName = $bridgeName")
+                onLynxBridgeResult(
+                    BridgeResult.toJsonResult(
+                        IDLBridgeMethod.BRIDGE_HAS_BEEN_RELEASED,
+                        "Bridge is released, please check it with container's owner."
+                    ), call, obj, false, callback
+                )
+                return
+            }
+            LogUtils.d(TAG, "Bridge is alive. bridgeName = $bridgeName")
+
+            obj.bridgeLifeClientImp.onBridgeCalledStart(call, obj)
+
+            bridgeThreadDispatcher.dispatchLynxBridgeThread(call) { isInMainThread ->
+                obj.dispatcher?.onDispatchBridgeMethod(call, object : IBridgeCallback {
+                    override fun onBridgeResult(
+                        result: BridgeResult,
+                        call: BridgeCall?,
+                        monitorBuilder: BridgeSDKMonitor.MonitorModel.Builder?
+                    ) {
+                        onLynxBridgeResult(result, call, obj, isInMainThread, callback)
+                    }
+                }, obj, null)
+            }
+
+        }
+
+    }
+
+    private fun onLynxBridgeResult(
+        result: BridgeResult,
+        call: BridgeCall?,
+        obj: BridgeContext,
+        isInMainThread: Boolean,
+        callback: Callback?
+    ) {
+        LogUtils.d(TAG, "onBridgeResult,result:$result,call:$call")
+
+        call?.let { obj.bridgeLifeClientImp.onBridgeCallbackCallStart(result, it, obj) }
+
+        try {
+            val map = if (result.parcel is JavaOnlyMap) {
+                result.parcel
+            } else if (result.parcel is JSONObject) {
+                BridgeConverter.convertJSONObject2JavaOnlyMap(result.parcel)
+            } else if (result.parcel is Map<*, *>) {
+                JavaOnlyMap.from(result.parcel)
+            } else {
+                JavaOnlyMap()
+            }
+
+            call?.apply {
+                this.lynxCallbackMap = map
+                this.isInMainThread = isInMainThread
+            }
+            if (call != null) {
+                obj.bridgeLifeClientImp.onBridgeCallbackInvokeStart(result, call)
+            }
+            callback?.invoke(map)
+
+            if (call != null) {
+                obj.bridgeLifeClientImp.onBridgeCalledEnd(call, obj)
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/monitor/BridgeSDKMonitor.kt

@@ -0,0 +1,239 @@
+// Copyright (c) 2022 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.monitor
+
+import android.content.Context
+import com.tiktok.sparkling.method.protocol.utils.MonitorUtils
+import org.json.JSONObject
+
+class BridgeSDKMonitor {
+    companion object {
+        private const val TAG = "BridgeSDKMonitor"
+        private const val SERVICE_NAME = "bridge_performance"
+        var channel_: String = ""
+    }
+
+    constructor(
+        context: Context,
+        appInfo: APPInfo4Monitor,
+    ) {
+        val appVersion = appInfo.appVersion
+        val updateVersionCode = appInfo.update_version_code
+        val channel = appInfo.channel
+        val sdkVersion = appInfo.sdkVersion
+        channel_ = channel ?: ""
+
+        val header = JSONObject()
+        header.apply {
+            // optional，the major version number of the host
+            put("app_version", appVersion)
+            // optional, the minor version number of the host
+            put("update_version_code", updateVersionCode)
+            put("channel", channel)
+            // optional，sdk version
+            put("sdk_version", sdkVersion)
+        }
+    }
+
+    /**
+     *
+     * @param serviceName event name
+     * @param category    enumerable Key-Value
+     * @param metric      not enumerable Key-Value
+     * @param logExtr     Information fields that other users want to upload, can be queried by hive, and do not participate in the output of the report
+     */
+    fun monitorEvent(data: MonitorModel) {
+        val category = JSONObject() // enumerable
+        val metric = JSONObject()   // not enumerable
+
+        category.put("code", data.code)
+        category.put("url", data.url)
+        category.put("channel", data.channel)
+        category.put("method", data.method)
+        category.put("container_type", data.containerType)
+
+        metric.put("duration", data.duration)
+        metric.put("request_data_length", data.request_data_length)
+        metric.put("request_send_timestamp", data.request_send_timestamp)
+        metric.put("request_receive_timestamp", data.request_receive_timestamp)
+        metric.put("request_decode_duration", data.request_decode_duration)
+        metric.put("request_duration", data.request_duration)
+
+        metric.put("response_data_length", data.response_data_length)
+        metric.put("response_send_timestamp", data.response_send_timestamp)
+        metric.put("response_receive_timestamp", data.response_receive_timestamp)
+        metric.put("response_encode_duration", data.response_encode_duration)
+        metric.put("response_duration", data.response_duration)
+
+        MonitorUtils.customReport(SERVICE_NAME, category, metric, null)
+    }
+
+
+    data class APPInfo4Monitor(
+        val appVersion: String? = null,
+        val update_version_code: String? = null,
+        val channel: String? = null,
+        val sdkVersion: String? = null
+    )
+
+    enum class ContainerType(val type: String) {
+        LYNX("lynx"), H5("h5")
+    }
+
+    data class MonitorModel(
+        val method: String?, // not enumerable
+        val code: Int?,      // enumerable
+        val channel: String?, // enumerable
+        val containerType: String?, // enumerable
+
+        val duration: Long?, // not enumerable response.receive_timestamp - request.send_timestamp, unit: ms
+        val url: String?,    // not enumerable
+
+        val request_data_length: Int?,        // input parameter data size, unit: byte
+        val request_send_timestamp: Long?,    // send time of fe, unit: ms
+        val request_receive_timestamp: Long?, // client receiving timing, unit: ms
+        val request_decode_duration: Long?,   // data deserialization time, unit: ms
+        val request_duration: Long?,            // receive_timestamp - send_timestamp, unit: ms
+
+        val response_data_length: Int?,        // return parameter data size, unit: byte
+        val response_encode_duration: Long?,   // data serialization time, unit:ms
+        val response_send_timestamp: Long?,    // client sending timing, unit: ms
+        val response_receive_timestamp: Long?, // front-end reception timing, unit: ms
+        val response_duration: Long?            // receive_timestamp - send_timestamp, unit: ms
+    ) {
+
+        class Builder() {
+            private var method: String? = null
+            private var code: Int? = null
+            private var channel: String? = null
+            private var containerType: String? = null
+
+            private var duration: Long? = null
+            private var url: String? = null
+
+            private var request_data_length: Int? = null
+            private var request_send_timestamp: Long? = null
+            private var request_receive_timestamp: Long? = null
+            private var request_decode_duration: Long? = null
+            private var request_duration: Long? = null
+
+            private var response_data_length: Int? = null
+            private var response_encode_duration: Long? = null
+            private var response_send_timestamp: Long? = null
+            private var response_receive_timestamp: Long? = null
+            private var response_duration: Long? = null
+
+            fun setMethod(str: String): Builder {
+                this.method = str
+                return this
+            }
+
+            fun setURL(url: String): Builder {
+                this.url = url
+                return this
+            }
+
+            fun setCode(code: Int): Builder {
+                this.code = code
+                return this
+            }
+
+            fun setChannel(channel: String): Builder {
+                this.channel = channel
+                return this
+            }
+
+            fun setContainerType(type: String): Builder {
+                this.containerType = type
+                return this
+            }
+
+            fun setDuration(): Builder {
+                if (response_receive_timestamp != null && request_send_timestamp != null)
+                    this.duration = response_receive_timestamp!! - request_send_timestamp!!
+                return this
+            }
+
+            fun setRequestDataLength(length: Int): Builder {
+                this.request_data_length = length
+                return this
+            }
+
+            fun setRequestSendTimestamp(ts: Long): Builder {
+                this.request_send_timestamp = ts
+                return this
+            }
+
+            fun setRequestReceiveTimestamp(ts: Long): Builder {
+                this.request_receive_timestamp = ts
+                return this
+            }
+
+            fun setRequestDuration(): Builder {
+                if (request_receive_timestamp != null && request_send_timestamp != null)
+                    this.request_duration = request_receive_timestamp!! - request_send_timestamp!!
+                return this
+            }
+
+            fun setRequestDecodeDuration(duration: Long): Builder {
+                this.request_decode_duration = duration
+                return this
+            }
+
+            ///
+
+            fun setResponseDataLength(length: Int): Builder {
+                this.response_data_length = length
+                return this
+            }
+
+            fun setResponseSendTimestamp(ts: Long): Builder {
+                this.response_send_timestamp = ts
+                return this
+            }
+
+            fun setResponseReceiveTimestamp(ts: Long): Builder {
+                this.response_receive_timestamp = ts
+                return this
+            }
+
+            fun setResponseDuration(): Builder {
+                if (response_receive_timestamp != null && response_send_timestamp != null)
+                    this.response_duration =
+                        response_receive_timestamp!! - response_send_timestamp!!
+                return this
+            }
+
+            fun setResponseEncodeDuration(duration: Long): Builder {
+                this.response_encode_duration = duration
+                return this
+            }
+
+            fun build(): MonitorModel {
+                return MonitorModel(
+                    method,
+                    code,
+                    channel,
+                    containerType,
+                    duration,
+                    url,
+                    request_data_length,
+                    request_send_timestamp,
+                    request_receive_timestamp,
+                    request_decode_duration,
+                    request_duration,
+                    response_data_length,
+                    response_encode_duration,
+                    response_send_timestamp,
+                    response_receive_timestamp,
+                    response_duration
+                )
+            }
+
+        }
+    }
+
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/monitor/IBridgeMonitor.kt

@@ -0,0 +1,17 @@
+// Copyright (c) 2022 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.monitor
+
+import android.util.Log
+import org.json.JSONObject
+
+interface IBridgeMonitor {
+    fun onBridgeRejected(entity: MonitorEntity)
+    fun onBridgeResolved(entity: MonitorEntity)
+    fun onBridgeEvent(eventName: String, data: JSONObject?) {
+        Log.d("IBridgeMonitor", "eventName = $eventName, data = ${data.toString()}")
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/monitor/MonitorEntity.kt

@@ -0,0 +1,22 @@
+// Copyright (c) 2022 TikTok Pte. Ltd.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+
+package com.tiktok.sparkling.method.protocol.impl.monitor
+
+import org.json.JSONObject
+
+class MonitorEntity {
+    var name:String? = null
+    var code:Int? = null
+    var message:String? = null
+    var url:String? = null
+    var beginTime:Long? = null
+    var endTime:Long? = null
+    var rawResult: JSONObject? = null
+    var rawRequest: JSONObject? = null
+    var hitBusinessHandler: Boolean = false
+    var nameSpace: String? = null
+    var isRunInMainThread: Boolean = true
+}