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

package/android/src/main/java/com/tiktok/sparkling/method/protocol/InnerBridge.kt

@@ -0,0 +1,134 @@
+// 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
+
+import android.content.Context
+import android.view.View
+import android.webkit.WebView
+import com.tiktok.sparkling.method.registry.core.BridgePlatformType
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+import com.lynx.tasm.LynxBackgroundRuntime
+import com.lynx.tasm.LynxBackgroundRuntimeOptions
+import com.lynx.tasm.LynxView
+import com.lynx.tasm.LynxViewBuilder
+import com.tiktok.sparkling.method.protocol.handler.BridgeDispatcher
+import com.tiktok.sparkling.method.protocol.impl.lynx.LynxBridgeProtocol
+import com.tiktok.sparkling.method.protocol.impl.lynx.LynxViewImpl
+import com.tiktok.sparkling.method.protocol.impl.monitor.BridgeSDKMonitor
+import com.tiktok.sparkling.method.protocol.impl.monitor.IBridgeMonitor
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeHandler
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeLifeClient
+import org.json.JSONObject
+import java.util.concurrent.atomic.AtomicBoolean
+
+internal class InnerBridge {
+    private var mBridgeContext = BridgeContext()
+
+    companion object {
+        private val hasInitMonitor: AtomicBoolean = AtomicBoolean(false)
+        var globalMonitor : BridgeSDKMonitor? = null
+        fun initSDKMonitor(context: Context, appInfo: BridgeSDKMonitor.APPInfo4Monitor) {
+            if (hasInitMonitor.compareAndSet(false, true))
+                globalMonitor = BridgeSDKMonitor(context, appInfo)
+        }
+    }
+
+    init {
+        mBridgeContext.dispatcher = BridgeDispatcher()
+    }
+
+    /**
+     * use this to pass the bridge to mBridgeContext, to and you can use the custom auth ability.
+     */
+    fun init(view: View, containerId: String?, jsBridgeProtocols: Int? = null, bridge: SparklingBridge) {
+        mBridgeContext.sparklingBridge = bridge
+        init(view, containerId, jsBridgeProtocols)
+    }
+
+    fun init(view: View, containerId: String?, jsBridgeProtocols: Int? = null) {
+        if (view is LynxView) {
+            mBridgeContext.lynxView = view
+            mBridgeContext.platform = BridgePlatformType.LYNX
+            mBridgeContext.registerProtocol(LynxBridgeProtocol(mBridgeContext))
+        } else if (view is WebView) {
+            // TODO
+        }
+        mBridgeContext.protocols.forEach {
+            it.init()
+        }
+        mBridgeContext.containerId = containerId
+    }
+
+    fun initLynxJSRuntime(containerId: String, options: LynxBackgroundRuntimeOptions, context: Context, sparklingBridge: SparklingBridge) {
+        mBridgeContext.sparklingBridge = sparklingBridge
+        mBridgeContext.platform = BridgePlatformType.LYNX
+        mBridgeContext.registerProtocol(LynxBridgeProtocol(mBridgeContext))
+        mBridgeContext.protocols.forEach {
+            it.init()
+        }
+        registerLynxJSRuntimeModule(options, containerId)
+    }
+
+    private fun registerLynxJSRuntimeModule(options: LynxBackgroundRuntimeOptions, containerId: String?) {
+        LynxViewImpl(mBridgeContext).initJSRuntime(options)
+        mBridgeContext.containerId = containerId
+    }
+
+    fun registerIBridgeLifeClient(bridgeLifeClient: IBridgeLifeClient) {
+        mBridgeContext.registerIBridgeLifeClient(bridgeLifeClient)
+    }
+
+
+    fun registerLynxModule(builder: LynxViewBuilder, containerId: String?) {
+        LynxViewImpl(mBridgeContext).apply {
+            init(builder)
+        }
+        mBridgeContext.containerId = containerId
+    }
+
+    fun registerHandler(handler: IBridgeHandler) {
+        mBridgeContext.dispatcher?.registerHandler(handler)
+    }
+
+    fun getBridgeContext(): BridgeContext {
+        return mBridgeContext
+    }
+
+    fun registerMonitor(monitor: IBridgeMonitor) {
+        mBridgeContext.monitor.add(monitor)
+    }
+
+    fun sendEvent(event: String, data: JSONObject?) {
+        mBridgeContext.monitor.forEach {
+            runCatching {
+                it.onBridgeEvent(event, data)
+            }.onFailure {
+                it.printStackTrace()
+            }
+        }
+        mBridgeContext.protocols.forEach {
+            it.sendEvent(event,data)
+        }
+    }
+
+    fun sendJSRuntimeEvent(event: String, data: JSONObject?) {
+        mBridgeContext.monitor.forEach {
+            runCatching {
+                it.onBridgeEvent(event, data)
+            }.onFailure {
+                it.printStackTrace()
+            }
+        }
+        mBridgeContext.protocols.forEach {
+            it.sendJSRuntimeEvent(event,data)
+        }
+    }
+
+    fun bindLynxJSRuntime(lynxBackgroundRuntime: LynxBackgroundRuntime) {
+        mBridgeContext.lynxBackgroundRuntime = lynxBackgroundRuntime
+    }
+
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/entity/BridgeCall.kt

@@ -0,0 +1,79 @@
+// 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.entity
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.impl.monitor.BridgeSDKMonitor
+import com.tiktok.sparkling.method.registry.core.model.context.BridgeCallThreadTypeEnum
+import com.tiktok.sparkling.method.registry.api.BridgeSettings
+import com.lynx.react.bridge.JavaOnlyMap
+import com.tiktok.sparkling.method.protocol.impl.errors.JSBErrorReportModel
+import com.tiktok.sparkling.method.protocol.impl.lifecycle.fe.FeCallMonitorModel
+import org.json.JSONObject
+
+class BridgeCall(val context: BridgeContext) {
+
+    companion object {
+        const val DEFAULT_NAMESPACE = "DEFAULT"
+    }
+
+    enum class PlatForm {
+        Lynx, Web, Other,
+    }
+
+
+    var callbackId = ""
+    var bridgeName = ""
+    var url = ""
+    var msgType = ""
+    var params: Any? = null
+    var sdkVersion = ""
+    var nameSpace = ""
+    var frameUrl = ""
+    var timestamp: Long = -1
+    var rawReq = ""
+    var hitBusinessHandler: Boolean = false
+    lateinit var platform: PlatForm
+
+    // when bridgeCallThreadType == null, it means bridgeCallThreadType no one set, so just use the default thread.
+    // the default thread in jsbsdk will be same as the main thread
+    var bridgeCallThreadType: BridgeCallThreadTypeEnum? = null
+
+    var cancelCallBack: CancelCallbackType = CancelCallbackType.NONE
+
+    /**
+     * force on instance sdk error
+     */
+    val jsbSDKErrorReportModel: JSBErrorReportModel = JSBErrorReportModel()
+
+    //for lifeClient
+    internal var callBeginTime: Long = 0
+//    var protocolVersion: Int = ProtocolVersion.UNKNOWN
+    internal var monitorBuilder: BridgeSDKMonitor.MonitorModel.Builder? = null
+    internal var invocation: String = "" //same as rawReq
+    internal var beginCreateCallBaskMsgTime: Long = 0
+    internal var endCreateCallBaskMsgTime: Long = 0
+    internal var callbackMsg: String? = null
+    internal var lynxCallbackMap: JavaOnlyMap? = null
+    internal var isInMainThread: Boolean = true
+    internal var feCallMonitorModel = FeCallMonitorModel()
+    internal var jsbEngine: String = ""
+
+    //for call to get invocation's jsonObject
+    internal var invocationJson: JSONObject? = null
+
+    override fun toString(): String {
+        if (BridgeSettings.bridgeCallToStringOptimization) {
+            return "BridgeCall(callbackId='$callbackId', bridgeName='$bridgeName')"
+        } else {
+            return "BridgeCall(callbackId='$callbackId', bridgeName='$bridgeName', hitBusinessHandler='$hitBusinessHandler', url='$url', msgType='$msgType', params='$params', sdkVersion=$sdkVersion, nameSpace='$nameSpace', frameUrl='$frameUrl')"
+        }
+
+    }
+
+}
+
+enum class CancelCallbackType {
+    NONE, ALL, ONLY_SUCCESS
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/entity/BridgeResult.kt

@@ -0,0 +1,68 @@
+// 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.entity
+
+import com.tiktok.sparkling.method.protocol.utils.BridgeConverter
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+import com.tiktok.sparkling.method.registry.api.Utils
+import com.lynx.react.bridge.JavaOnlyMap
+import org.json.JSONObject
+
+class BridgeResult(val parcel: Any) {
+
+    override fun toString(): String {
+        if (SparklingBridge.isDebugEnv) {
+            return toJSONObject().toString()
+        } else {
+            return ""
+        }
+    }
+
+    companion object {
+        fun toJsonResult(code: Int, msg: String = "", data: JSONObject? = null): BridgeResult {
+            val json = JSONObject()
+            json.apply {
+                put("code", code)
+                put("msg", msg)
+                put("data", data)
+            }
+            return BridgeResult(json)
+        }
+    }
+
+    fun toJSONObject(): JSONObject {
+        if (parcel is JSONObject) return parcel
+        if (parcel is JavaOnlyMap) {
+            return BridgeConverter.revertJavaOnlyMap2JSONObject(parcel)
+        }
+        if (parcel is Map<*, *>) {
+            return Utils.mapToJSON(parcel as Map<String, Any?>)
+        }
+        return JSONObject()
+    }
+
+    fun isSuccessResult(): Boolean {
+        try {
+            if (parcel is JSONObject) return parcel.optInt("code", IDLBridgeMethod.FAIL) == IDLBridgeMethod.SUCCESS
+            if (parcel is Map<*, *>) return parcel.get("code") == IDLBridgeMethod.SUCCESS
+            if (parcel is JavaOnlyMap) return parcel.getInt("code") == IDLBridgeMethod.SUCCESS
+            return false
+        } catch (e: Exception) {
+            return false
+        }
+    }
+
+    fun toJSONObject(call: BridgeCall?): JSONObject {
+        return (if (parcel is JSONObject) {
+            parcel
+        } else if (parcel is Map<*, *>) {
+            Utils.mapToJSON(parcel as Map<String, Any?>)
+        } else if (parcel is JavaOnlyMap) {
+            BridgeConverter.revertJavaOnlyMap2JSONObject(parcel)
+        } else JSONObject())
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/handler/BridgeDispatcher.kt

@@ -0,0 +1,198 @@
+// 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.handler
+
+import android.os.Handler
+import android.os.Looper
+import android.widget.Toast
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+import com.tiktok.sparkling.method.protocol.impl.monitor.BridgeSDKMonitor
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeCallback
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeHandler
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeMethodCallback
+import com.tiktok.sparkling.method.protocol.utils.BridgeConstants
+import com.tiktok.sparkling.method.protocol.utils.LogUtils
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+import com.tiktok.sparkling.method.registry.api.SparklingBridge.Companion.getToastSetting
+import org.json.JSONObject
+
+class BridgeDispatcher {
+    companion object {
+        val TAG = "BridgeDispatcher"
+        val handler = Handler(Looper.getMainLooper())
+    }
+
+    private var bridgeHandler: IBridgeHandler? = null
+
+    fun registerHandler(handler: IBridgeHandler) {
+        bridgeHandler = handler
+    }
+
+    @JvmOverloads
+    fun onDispatchBridgeMethod(
+        call: BridgeCall,
+        callback: IBridgeCallback,
+        context: BridgeContext,
+        monitorBuilder: BridgeSDKMonitor.MonitorModel.Builder? = null
+    ) {
+        if (context.jsbMockInterceptor != null) {
+            if (!shouldInvokeResult(context, call, callback)) {
+                val bridgeCall = context.jsbMockInterceptor!!.interceptBridgeCall(call)
+                realDispatchBridgeMethod(bridgeCall, callback, context, monitorBuilder)
+            }
+        } else realDispatchBridgeMethod(call, callback, context, monitorBuilder)
+    }
+
+    private fun shouldInvokeResult(
+        context: BridgeContext,
+        call: BridgeCall,
+        callback: IBridgeCallback
+    ): Boolean {
+        val result = context.jsbMockInterceptor!!.invokeBridgeResult(call)
+        result?.let {
+            callback.onBridgeResult(it, call, null)
+            return true
+        }
+        return false
+    }
+
+    private fun realDispatchBridgeMethod(
+        call: BridgeCall,
+        callback: IBridgeCallback,
+        context: BridgeContext,
+        monitorBuilder: BridgeSDKMonitor.MonitorModel.Builder?
+    ) {
+        LogUtils.d(TAG, "realDispatchBridgeMethod: ${Thread.currentThread()} and call is \n$call")
+
+        SparklingBridge.bridgeFactoryManager?.checkAndInitBridge(context, call)
+
+        val client = context.bridgeClient
+        client.onBridgeDispatched(call)
+        val result = client.shouldInterceptRequest(call)
+
+        if (result != null && (
+                    result.toJSONObject()
+                        .optInt("code") == BridgeConstants.ERROR_BRIDGE_NO_AUTHORITY)
+        ) {
+            client.onBridgeCallback()
+            callback.onBridgeResult(
+                context.jsbMockInterceptor?.interceptBridgeResult(call, result) ?: result,
+                call,
+                monitorBuilder
+            )
+            if (getToastSetting()) toastJsbError(call, result.toJSONObject(), context)
+            return
+        }
+
+        val shouldHandleBridgeCallResultModel =
+            context.bridgeLifeClientImp.shouldHandleBridgeCall(call, context)
+        if (!shouldHandleBridgeCallResultModel.shouldHandleBridgeCall) {
+            callback.onBridgeResult(
+                BridgeResult.toJsonResult(
+                    IDLBridgeMethod.BRIDGE_CALL_BE_INTERCEPTED,
+                    IDLBridgeMethod.BRIDGE_CALL_BE_INTERCEPTED_MSG + ", reason: " + shouldHandleBridgeCallResultModel.reason,
+                    null
+                ),
+                call,
+                monitorBuilder
+            )
+            return
+        }
+
+        val callbackHandler = object : IBridgeMethodCallback {
+            override fun onBridgeResult(parcel: Any) {
+                client.onBridgeCallback()
+                val result =
+                    context.jsbMockInterceptor?.interceptBridgeResult(call, BridgeResult(parcel))
+                        ?: BridgeResult(parcel)
+                callback.onBridgeResult(result, call, monitorBuilder)
+                if (getToastSetting()) toastJsbError(call, result.toJSONObject(), context)
+            }
+        }
+
+        if (context.shouldHandleWithBusinessHandler(call)) {
+            call.hitBusinessHandler = true
+            context.businessCallHandler!!.handle(context, call, callbackHandler)
+            LogUtils.d(
+                TAG,
+                "[JSBHit] Business JSB Handler(${context.businessCallHandler?.nameSpace}), $call"
+            )
+        } else {
+            call.hitBusinessHandler = false
+            bridgeHandler!!.handle(context, call, callbackHandler)
+            LogUtils.d(TAG, "[JSBHit] Default JSB Handler, $call")
+        }
+    }
+
+    fun handleRawJSBCall(call: BridgeCall, context: BridgeContext, callback: IBridgeCallback) {
+        runCatching {
+            bridgeHandler?.handle(context, call, object : IBridgeMethodCallback {
+                override fun onBridgeResult(parcel: Any) {
+                    callback.onBridgeResult(BridgeResult(parcel), call, null)
+                }
+            })
+        }.onFailure {
+            it.printStackTrace()
+            LogUtils.i(TAG, "handleRawJSBCall ${call.bridgeName} fail, msg: ${it.message}")
+        }
+    }
+
+    private fun toastJsbError(call: BridgeCall, json: JSONObject, context: BridgeContext) {
+        val appContext = context.lynxView?.context
+        appContext?.let {
+            handler.post {
+                if (json.length() == 0) {
+                    Toast.makeText(
+                        it,
+                        "bridgeName: ${call.bridgeName}, callback info is null, check it!",
+                        Toast.LENGTH_SHORT
+                    ).show()
+                }
+
+                val code = json.optInt("code", -2345)
+                if (code != -1234 && code != BridgeConstants.BRIDGE_CALL_SUCCESS) {
+                    when (code) {
+                        BridgeConstants.BRIDGE_CALL_FAIL ->
+                            Toast.makeText(
+                                it,
+                                "${call.bridgeName}, code=$code, bridge call fail",
+                                Toast.LENGTH_SHORT
+                            ).show()
+
+                        BridgeConstants.ERROR_BRIDGE_NO_AUTHORITY ->
+                            Toast.makeText(
+                                it,
+                                "${call.bridgeName}, code=$code, no authority",
+                                Toast.LENGTH_SHORT
+                            ).show()
+
+                        BridgeConstants.BRIDGE_NOT_FOUND ->
+                            Toast.makeText(
+                                it,
+                                "${call.bridgeName}, code=$code, bridge not found",
+                                Toast.LENGTH_SHORT
+                            ).show()
+
+                        else -> Toast.makeText(
+                            it,
+                            "${call.bridgeName}, code=$code, may not success, check it.",
+                            Toast.LENGTH_SHORT
+                        ).show()
+                    }
+                }
+                if (code == -2345)
+                    Toast.makeText(
+                        it,
+                        "${call.bridgeName}, seems no code callback",
+                        Toast.LENGTH_SHORT
+                    ).show()
+            }
+        }
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/handler/BridgeFactoryManager.kt

@@ -0,0 +1,16 @@
+// 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.handler
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+
+/**
+ * @Author: linshuhao
+ * @Time: 2022/5/12 15:31
+ * @Description:
+ */
+open class BridgeFactoryManager {
+    open fun checkAndInitBridge(bridgeContext: BridgeContext, call: BridgeCall){}
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/handler/BridgeThreadDispatcher.kt

@@ -0,0 +1,56 @@
+// Copyright (c) 2023 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.handler
+
+import android.os.Handler
+import android.os.Looper
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+
+/**
+ * if you want to dispatch jsb to other thread, you need to implement SparklingBridge.bridgeThreadDispatcher
+ * you can just implement one method when you just want to dispatch noe engine's jsb thread.
+ */
+open class BridgeThreadDispatcher(private val handler: Handler? = null) {
+    // Lazy initialize the Handler to avoid issues in unit tests
+    private val mHandler: Handler? by lazy {
+        handler ?: try {
+            Handler(Looper.getMainLooper())
+        } catch (e: RuntimeException) {
+            // In unit tests, return null handler and execute synchronously
+            null
+        }
+    }
+
+    /**
+     * if you want to dispatch lynx's jsb, you can use this method
+     */
+    open fun dispatchLynxBridgeThread(call: BridgeCall, jsbRealCallBlock: (isRunInMainThread: Boolean) -> Unit?) {
+        val handler = mHandler
+        if (handler != null) {
+            handler.post {
+                jsbRealCallBlock(true)
+            }
+        } else {
+            // Execute synchronously in unit tests
+            jsbRealCallBlock(true)
+        }
+    }
+
+    /**
+     * if you want to dispatch web's jsb, you can use this method
+     */
+    open fun dispatchWebBridgeThread(call: BridgeCall, jsbRealCallBlock: (isRunInMainThread: Boolean) -> Unit?) {
+        val handler = mHandler
+        if (handler != null) {
+            handler.post {
+                jsbRealCallBlock(true)
+            }
+        } else {
+            // Execute synchronously in unit tests
+            jsbRealCallBlock(true)
+        }
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/impl/errors/JSBErrorReportModel.kt

@@ -0,0 +1,144 @@
+// Copyright (c) 2023 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.errors
+
+import android.view.View
+import com.tiktok.sparkling.method.protocol.utils.MonitorUtils
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+import org.json.JSONObject
+
+/**
+ */
+class JSBErrorReportModel {
+    companion object {
+        const val DEFAULT_JSB_ERROR_BID = "jsb_sdk_error_bid"
+        const val DEFAULT_JSB_ERROR_EVENT = "jsb_sdk_error_event"
+
+        //global messages
+        private val globalExtension: HashMap<String, Any> = HashMap<String, Any>()
+
+        fun putGlobalExtension(key: String, value: Any?) {
+            value?.let {
+                globalExtension[key] = it
+            }
+        }
+
+        fun putGlobalExtension(map: Map<String, Any>) {
+            globalExtension.putAll(map)
+        }
+    }
+
+    //instance messages
+    private var jsbMethodName: String? = null
+    private var jsbUrl: String? = null
+    private var jsbErrorCode: Int? = null
+    private var jsbBridgeSdk: String? = null
+    private var view: View? = null
+    private var containerID: String? = null
+    private var jsbEngine: String? = null
+
+    //only put new value
+    private val jsbExtension: HashMap<String, Any> = HashMap<String, Any>()
+
+    internal fun setJsbMethodName(jsbMethodName: String?) {
+        this.jsbMethodName = jsbMethodName
+    }
+
+    internal fun setJsbEngine(jsbEngine: String) {
+        this.jsbEngine = jsbEngine
+    }
+
+    internal fun setJsbUrl(jsbUrl: String?) {
+        this.jsbUrl = jsbUrl
+    }
+
+    internal fun setJsbErrorCode(jsbErrorCode: Int?) {
+        this.jsbErrorCode = jsbErrorCode
+    }
+
+    internal fun setJsbBridgeSdk(jsbBridgeSdk: String?) {
+        this.jsbBridgeSdk = jsbBridgeSdk
+    }
+
+    internal fun setView(view: View?) {
+        this.view = view
+    }
+
+    internal fun setContainerID(containerID: String?) {
+        this.containerID = containerID
+    }
+
+    fun putJsbExtension(key: String, value: Any?) {
+        value?.let { jsbExtension.put(key, it) }
+    }
+
+    fun putJsbExtension(map: Map<String, Any>) {
+        jsbExtension.putAll(map)
+    }
+
+
+    internal fun reportJSBErrorModel(contextErrorModel: JSBErrorReportModel?) {
+        if (!checkJSBErrorCodeIsRight()) {
+            return
+        }
+        if (SparklingBridge.jsbErrorReportBlockList.contains(jsbMethodName)) {
+            //report be block.
+            return
+        }
+        realReportSDKErrorModel(contextErrorModel, DEFAULT_JSB_ERROR_EVENT, 0)
+    }
+
+    private fun realReportSDKErrorModel(
+        contextErrorModel: JSBErrorReportModel?,
+        eventName: String,
+        simple: Int
+    ) {
+        MonitorUtils.customReport(
+            eventName,
+            JSONObject().apply {
+                put("jsb_method_name", jsbMethodName)
+                put("jsb_url", jsbUrl)
+                put("jsb_error_code", jsbErrorCode)
+                put("jsb_bridge_sdk", jsbBridgeSdk)
+                put("jsb_engine", jsbEngine)
+                for ((key, value) in jsbExtension) {
+                    put(key, value.toString())
+                }
+                if (jsbErrorCode == IDLBridgeMethod.UNREGISTERED) {
+                    for ((key, value) in globalExtension) {
+                        put(key, value.toString())
+                    }
+                }
+                //add context message
+                contextErrorModel?.jsbExtension?.let {
+                    for ((key, value) in it) {
+                        put(key, value.toString())
+                    }
+                }
+            })
+    }
+
+    private val allJSBSDKErrorCode = arrayOf(
+        IDLBridgeMethod.UNREGISTERED, // UnregisteredMethod, the called method isn't registered, due to legacy error, sdk use BridgeConstants's BRIDGE_NOT_FOUND
+        IDLBridgeMethod.INVALID_PARAM, // InvalidParameter, the parameter passed by FE is invalid
+        IDLBridgeMethod.INVALID_RESULT, // InvalidResult, the result passed by the method implementor is invalid
+
+        IDLBridgeMethod.UNKNOWN_ERROR,
+        IDLBridgeMethod.PERMISSION_NO_EXIST, // internal code, due to legacy error, sdk use BridgeConstants's PERMISSION_NO_EXIST
+        IDLBridgeMethod.ANNOTATION_ERROR, // when annotation can't get
+        IDLBridgeMethod.ILLEGAL_OPERATION_ERROR, // when call a illegal method of proxy
+
+
+        IDLBridgeMethod.BRIDGE_CALL_BE_INTERCEPTED, // bridge call be intercepted
+        IDLBridgeMethod.BRIDGE_HAS_BEEN_RELEASED,
+
+        )
+
+    private fun checkJSBErrorCodeIsRight(): Boolean {
+        return allJSBSDKErrorCode.contains(jsbErrorCode)
+    }
+}