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

package/android/src/main/java/com/tiktok/sparkling/method/registry/api/DefaultCallHandler.kt

@@ -0,0 +1,106 @@
+// 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.registry.api
+
+import com.lynx.react.bridge.ReadableMap
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeHandler
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeMethodCallback
+import com.tiktok.sparkling.method.registry.core.IBridgeContext
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.core.BridgePlatformType
+import com.tiktok.sparkling.method.registry.api.util.BridgeMethodCallbackHelper
+import org.json.JSONObject
+
+class DefaultCallHandler : IBridgeHandler {
+    private var context: IBridgeContext? = null
+    private var pool: BridgeLocalPool = BridgeLocalPool()
+    private var isReleased = false
+
+    override fun handle(
+        bridgeContext: BridgeContext,
+        call: BridgeCall,
+        callback: IBridgeMethodCallback
+    ) {
+        val platform = BridgeContext.getPlatformByBridgeContext(bridgeContext)
+        val bridge = pool.getBridge(call.bridgeName, platform)
+            ?: return BridgeMethodCallbackHelper.bridgeNotFound(callback)
+
+        val params = call.params
+
+        context?.let {
+            bridge.setBridgeContext(it)
+        }
+
+        if (!bridge.compatibility.value) {
+            when (params) {
+                is JSONObject -> {
+                    JsonProcessor(bridge, params, call.platform).apply { this@apply.context = this@DefaultCallHandler.context }
+                }
+                is ReadableMap -> {
+                    ReadableMapProcessor(bridge, unWrapperParams(params) ?: params).apply { this@apply.context = this@DefaultCallHandler.context }
+                }
+                else -> {
+                    return
+                }
+            }.handle(callback)
+        } else {      // compatible bridge
+            val idlCallback = object : IDLBridgeMethod.Callback {
+                override fun invoke(data: Map<String, Any?>) {
+                    callback.onBridgeResult(data)
+                }
+            }
+            when (params) {
+                is JSONObject -> {
+                    bridge.realHandle(Utils.jsonToMap(params), idlCallback, BridgePlatformType.ALL)
+                }
+
+                is ReadableMap -> {
+                    bridge.realHandle(
+                        (unWrapperParams(params) ?: params).toHashMap(),
+                        idlCallback,
+                        BridgePlatformType.ALL
+                    )
+                }
+
+                else -> {
+                    bridge.realHandle(emptyMap(), idlCallback, BridgePlatformType.ALL)
+                }
+            }
+        }
+    }
+
+    fun registerLocalIDLMethod(
+        clazz: Class<out IDLBridgeMethod>?,
+        scope: BridgePlatformType = BridgePlatformType.ALL
+    ) {
+        pool.registerLocalIDLMethod(clazz, scope)
+    }
+
+    fun setBridgeContext(context: IBridgeContext) {
+        this.context = context
+        this.pool.setBridgeContext(context)
+    }
+
+    fun getBridge(bridgeContext: BridgeContext, bridgeName: String) : IDLBridgeMethod? {
+        val platform = BridgeContext.getPlatformByBridgeContext(bridgeContext)
+        return pool.getBridge(bridgeName, platform)
+    }
+
+    override fun onRelease() {
+        pool.release()
+        isReleased = true
+    }
+
+    override fun isReleased(): Boolean {
+        return isReleased
+    }
+
+    private fun unWrapperParams(params: ReadableMap?) : ReadableMap? {
+        return params?.getMap("data") ?: params
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/api/IBridgeMethod.kt

@@ -0,0 +1,118 @@
+// 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.registry.api
+
+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.interfaces.IBridgeMethodCallback
+import com.tiktok.sparkling.method.registry.core.IBridgeContext
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.core.BridgePlatformType
+import com.tiktok.sparkling.method.registry.core.interfaces.IPlatformDataProcessor
+import com.tiktok.sparkling.method.registry.core.exception.IllegalInputParamException
+import com.tiktok.sparkling.method.registry.core.exception.IllegalOperationException
+import com.tiktok.sparkling.method.registry.core.exception.IllegalOutputParamException
+import com.tiktok.sparkling.method.registry.api.processor.LynxPlatformDataProcessor
+import com.tiktok.sparkling.method.registry.api.processor.WebPlatformDataProcessor
+import com.tiktok.sparkling.method.registry.api.util.printStackString
+import org.json.JSONObject
+
+class JsonProcessor @JvmOverloads constructor(
+    bridge: IDLBridgeMethod,
+    data: JSONObject,
+    val platForm: BridgeCall.PlatForm = BridgeCall.PlatForm.Web
+) : BaseProcessor<JSONObject>(bridge, data) {
+    var context: IBridgeContext? = null
+    override fun getPlatformType() =
+        BridgePlatformType.WEB
+
+    override val processor = WebPlatformDataProcessor().apply {
+        this@apply.context = this@JsonProcessor.context
+    }
+
+    override fun onError(code: Int, message: String): JSONObject {
+        return JSONObject().apply {
+            put("code", code)
+            put("msg", message)
+        }
+    }
+}
+
+class ReadableMapProcessor(bridge: IDLBridgeMethod, data: ReadableMap) :
+    BaseProcessor<ReadableMap>(bridge, data) {
+    var context: IBridgeContext? = null
+    override fun getPlatformType() = BridgePlatformType.LYNX
+    override val processor = LynxPlatformDataProcessor().apply {
+        this@apply.context = this@ReadableMapProcessor.context
+    }
+
+    override fun onError(code: Int, message: String): ReadableMap {
+        return JavaOnlyMap.from(hashMapOf<String, Any>().apply {
+            put("code", code)
+            put("msg", message)
+        })
+    }
+}
+
+
+abstract class BaseProcessor<Input>(val bridge: IDLBridgeMethod, val data: Input) {
+
+    abstract fun getPlatformType(): BridgePlatformType
+    abstract val processor: IPlatformDataProcessor<Input>
+    fun handle(callback: IBridgeMethodCallback) {
+        try {
+            val map = processor.transformPlatformDataToMap(data, bridge::class.java)
+            if (map == null) {
+                callback.onBridgeResult(
+                    onError(
+                        IDLBridgeMethod.ANNOTATION_ERROR,
+                        "processor.transformPlatformDataToMap failed"
+                    )!!
+                )
+            } else {
+                bridge.realHandle(map, object : IDLBridgeMethod.Callback {
+                    override fun invoke(data: Map<String, Any?>) {
+                        val code =
+                            (data[IDLBridgeMethod.PARAM_CODE] as? Int) ?: IDLBridgeMethod.SUCCESS
+                        if (code != IDLBridgeMethod.SUCCESS) {
+                            callback.onBridgeResult(
+                                processor.transformMapToPlatformData(
+                                    data,
+                                    bridge::class.java
+                                )!!
+                            )
+                        } else {
+                            callback.onBridgeResult(
+                                processor.transformMapToPlatformData(
+                                    data,
+                                    bridge::class.java
+                                )!!
+                            )
+                        }
+                    }
+                }, getPlatformType())
+            }
+        } catch (e: IllegalInputParamException) {
+            callback.onBridgeResult(onError(IDLBridgeMethod.INVALID_PARAM, e.toString())!!)
+        } catch (e: IllegalOutputParamException) {
+            callback.onBridgeResult(onError(IDLBridgeMethod.INVALID_RESULT, e.toString())!!)
+        } catch (e: IllegalOperationException) {
+            callback.onBridgeResult(
+                onError(
+                    IDLBridgeMethod.ILLEGAL_OPERATION_ERROR,
+                    e.toString()
+                )!!
+            )
+        } catch (e: Throwable) {
+            callback.onBridgeResult(onError(IDLBridgeMethod.UNKNOWN_ERROR, e.printStackString())!!)
+        }
+    }
+
+    abstract fun onError(code: Int, message: String): Input
+}
+
+

package/android/src/main/java/com/tiktok/sparkling/method/registry/api/PiperDataExt.kt

@@ -0,0 +1,71 @@
+// 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.registry.api
+
+import com.lynx.react.bridge.PiperData
+import org.json.JSONObject
+
+/**
+ */
+
+internal fun PiperData.toJSONObject(): JSONObject {
+    return try {
+        when (this.dataType) {
+            PiperData.DataType.String.ordinal -> {
+                val rawData = this.rawData
+                if (rawData is String) {
+                    JSONObject(rawData)
+                } else {
+                    JSONObject()
+                }
+            }
+
+            PiperData.DataType.Map.ordinal -> {
+                val rawData = this.rawData
+                if (rawData is Map<*, *>) {
+                    JSONObject(rawData)
+                } else {
+                    JSONObject()
+                }
+            }
+
+            else -> {
+                JSONObject()
+            }
+        }
+    } catch (e: Exception) {
+        JSONObject()
+    }
+}
+
+internal fun PiperData.stringify(): String {
+    return when (this.dataType) {
+        PiperData.DataType.String.ordinal -> {
+            this.rawData as? String
+        }
+
+        PiperData.DataType.Map.ordinal -> {
+            val rawData = this.rawData
+            if (rawData is Map<*, *>) {
+                JSONObject(rawData).toString()
+            } else {
+                null
+            }
+        }
+
+        else -> null
+    } ?: ""
+}
+
+internal fun Map<*, *>.containsPiperData(): Boolean {
+    this.forEach { (_, v) ->
+        if (v is PiperData) {
+            return true
+        }
+        if (v is Map<*, *> && v.containsPiperData()) {
+            return true
+        }
+    }
+    return false
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/api/SparklingBridge.kt

@@ -0,0 +1,374 @@
+// 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.registry.api
+
+import android.content.Context
+import android.view.View
+import com.lynx.tasm.LynxBackgroundRuntime
+import com.lynx.tasm.LynxBackgroundRuntimeOptions
+import com.lynx.tasm.LynxViewBuilder
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.InnerBridge
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+import com.tiktok.sparkling.method.protocol.handler.BridgeFactoryManager
+import com.tiktok.sparkling.method.protocol.handler.BridgeThreadDispatcher
+import com.tiktok.sparkling.method.protocol.impl.errors.JSBErrorReportModel
+import com.tiktok.sparkling.method.protocol.impl.interceptor.BridgeMockInterceptor
+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.IBridgeCallback
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeLifeClient
+import com.tiktok.sparkling.method.protocol.utils.LogUtils
+import com.tiktok.sparkling.method.registry.core.BridgeContextWrapper
+import com.tiktok.sparkling.method.registry.core.IBridgeContext
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.core.IDLMethodRegistryCacheManager
+import com.tiktok.sparkling.method.registry.core.JSEventDelegate
+import com.tiktok.sparkling.method.registry.core.SparklingBridgeManager
+import com.tiktok.sparkling.method.registry.core.SparklingBridgeManager.DEFAULT_NAMESPACE
+import com.tiktok.sparkling.method.registry.core.BridgePlatformType
+import com.tiktok.sparkling.method.registry.core.interfaces.IContainerIDProvider
+import com.tiktok.sparkling.method.registry.core.interfaces.IReleasable
+import com.tiktok.sparkling.method.registry.api.util.BridgeProtocolConstants
+import com.tiktok.sparkling.method.registry.api.util.log
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArrayList
+
+class SparklingBridge : IReleasable {
+
+    internal val innerBridge: InnerBridge = InnerBridge()
+    private val closedSubscribers = mutableListOf<Pair<String, JSONObject?>>()
+    private val TAG = "SparklingBridge"
+    private val bridgeSdkContext = BridgeContextWrapper()
+
+    companion object {
+
+        var bridgeFactoryManager: BridgeFactoryManager? = null
+        
+        private var _bridgeThreadDispatcher: BridgeThreadDispatcher? = null
+        var bridgeThreadDispatcher: BridgeThreadDispatcher
+            get() = _bridgeThreadDispatcher ?: BridgeThreadDispatcher().also { _bridgeThreadDispatcher = it }
+            set(value) { _bridgeThreadDispatcher = value }
+
+        /**
+         * Whether the host is a debug environment
+         */
+        var isDebugEnv = false
+
+        /**
+         * JSB SDK Error report block jsb list.
+         * if you set jsb name here, it's jsb error message will not reported.
+         */
+        val jsbErrorReportBlockList = ArrayList<String>()
+
+        val cancelCallbackConfig: CancelCallbackConfig =
+            CancelCallbackConfig().apply { enable = false }
+
+
+        /**
+         * switch enableToast to true will invoke a toast when jsb callback with an error code
+         */
+        private var enableToast = false
+        fun enableToast(isEnable: Boolean) {
+            enableToast = isEnable
+        }
+
+        fun getToastSetting(): Boolean {
+            return enableToast
+        }
+
+        fun attachInitListener(listener: BridgeInitListener) {
+            BridgeManager.attachInitListener(listener)
+        }
+
+    }
+
+
+    fun getErrorReportModel(): JSBErrorReportModel {
+        return innerBridge.getBridgeContext().errorReportModel
+    }
+
+    /**
+     * prepareLynxJSRuntime
+     * because of there is no lynxjsruntime yet, so we need a new way to bind lynxjsruntime
+     */
+    fun prepareLynxJSRuntime(
+        containerId: String,
+        options: LynxBackgroundRuntimeOptions,
+        context: Context
+    ) {
+        BridgeManager.insert(containerId, this)
+        innerBridge.initLynxJSRuntime(containerId, options, context, this)
+        bridgeSdkContext.registerWeakObject(
+            BridgeContext::class.java,
+            innerBridge.getBridgeContext()
+        )
+        bridgeSdkContext.setContainerID(containerId)
+//        bridgeSdkContext.setView(view)
+        bridgeSdkContext.setBridge(this)
+        bridgeSdkContext.setJSEventDelegate(object : JSEventDelegate {
+            override fun sendJSEvent(eventName: String, params: JSONObject?) {
+                sendJSRuntimeEvent(eventName, params)
+            }
+        })
+        bridgeSdkContext.registerObject(
+            IDLBridgeMethod.JSEventDelegate::class.java,
+            object : IDLBridgeMethod.JSEventDelegate {
+                override fun sendJSEvent(eventName: String, params: Map<String, Any?>?) {
+                    sendJSRuntimeEvent(
+                        eventName,
+                        params?.let { Utils.mapToJSON(params) } ?: JSONObject())
+                }
+            }
+        )
+        bridgeSdkContext.registerObject(
+            IContainerIDProvider::class.java,
+            object : IContainerIDProvider {
+                override fun provideContainerID(): String? {
+                    return containerId
+                }
+            })
+        val handler = getBridgeContext().defaultCallHandler
+        handler.setBridgeContext(bridgeSdkContext)
+        innerBridge.registerHandler(handler)
+    }
+
+    /**
+     * bind lynxjsruntime
+     */
+    fun bindLynxJSRuntime(lynxBackgroundRuntime: LynxBackgroundRuntime) {
+        innerBridge.bindLynxJSRuntime(lynxBackgroundRuntime)
+    }
+
+    fun sendJSRuntimeEvent(eventName: String, jsonObject: JSONObject?) {
+        innerBridge.sendJSRuntimeEvent(eventName, jsonObject)
+    }
+
+
+    /**
+     * The first step of protocol layer initialization
+     * @jsBridgeProtocols bridge protocol for control injection
+     * @see BridgeProtocolConstants specific protocol constant reference
+     */
+    fun init(view: View, containerId: String?, jsBridgeProtocols: Int) {
+        BridgeManager.insert(view, this)
+        innerBridge.init(view, containerId, jsBridgeProtocols, this)
+        bridgeSdkContext.registerWeakObject(
+            BridgeContext::class.java,
+            innerBridge.getBridgeContext()
+        )
+        bridgeSdkContext.setContainerID(containerId)
+        bridgeSdkContext.setView(view)
+        bridgeSdkContext.setBridge(this)
+        bridgeSdkContext.setJSEventDelegate(object : JSEventDelegate {
+            override fun sendJSEvent(eventName: String, params: JSONObject?) {
+                sendEvent(eventName, params)
+            }
+        })
+        bridgeSdkContext.registerObject(
+            IDLBridgeMethod.JSEventDelegate::class.java,
+            object : IDLBridgeMethod.JSEventDelegate {
+                override fun sendJSEvent(eventName: String, params: Map<String, Any?>?) {
+                    sendEvent(eventName, params?.let { Utils.mapToJSON(params) } ?: JSONObject())
+                }
+            }
+        )
+        bridgeSdkContext.registerObject(
+            IContainerIDProvider::class.java,
+            object : IContainerIDProvider {
+                override fun provideContainerID(): String? {
+                    return containerId
+                }
+            })
+        val handler = getBridgeContext().defaultCallHandler
+        handler.setBridgeContext(bridgeSdkContext)
+        innerBridge.registerHandler(handler)
+    }
+
+
+    fun bindWithBusinessNamespace(namespace: String) {
+        getBridgeContext().businessCallHandler = BusinessCallHandler(namespace).apply {
+            setBridgeContext(bridgeSdkContext)
+        }
+    }
+
+    /**
+     * only for who has call bindWithBusinessNamespace to register it's unique IDLMethod
+     */
+    fun registerBusinessIDLMethod(
+        clazz: Class<out IDLBridgeMethod>,
+        scope: BridgePlatformType = BridgePlatformType.ALL
+    ) {
+        getBridgeContext().getNamespace()?.let {
+            getBridgeContext().businessCallHandler?.registerMethod(clazz, scope)
+        }
+    }
+
+    fun registerIDLMethod(
+        clazz: Class<out IDLBridgeMethod>?, scope: BridgePlatformType = BridgePlatformType.ALL,
+        namespace:String = DEFAULT_NAMESPACE
+    ) {
+        SparklingBridgeManager.registerIDLMethod(clazz, scope, namespace)
+    }
+
+    fun isBusinessIDLMethodExists(
+        name: String,
+        platformType: BridgePlatformType = BridgePlatformType.ALL
+    ): Boolean {
+        if (getBridgeContext().getNamespace().isNullOrEmpty()) {
+            return false
+        }
+        val businessHandler = getBridgeContext().businessCallHandler ?: return false
+        return businessHandler.isMethodExists(name, platformType)
+    }
+
+    fun registerLocalIDLMethod(
+        clazz: Class<out IDLBridgeMethod>?,
+        scope: BridgePlatformType = BridgePlatformType.ALL
+    ) {
+        innerBridge.getBridgeContext().defaultCallHandler.registerLocalIDLMethod(clazz, scope)
+    }
+
+    fun getBridgeSDKContext(): IBridgeContext {
+        return bridgeSdkContext
+    }
+
+//    @Deprecated("don't use this method")
+    fun getBridgeContext(): BridgeContext {
+        return innerBridge.getBridgeContext()
+    }
+
+    fun registerMonitor(monitor: IBridgeMonitor) {
+        innerBridge.registerMonitor(monitor)
+    }
+
+    fun registerJSBMockInterceptor(interceptor: BridgeMockInterceptor) {
+        innerBridge.getBridgeContext().jsbMockInterceptor = interceptor
+    }
+
+    fun initSDKMonitor(context: Context, appInfo: BridgeSDKMonitor.APPInfo4Monitor) {
+        InnerBridge.initSDKMonitor(context, appInfo)
+    }
+
+    fun registerLynxModule(builder: LynxViewBuilder, containerId: String?) {
+        innerBridge.registerLynxModule(builder, containerId)
+    }
+
+    fun registerIBridgeLifeClient(bridgeLifeClient: IBridgeLifeClient) {
+        innerBridge.registerIBridgeLifeClient(bridgeLifeClient)
+    }
+
+    fun sendEvent(event: String, data: JSONObject?) {
+        innerBridge.sendEvent(event, data)
+    }
+
+    fun addClosedEventObserver(bridgeNames: List<String>, params: List<JSONObject?>) {
+        bridgeNames.forEachIndexed { index, s ->
+            this.closedSubscribers.add(Pair(bridgeNames[index], params[index]))
+        }
+    }
+
+    override fun release() {
+        dealWithCloseEvent()
+        innerBridge.getBridgeContext().defaultCallHandler.onRelease()
+        innerBridge.getBridgeContext().businessCallHandler?.onRelease()
+        innerBridge.getBridgeContext().errorReportModel.putJsbExtension("release", "true")
+        BridgeManager.remove(this)
+        bridgeSdkContext.containerID?.let {
+            IDLMethodRegistryCacheManager.unregisterIDLMethodRegistryCache(
+                it
+            )
+        }
+    }
+
+    private fun dealWithCloseEvent() {
+        closedSubscribers.forEach { pair ->
+            val curPlatform = when (getBridgeContext().platform) {
+                BridgePlatformType.LYNX -> {
+                    BridgeCall.PlatForm.Lynx
+                }
+
+                BridgePlatformType.WEB -> {
+                    BridgeCall.PlatForm.Web
+                }
+
+                else -> {
+                    BridgeCall.PlatForm.Other
+                }
+            }
+
+            getBridgeContext()?.dispatcher?.onDispatchBridgeMethod(
+                BridgeCall(getBridgeContext()).apply {
+                    bridgeName = pair.first
+                    params = pair.second
+                    nameSpace = "DEFAULT"
+                    platform = curPlatform
+                    url = ""
+                },
+                object : IBridgeCallback {
+                    override fun onBridgeResult(
+                        result: BridgeResult, call: BridgeCall?,
+                        monitorBuilder: BridgeSDKMonitor.MonitorModel.Builder?
+                    ) {
+                        LogUtils.d(
+                            TAG,
+                            "dealWithCloseEvent, bridgeName: ${pair.first}}, result: ${result.toString()}"
+                        )
+                    }
+                },
+                getBridgeContext()!!,
+                null
+            )
+        }
+    }
+}
+
+internal object BridgeManager {
+    private val map: ConcurrentHashMap<Int, SparklingBridge> = ConcurrentHashMap()
+
+    //    private val containerIdMap : WeakValueConcurrentHashMap<String, SparklingBridge> = WeakValueConcurrentHashMap()
+    private val listeners = CopyOnWriteArrayList<BridgeInitListener>()
+
+    fun attachInitListener(listener: BridgeInitListener) = listeners.add(listener)
+
+    fun insert(webView: View, sparklingBridge: SparklingBridge) {
+        map[webView.hashCode()] = sparklingBridge
+        map.values.log()
+        listeners.forEach {
+            it.onInit(webView, sparklingBridge)
+        }
+    }
+
+    fun getSparklingBridge(view: View): SparklingBridge? {
+        return map[view.hashCode()]
+    }
+
+    fun remove(bridge: SparklingBridge) {
+        val find = map.toList().find { it.second == bridge }
+        if (find != null) {
+            map.remove(find.first)
+        }
+        map.values.log()
+//        containerIdMap.remove(bridge.getBridgeSDKContext().containerID)
+    }
+
+    /**
+     * create this function for lynx runtime JSB
+     * wait hdt to support this feature
+     * @param containerId
+     * @return
+     */
+    fun insert(containerId: String, sparklingBridge: SparklingBridge) {
+
+    }
+
+}
+
+interface BridgeInitListener {
+    fun onInit(view: View, sparklingBridge: SparklingBridge)
+    fun onInit(containerID: String, sparklingBridge: SparklingBridge) {}
+}