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

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

@@ -0,0 +1,14 @@
+// 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.interfaces
+
+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
+
+interface IBridgeCallback {
+    fun onBridgeResult(result: BridgeResult, call: BridgeCall?, monitorBuilder: BridgeSDKMonitor.MonitorModel.Builder?)
+}

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

@@ -0,0 +1,19 @@
+// 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.interfaces
+
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+import org.json.JSONObject
+
+interface IBridgeClient {
+    fun shouldInterceptRequest(call: BridgeCall): BridgeResult?
+    fun onBridgeInvoked(protocol: IBridgeProtocol, detail: JSONObject)
+    fun onBridgeDispatched(call:BridgeCall)
+    fun onBridgeResultReceived(name: String, handler: IBridgeHandler, detail: JSONObject)
+    fun onBridgeCallback()
+    fun onBridgeRejected()
+}

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

@@ -0,0 +1,23 @@
+// 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.interfaces
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+
+interface IBridgeHandler {
+    fun handle(
+        bridgeContext: BridgeContext,
+        call: BridgeCall,
+        callback: IBridgeMethodCallback
+    )
+    fun onRelease()
+
+    /**
+     * for check release status
+     */
+    fun isReleased(): Boolean
+}

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

@@ -0,0 +1,45 @@
+// 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.interfaces
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+
+/**
+ */
+/**
+ * when shouldHandleBridgeCall is false, you should give a reason to explain it
+ */
+class ShouldHandleBridgeCallResultModel(val shouldHandleBridgeCall: Boolean, val reason: String?){}
+abstract class IBridgeLifeClient {
+
+    /**
+     * if return false, the jsb call will be intercepted, and will callback to FE
+     * with error code : -10 BRIDGE_CALL_BE_INTERCEPTED and message : "intercepted by lifeClient"
+     */
+    open fun shouldHandleBridgeCall(call: BridgeCall, bridgeContext: BridgeContext) : ShouldHandleBridgeCallResultModel {
+        return ShouldHandleBridgeCallResultModel(true, null)
+    }
+    /**
+     * you can register jsb in there
+     */
+    open fun onBridgeCalledStart(call: BridgeCall, bridgeContext: BridgeContext) {}
+    open fun onBridgeImplHandleStart(call: BridgeCall?, bridgeContext: BridgeContext) {}
+    open fun onBridgeImplHandleEnd(call: BridgeCall?, bridgeContext: BridgeContext) {}
+    open fun onBridgeCallbackCallStart(result: BridgeResult, call: BridgeCall, mContext: BridgeContext) {}
+    open fun onBridgeCallbackInvokeStart(result: BridgeResult, call: BridgeCall){}
+    open fun onBridgeCalledEnd(call: BridgeCall, bridgeContext: BridgeContext) {}
+
+    /**
+     * data is any.
+     * when it is webview, data will be a JSONObject
+     * when it is lynxview, data will be JavaOnlyArray
+     * you can change data in onBridgeEventBegin.
+     */
+    open fun onBridgeEventStart(eventName: String, data: Any?) {}
+    open fun onBridgeEventEnd(eventName: String, data: Any?) {}
+}

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

@@ -0,0 +1,10 @@
+// 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.interfaces
+
+interface IBridgeMethodCallback {
+    fun onBridgeResult(parcel: Any)
+}

package/android/src/main/java/com/tiktok/sparkling/method/protocol/interfaces/IBridgeProtocol.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.interfaces
+
+import com.tiktok.sparkling.method.protocol.BridgeContext
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+
+abstract class IBridgeProtocol(context: BridgeContext) {
+    val mContext = context
+
+    /**
+     * params: JSONObject or JavaOnlyArray
+     */
+    abstract fun sendEvent(name: String, params: Any?)
+    abstract fun init()
+    abstract fun createBridgeCall(msg:String): BridgeCall
+
+    open fun sendJSRuntimeEvent(name: String, params: Any?) {}
+}

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

@@ -0,0 +1,13 @@
+// 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.utils
+
+internal object BridgeConstants {
+    const val BRIDGE_CALL_SUCCESS = 1
+    const val BRIDGE_CALL_FAIL = 0
+    const val ERROR_BRIDGE_NO_AUTHORITY = -1
+    const val BRIDGE_NOT_FOUND = -2
+}

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

