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

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

@@ -0,0 +1,44 @@
+// 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.util
+
+import com.lynx.react.bridge.WritableArray
+import com.lynx.react.bridge.WritableMap
+import com.tiktok.sparkling.method.registry.core.XReadableArray
+import com.tiktok.sparkling.method.registry.core.XReadableMap
+import org.json.JSONArray
+import org.json.JSONObject
+
+interface IConvertUtils {
+
+    fun toStringOrJson(data: Any?): String
+
+    fun mapToJSON(map: Map<String, Any?>): JSONObject
+
+
+    fun mapSupportPiperdataToJSON(map: Map<String, Any?>): JSONObject
+
+    fun listSupportPiperdataToJSON(list: List<Any>): JSONArray
+
+    fun listToJSON(list: List<Any>): JSONArray
+
+    fun jsonToMap(json: JSONObject): Map<String, Any?>
+
+    fun jsonToList(json: JSONArray): List<Any?>
+
+
+    fun convertJsonToMap(jsonObject: JSONObject): WritableMap
+
+    fun convertJsonToArray(jsonArray: JSONArray): WritableArray
+
+    fun convertMapToReadableMap(source: Map<String, Any?>): WritableMap
+
+    fun convertArrayToWritableArray(sourceArray: List<Any>): WritableArray
+
+    fun convertXReadableMapToReadableMap(source: XReadableMap): WritableMap
+
+    fun convertXReadableArrayToReadableArray(source: XReadableArray): WritableArray
+
+    fun getValue(value: Any?): Any?
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/api/util/LogHelper.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.registry.api.util
+
+import android.util.Log
+import java.io.PrintWriter
+import java.io.StringWriter
+
+const val TAG = "SparklingBridge"
+internal fun Any?.log() {
+    when (this) {
+        is Map<*,*> -> {
+
+        }
+        else -> {
+            Log.d(TAG, this.toString())
+        }
+    }
+}
+
+internal fun Throwable.printStackString(): String {
+    val sw = StringWriter()
+    val pw = PrintWriter(sw)
+    this.printStackTrace(pw)
+    pw.flush()
+    return sw.toString()
+}

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

@@ -0,0 +1,73 @@
+// 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.util
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.tiktok.sparkling.method.runtime.depend.CommonDependsProvider
+import com.tiktok.sparkling.method.registry.api.util.ThreadPool.runInBackGround
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+
+object ThreadPool {
+
+    private const val TAG = "ThreadPool"
+
+    private var executor: ExecutorService? = null
+
+    private val mainHandler: Handler by lazy {
+        Handler(Looper.getMainLooper())
+    }
+
+    /**
+     * run task on main thread
+     */
+    fun runInMain(runnable: Runnable) {
+        mainHandler.post(runnable)
+    }
+
+    /**
+     * run task on background thread
+     */
+    fun runInBackGround(runnable: Runnable) {
+        ensureExecutorNotNull()
+        executor!!.submit(runnable)
+    }
+
+    /**
+     * config custom executor by user
+     * used by runInBackGround
+     * @see runInBackGround
+     */
+    fun configExecutorService(outerExecutors: ExecutorService) {
+        executor = outerExecutors
+    }
+
+    fun getExecutorService(): ExecutorService {
+        ensureExecutorNotNull()
+        return executor!!
+    }
+
+    private fun ensureExecutorNotNull() {
+        if (executor == null) {
+            executor = CommonDependsProvider.hostThreadPoolExecutorDepend?.getNormalThreadExecutor()
+                ?: createDefault()
+        }
+    }
+
+    private fun createDefault(): ExecutorService {
+        val cupNumber = Runtime.getRuntime().availableProcessors()
+        var threadPoolSize = cupNumber / 2
+        if (threadPoolSize == 0) {
+            threadPoolSize = 1
+        }
+        Log.d(TAG, "jsb thread pool size: $threadPoolSize")
+        return Executors.newFixedThreadPool(threadPoolSize)
+    }
+
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/core/BridgeCollections.kt

@@ -0,0 +1,194 @@
+// 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.core
+
+interface XReadableMap {
+    fun hasKey(name: String): Boolean
+    fun isNull(name: String): Boolean
+    fun getBoolean(name: String): Boolean
+    fun getDouble(name: String): Double
+    fun getInt(name: String): Int
+    fun getString(name: String): String
+    fun getArray(name: String): XReadableArray?
+    fun getMap(name: String): XReadableMap?
+    fun get(name: String): XDynamic
+    fun getType(name: String): XReadableType
+    fun keyIterator(): XKeyIterator
+    fun toMap(): Map<String, Any?>
+}
+
+fun XReadableMap.optString(name: String, defaultValue: String = ""): String {
+    if (!hasKey(name)) {
+        return defaultValue
+    }
+
+    val value = get(name)
+    return if (value.getType() == XReadableType.String) {
+        value.asString()
+    } else {
+        defaultValue
+    }
+}
+
+fun XReadableMap.optBoolean(name: String, defaultValue: Boolean = false): Boolean {
+    if (!hasKey(name)) {
+        return defaultValue
+    }
+
+    val value = get(name)
+    return if (value.getType() == XReadableType.Boolean) {
+        value.asBoolean()
+    } else {
+        defaultValue
+    }
+}
+
+fun XReadableMap.optInt(name: String, defaultValue: Int = 0): Int {
+    if (!hasKey(name)) {
+        return defaultValue
+    }
+
+    val value = get(name)
+    return if (value.getType() == XReadableType.Int) {
+        value.asInt()
+    } else {
+        defaultValue
+    }
+}
+
+fun XReadableMap.optDouble(name: String, defaultValue: Double = 0.0): Double {
+    if (!hasKey(name)) {
+        return defaultValue
+    }
+
+    val value = get(name)
+    return if (value.getType() == XReadableType.Number) {
+        value.asDouble()
+    } else {
+        defaultValue
+    }
+}
+
+fun XReadableMap.optMap(name: String, defaultValue: XReadableMap? = null): XReadableMap? {
+    if (!hasKey(name)) {
+        return defaultValue
+    }
+
+    val value = get(name)
+    return if (value.getType() == XReadableType.Map) {
+        value.asMap()
+    } else {
+        defaultValue
+    }
+}
+
+fun XReadableMap.optArray(name: String, defaultValue: XReadableArray? = null): XReadableArray? {
+    if (!hasKey(name)) {
+        return defaultValue
+    }
+
+    val value = get(name)
+    return if (value.getType() == XReadableType.Array) {
+        value.asArray()
+    } else {
+        defaultValue
+    }
+}
+
+interface XReadableArray {
+    fun size(): Int
+    fun isNull(index: Int): Boolean
+    fun getBoolean(index: Int): Boolean
+    fun getDouble(index: Int): Double
+    fun getInt(index: Int): Int
+    fun getString(index: Int): String
+    fun getArray(index: Int): XReadableArray?
+    fun getMap(index: Int): XReadableMap?
+    fun get(index: Int): XDynamic
+    fun getType(index: Int): XReadableType
+    fun toList(): List<Any?>
+}
+
+fun XReadableArray.toObjectList(): List<Any> {
+    val data = mutableListOf<Any>()
+    for (idx in 0 until size()) {
+        when (getType(idx)) {
+            XReadableType.String -> data.add(getString(idx))
+            XReadableType.Number -> data.add(getDouble(idx))
+            XReadableType.Boolean -> data.add(getBoolean(idx))
+            XReadableType.Int -> data.add(getInt(idx))
+            XReadableType.Map -> {
+                getMap(idx)?.let {
+                    data.add(it.toObjectMap())
+                }
+            }
+            XReadableType.Array -> {
+                getArray(idx)?.let {
+                    data.add(it.toObjectList())
+                }
+            }
+            else -> {
+                //ignore
+            }
+        }
+    }
+    return data
+}
+
+fun XReadableMap.toObjectMap(): Map<String, Any> {
+    val data = mutableMapOf<String, Any>()
+    val iterator = keyIterator()
+    while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        when (getType(key)) {
+            XReadableType.String -> data[key] = getString(key)
+            XReadableType.Number -> data[key] = getDouble(key)
+            XReadableType.Boolean -> data[key] = getBoolean(key)
+            XReadableType.Int -> data[key] = getInt(key)
+            XReadableType.Map -> {
+                getMap(key)?.let {
+                    data[key] = it.toObjectMap()
+                }
+            }
+            XReadableType.Array -> {
+                getArray(key)?.let {
+                    data[key] = it.toObjectList()
+                }
+            }
+            else -> {
+                //ignore
+            }
+        }
+    }
+    return data
+}
+
+interface XDynamic {
+    fun isNull(): Boolean
+    fun getType(): XReadableType
+    fun asBoolean(): Boolean
+    fun asDouble(): Double
+    fun asInt(): Int
+    fun asString(): String
+    fun asArray(): XReadableArray?
+    fun asMap(): XReadableMap?
+    fun recycle()
+}
+
+interface XKeyIterator {
+    fun hasNextKey(): Boolean
+    fun nextKey(): String
+}
+
+enum class XReadableType {
+    Null,
+    Boolean,
+    Number,
+    Int,
+    String,
+    Map,
+    Array
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/core/BridgePlatformType.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.registry.core
+
+/**
+ * Desc:
+ */
+enum class BridgePlatformType {
+    WEB, LYNX, NONE, ALL
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/core/IBridgeContext.kt

@@ -0,0 +1,137 @@
+// 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.core
+
+import android.app.Activity
+import android.content.Context
+import android.view.View
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+import com.tiktok.sparkling.method.registry.core.model.context.IContextProvider
+import com.tiktok.sparkling.method.registry.core.model.context.ContextHolder
+import com.tiktok.sparkling.method.registry.core.model.context.WeakContextHolder
+import com.tiktok.sparkling.method.registry.core.utils.IDLMethodHelper
+import org.json.JSONObject
+import java.lang.ref.WeakReference
+
+interface IBridgeContext {
+    val bridge: SparklingBridge?
+    val view: View?
+    val ownerActivity: Activity?
+    val containerID: String?
+    val context: Context?
+    fun sendEvent(name: String, obj: JSONObject)
+    fun <T> getObject(clazz: Class<T>): T?
+}
+
+interface JSEventDelegate {
+    fun sendJSEvent(eventName: String, params: JSONObject?)
+}
+
+class BridgeContextWrapper : IBridgeContext {
+    private val providers: MutableMap<Class<*>, IContextProvider<*>> = mutableMapOf()
+    private var _view: WeakReference<View?>? = null
+    private var _activity: WeakReference<Activity?>? = null
+    private var _containerID: String? = null
+    private var _jsEvent: JSEventDelegate? = null
+    private var __bridge: WeakReference<SparklingBridge>? = null
+    /**
+     * register object to JSBSDKContext, you can use getSDKContext().getObject(clazz) in JSB method to get it.
+     * there is two-ways to register object to JSBSDKContext: registerObject & registerWeakObject
+     * 1. registerObject register an object to JSBSDKContext. It uses strong references to ensure that objects exist when used.
+     * 2. registerWeakObject register a weakObject to JSBSDKContext.
+     *    It uses weak references to store the object, so when the object is released, maybe you will get a null when you use it.
+     * 3. registerWeakObject has higher priority than registerObject,
+     *    so if you register the same class with object and weakObject, you only can get the weakObject.
+     */
+    fun <T> registerWeakObject(clazz: Class<T>, t: T?) {
+        providers[clazz] = WeakContextHolder(t)
+    }
+    /**
+     * register object to JSBSDKContext, you can use getSDKContext().getObject(clazz) in JSB method to get it.
+     * there is two-ways to register object to JSBSDKContext: registerObject & registerWeakObject
+     * 1. registerObject register an object to JSBSDKContext. It uses strong references to ensure that objects exist when used.
+     * 2. registerWeakObject register a weakObject to JSBSDKContext.
+     *    It uses weak references to store the object, so when the object is released, maybe you will get a null when you use it.
+     * 3. registerWeakObject has higher priority than registerObject,
+     *    so if you register the same class with object and weakObject, you only can get the weakObject.
+     */
+    fun <T> registerObject(clazz: Class<T>, t: T?) {
+        providers[clazz] = ContextHolder(t)
+    }
+    /**
+     * register object to JSBSDKContext, you can use getSDKContext().getObject(clazz) in JSB method to get it.
+     * there is two-ways to register object to JSBSDKContext: registerObject & registerWeakObject
+     * 1. registerObject register an object to JSBSDKContext. It uses strong references to ensure that objects exist when used.
+     * 2. registerWeakObject register a weakObject to JSBSDKContext.
+     *    It uses weak references to store the object, so when the object is released, maybe you will get a null when you use it.
+     * 3. registerWeakObject has higher priority than registerObject,
+     *    so if you register the same class with object and weakObject, you only can get the weakObject.
+     */
+    fun registerWeakObjects(map: Map<Class<*>, WeakContextHolder<*>>) {
+        providers.putAll(map)
+    }
+    /**
+     * register object to JSBSDKContext, you can use getSDKContext().getObject(clazz) in JSB method to get it.
+     * there is two-ways to register object to JSBSDKContext: registerObject & registerWeakObject
+     * 1. registerObject register an object to JSBSDKContext. It uses strong references to ensure that objects exist when used.
+     * 2. registerWeakObject register a weakObject to JSBSDKContext.
+     *    It uses weak references to store the object, so when the object is released, maybe you will get a null when you use it.
+     * 3. registerWeakObject has higher priority than registerObject,
+     *    so if you register the same class with object and weakObject, you only can get the weakObject.
+     */
+    fun registerObjects(map: Map<Class<*>, ContextHolder<*>>) {
+        providers.putAll(map)
+    }
+
+    fun setJSEventDelegate(delegate: JSEventDelegate) {
+        if (_jsEvent == null) {
+            _jsEvent = delegate
+        }
+    }
+
+    fun setView(view: View?) {
+        if (_view == null) {
+            _view = WeakReference(view)
+        }
+    }
+
+    fun setContainerID(containerID: String?) {
+        _containerID = containerID
+    }
+
+    fun setOwnerActivity(activity: Activity?) {
+        if (_activity?.get() == null) {
+            _activity = WeakReference(activity)
+        }
+    }
+
+    fun setBridge(bridge:SparklingBridge) {
+        if (__bridge?.get() == null) {
+            __bridge = WeakReference(bridge)
+        }
+    }
+
+    override val bridge: SparklingBridge?
+        get() = __bridge?.get()
+
+    override val view: View?
+        get() = _view?.get() ?: getObject(View::class.java)
+    override val ownerActivity: Activity?
+        get() = WeakReference(IDLMethodHelper.getActivity(context)).get()
+    override val context: Context?
+        get() = _view?.get()?.context ?: getObject(Context::class.java)
+
+    override fun sendEvent(name: String, obj: JSONObject) {
+        _jsEvent?.sendJSEvent(name, obj)
+    }
+
+    override val containerID: String?
+        get() = _containerID
+
+    override fun <T> getObject(clazz: Class<T>): T? {
+        return providers[clazz]?.provideInstance() as T?
+    }
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/core/IDLBridgeMethod.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.core
+
+import com.tiktok.sparkling.method.registry.core.model.context.ContextProviderFactory
+import com.tiktok.sparkling.method.registry.core.model.idl.IDLMethodBaseParamModel
+import com.tiktok.sparkling.method.registry.core.model.idl.IDLMethodBaseResultModel
+
+/**
+ * Desc:
+ */
+interface IDLBridgeMethod {
+
+    companion object {
+        const val KEY_NOT_FOUND = 2
+        const val SUCCESS = 1
+        const val FAIL = 0 //error code for JSB method
+
+        //error code for sdk
+        const val UNREGISTERED = -2 // UnregisteredMethod, the called method isn't registered, due to legacy error, sdk use BridgeConstants's BRIDGE_NOT_FOUND
+        const val INVALID_PARAM = -3 // InvalidParameter, the parameter passed by FE is invalid
+        const val INVALID_RESULT = -5 // InvalidResult, the result passed by the method implementor is invalid
+        const val BRIDGE_CALL_BE_INTERCEPTED = -10 // bridge call be intercepted
+        const val BRIDGE_CALL_BE_INTERCEPTED_MSG = "intercepted by lifeClient"
+        const val BRIDGE_HAS_BEEN_RELEASED = -13 //bridge has been released
+
+        const val UNKNOWN_ERROR = -1000
+        const val PERMISSION_NO_EXIST = -1128 // internal code, due to legacy error, sdk use BridgeConstants's PERMISSION_NO_EXIST
+        const val ANNOTATION_ERROR = -2000 // when annotation can't get
+        const val ILLEGAL_OPERATION_ERROR = -2001 // when call a illegal method of proxy
+
+        //other error codes
+        const val UNAUTHORIZED_ACCESS = -6 // UnauthorizedAccess, unauthorized to access some resources, like camera, microphone
+        const val CANCELLED = -7 // OperationCancelled, user cancelled certain operation
+        const val OPERATION_TIMEOUT = -8 // OperationTimeout
+        const val NOT_FOUND = -9 // NOT_FOUND
+
+        const val NETWORK_UNREACHABLE = -1001
+        const val NETWORK_TIMEOUT = -1002
+        const val MALFORMEDRESPONSE_ERROR = -1003
+
+        const val PARAM_CODE = "code"
+        const val PARAM_MSG = "msg"
+        const val PARAM_DATA = "data"
+        const val ORIGINAL_RESULT = "originalResult"
+    }
+
+
+    enum class Compatibility(val value: Boolean) {
+        Compatible(true),
+        InCompatible(false)
+    }
+
+    interface Callback {
+        // why do we need hashmap here
+        fun invoke(data: Map<String, Any?>)
+    }
+
+    interface JSEventDelegate {
+        fun sendJSEvent(eventName: String, params: Map<String, Any?>?)
+    }
+
+    fun provideParamModel(): Class<out IDLMethodBaseParamModel>? {
+        return null
+    }
+
+    fun provideResultModel(): Class<out IDLMethodBaseResultModel>? {
+        return null
+    }
+
+    /**
+     * this just for old jsb change to idl with difference format result.
+     * if you set useOriginalResult is true,
+     * you can add your result as a Map<String, any> to the resultModel with key: IDLBridgeMethod.ORIGINAL_RESULT,
+     * we will get it by the key : IDLBridgeMethod.ORIGINAL_RESULT,
+     * or you can also pass the original map<String, any> to callbak, we will pass it to fe directly.
+     */
+    val useOriginalResult: Boolean
+        get() = false
+
+    fun shouldUseOriginalData(bridgeContext: IBridgeContext?): Boolean {
+        return false
+    }
+
+    val compatibility: Compatibility
+        get() = Compatibility.InCompatible
+
+    val name: String
+
+    fun realHandle(params: Map<String, Any?>, callback: Callback, type: BridgePlatformType)
+
+    fun setProviderFactory(contextProviderFactory: ContextProviderFactory?)
+
+    fun setBridgeContext(bridgeContext: IBridgeContext)
+
+    fun release() {}
+}

package/android/src/main/java/com/tiktok/sparkling/method/registry/core/IDLMethodProvider.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.registry.core
+
+/**
+ * Desc:
+ */
+interface IDLMethodProvider {
+    fun provideMethod(): IDLBridgeMethod
+}