@@ -0,0 +1,147 @@
+// 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.utils
+
+import com.tiktok.sparkling.method.registry.api.stringify
+import com.lynx.react.bridge.JavaOnlyArray
+import com.lynx.react.bridge.JavaOnlyMap
+import com.lynx.react.bridge.PiperData
+import com.lynx.react.bridge.ReadableType
+import org.json.JSONArray
+import org.json.JSONObject
+
+object BridgeConverter {
+    private const val TAG = "BridgeConverter"
+
+    fun revertJavaOnlyMap2JSONObject(map: JavaOnlyMap?): JSONObject {
+        val obj = JSONObject()
+        if (map.isNullOrEmpty()) {
+            return obj
+        }
+        val keys = map.keySetIterator()
+        while (keys.hasNextKey()) {
+            val nextKey = keys.nextKey()
+            val nextValue = map[nextKey]
+            try {
+                when (map.getType(nextKey)) {
+                    ReadableType.Array -> {
+                        obj.putOpt(nextKey, revertJavaOnlyArray2JSONArray(nextValue as JavaOnlyArray))
+                    }
+                    ReadableType.Map -> {
+                        obj.putOpt(nextKey, revertJavaOnlyMap2JSONObject(nextValue as JavaOnlyMap))
+                    }
+                    ReadableType.Number -> {
+                        val num = nextValue as Number
+                        obj.put(nextKey, getNumber(num))
+                    }
+                    ReadableType.PiperData -> {
+                        val jsonObject = (nextValue as PiperData).stringify()
+                        obj.put(nextKey, jsonObject)
+                    }
+                    else -> {
+                        obj.putOpt(nextKey, nextValue)
+                    }
+                }
+            } catch (ex: Throwable) {
+                LogUtils.e(TAG, "revertJavaOnlyMap2JSONObject $ex")
+            }
+
+        }
+        return obj
+    }
+
+    private fun revertJavaOnlyArray2JSONArray(array: JavaOnlyArray): JSONArray {
+        val result = JSONArray()
+        for (i in 0 until array.size) {
+            val value = array[i]
+            try {
+                when (array.getType(i)) {
+                    ReadableType.Map -> {
+                        result.put(revertJavaOnlyMap2JSONObject(value as JavaOnlyMap))
+                    }
+                    ReadableType.Array -> {
+                        result.put(revertJavaOnlyArray2JSONArray(value as JavaOnlyArray))
+                    }
+                    ReadableType.Number -> {
+                        val num = value as Number
+                        result.put(getNumber(num))
+                    }
+                    ReadableType.PiperData -> {
+                        val jsonObject = (value as PiperData).stringify()
+                        result.put(jsonObject)
+                    }
+                    else -> {
+                        result.put(value)
+                    }
+                }
+            } catch (ex: Throwable) {
+                LogUtils.e(TAG, "revertJavaOnlyArray2JSONArray $ex")
+            }
+        }
+        return result
+    }
+
+    private fun getNumber(rawNumber: Number): Number {
+        val intValue: Int = runCatching { rawNumber.toInt() }.getOrNull() ?: 0
+        val doubleValue: Double = runCatching { rawNumber.toDouble() }.getOrNull() ?: 0.0
+        if (intValue.compareTo(doubleValue) == 0) {
+            return intValue
+        } else {
+            val longValue: Long = doubleValue.toLong()
+            if (doubleValue.compareTo(longValue) == 0) {
+                return longValue
+            } else {
+                return doubleValue
+            }
+        }
+    }
+
+    fun convertJSONObject2JavaOnlyMap(obj: JSONObject): JavaOnlyMap {
+        val keys = obj.keys()
+        val result = JavaOnlyMap()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            when (val sonValue = obj.opt(key)) {
+                is JSONObject -> {
+                    result[key] = convertJSONObject2JavaOnlyMap(sonValue)
+                }
+                is JSONArray -> {
+                    result[key] = convertJSONArray2JavaOnlyArray(sonValue)
+                }
+                else -> {
+                    if(sonValue == JSONObject.NULL) {
+                        result[key] = null
+                    }else {
+                        result[key] = sonValue
+                    }
+                }
+            }
+        }
+        return result
+    }
+
+
+
+
+    private fun convertJSONArray2JavaOnlyArray(arrays: JSONArray): JavaOnlyArray {
+        val result = JavaOnlyArray()
+        for (i in 0 until arrays.length()) {
+            when (val sonValue = arrays.opt(i)) {
+                is JSONArray -> {
+                    result.add(convertJSONArray2JavaOnlyArray(sonValue))
+                }
+                is JSONObject -> {
+                    result.add(convertJSONObject2JavaOnlyMap(sonValue))
+                }
+                else -> {
+                    result.add(sonValue)
+                }
+            }
+        }
+        return result
+    }
+
+}

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

@@ -0,0 +1,37 @@
+// 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.utils
+
+import android.util.Log
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+
+object LogUtils {
+    fun e(tag:String,msg:String){
+        if (SparklingBridge.isDebugEnv) {
+            Log.e(tag, msg)
+        }
+    }
+    fun d(tag:String,msg:String){
+        if (SparklingBridge.isDebugEnv) {
+            Log.d(tag, msg)
+        }
+    }
+    fun w(tag:String,msg:String){
+        if (SparklingBridge.isDebugEnv) {
+            Log.w(tag, msg)
+        }
+    }
+    fun i(tag:String,msg:String){
+        if (SparklingBridge.isDebugEnv) {
+            Log.i(tag, msg)
+        }
+    }
+    fun v(tag:String,msg:String){
+        if (SparklingBridge.isDebugEnv) {
+            Log.v(tag, msg)
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+// 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.utils
+
+import org.json.JSONObject
+
+/**
+ *
+ */
+class MonitorUtils {
+    companion object {
+        fun customReport(eventName: String, eventInfo: JSONObject?) {
+            customReport(eventName, null, eventInfo)
+        }
+
+        fun customReport(eventName: String, category: JSONObject?, metrics: JSONObject?) {
+            customReport(eventName, category, metrics, null)
+        }
+
+        fun customReport(
+            eventName: String,
+            category: JSONObject?,
+            metrics: JSONObject?,
+            extraInfo: String?
+        ) {
+            // TODO: implement by injection
+        }
+
+        fun lifecycleReportPV(params: HashMap<String, Any>) {
+            // TODO: implement by injection
+        }
+
+        fun lifecycleReportPerf(params: HashMap<String, Any>) {
+            // TODO: implement by injection
+        }
+
+    }
+}

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

@@ -0,0 +1,70 @@
+// 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.tiktok.sparkling.method.registry.core.IBridgeContext
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.core.LocalBridge
+import com.tiktok.sparkling.method.registry.core.SparklingBridgeManager
+import com.tiktok.sparkling.method.registry.core.BridgePlatformType
+import com.tiktok.sparkling.method.registry.core.interfaces.IReleasable
+import java.util.concurrent.ConcurrentHashMap
+
+class BridgeLocalPool : IReleasable {
+    private var context: IBridgeContext? = null
+    private val map: ConcurrentHashMap<BridgePlatformType, ConcurrentHashMap<String, IDLBridgeMethod>> = ConcurrentHashMap()
+
+    private val localBridge: LocalBridge by lazy {
+        LocalBridge().apply { setIsLocalBridge(true) }
+    }
+
+    fun setBridgeContext(context: IBridgeContext?) {
+        this.context = context
+        localBridge.setContext(context)
+    }
+
+    fun registerLocalIDLMethod(
+        clazz: Class<out IDLBridgeMethod>?,
+        scope: BridgePlatformType = BridgePlatformType.ALL
+    ) {
+        localBridge.registerIDLMethod(clazz, scope)
+    }
+
+    fun getBridge(bridgeName: String, platformType: BridgePlatformType): IDLBridgeMethod? {
+        val method = map[platformType]?.get(bridgeName) ?: map[BridgePlatformType.ALL]?.get(bridgeName)
+        if (method != null) {
+            return method
+        } else {
+            val clazz =
+                localBridge.findIDLMethodClass(platformType, bridgeName) ?:
+                SparklingBridgeManager.findIDLMethodClass(platformType, bridgeName) ?:
+                return null
+            val newInstance = clazz.newInstance()
+            getPlatformTypeCache(platformType)[bridgeName] = newInstance
+            return newInstance
+        }
+    }
+
+    private fun getPlatformTypeCache(platformType: BridgePlatformType): ConcurrentHashMap<String, IDLBridgeMethod> {
+        val concurrentHashMap = map[platformType]
+        return if (concurrentHashMap == null) {
+            map[platformType] = ConcurrentHashMap()
+            map[platformType]!!
+        } else {
+            concurrentHashMap
+        }
+    }
+
+    override fun release() {
+        map.forEach { entry ->
+            entry.value.forEach{
+                it.value.release()
+            }
+        }
+        map.clear()
+    }
+}

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

@@ -0,0 +1,19 @@
+// 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.registry.api
+
+/**
+ * when your value is just for the experiment, you can add it here.
+ * and after your data has been recycled, you must delete it.
+ */
+object BridgeSettings {
+
+    var bridgeRegistryOptimize: Boolean = false
+    var bridgeDisableLongToDouble: Boolean = false
+    var bridgeNewInputNumberTypeChange : Boolean = false
+    var bridgeCallToStringOptimization: Boolean = false
+
+}

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

@@ -0,0 +1,100 @@
+// 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.IDLMethodRegistry
+import com.tiktok.sparkling.method.registry.core.BridgePlatformType
+import com.tiktok.sparkling.method.registry.api.util.BridgeMethodCallbackHelper
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ */
+class BusinessCallHandler(val nameSpace: String): IBridgeHandler {
+    private var context : IBridgeContext? = null
+    private var registry = IDLMethodRegistry().apply { namespace = nameSpace }
+    private var pool: ConcurrentHashMap<BridgePlatformType, ConcurrentHashMap<String, IDLBridgeMethod>> = ConcurrentHashMap()
+    private var isRelease = false
+    override fun handle(
+        bridgeContext: BridgeContext,
+        call: BridgeCall,
+        callback: IBridgeMethodCallback
+    ) {
+        val bridge = getBridge(bridgeContext, call.bridgeName) ?: return BridgeMethodCallbackHelper.bridgeNotFound(callback)
+
+        context?.let {
+            bridge.setBridgeContext(it)
+        }
+        val params = call.params
+        when (params) {
+            is JSONObject -> {
+                JsonProcessor(bridge, params, call.platform)
+            }
+            is ReadableMap -> {
+                ReadableMapProcessor(bridge, unWrapperParams(params) ?: params)
+            }
+            else -> {
+                return
+            }
+        }.handle(callback)
+    }
+
+    fun registerMethod(
+        clazz: Class<out IDLBridgeMethod>,
+        scope: BridgePlatformType = BridgePlatformType.ALL
+    ) {
+        registry.registerMethod(clazz, scope)
+    }
+
+    fun getBridge(bridgeContext: BridgeContext, bridgeName: String) : IDLBridgeMethod? {
+        val platformType = BridgeContext.getPlatformByBridgeContext(bridgeContext)
+        val clazz = registry.findMethodClass(platformType, bridgeName) ?: return null
+        val newInstance = clazz.newInstance()
+        getPlatformTypeCache(platformType)[bridgeName] = newInstance
+        return newInstance
+    }
+
+    fun isMethodExists(
+        name: String,
+        platformType: BridgePlatformType = BridgePlatformType.ALL
+    ): Boolean {
+        return registry.isMethodExists(name, platformType)
+    }
+
+    fun setBridgeContext(bridgeContext: IBridgeContext) {
+        context = bridgeContext
+    }
+
+    private fun getPlatformTypeCache(platformType: BridgePlatformType): ConcurrentHashMap<String, IDLBridgeMethod> {
+        val concurrentHashMap = pool[platformType]
+        return if (concurrentHashMap == null) {
+            pool[platformType] = ConcurrentHashMap()
+            pool[platformType]!!
+        } else {
+            concurrentHashMap
+        }
+    }
+
+    private fun unWrapperParams(params: ReadableMap?) : ReadableMap? {
+        return params?.getMap("data") ?: params
+    }
+
+    override fun onRelease() {
+        pool.clear()
+        isRelease = true
+    }
+
+    override fun isReleased(): Boolean {
+        return isRelease
+    }
+}

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

@@ -0,0 +1,13 @@
+// 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.registry.api
+
+/**
+ */
+class CancelCallbackConfig {
+    var enable: Boolean = false
+    var cancelCallbackUrlList: ArrayList<String>? = null
+}