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

package/README.md

@@ -0,0 +1,39 @@
+# sparkling-method
+
+[![npm version](https://img.shields.io/npm/v/sparkling-method.svg)](https://npmjs.com/package/sparkling-method)
+[![license](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](../../LICENSE)
+
+SDK for building Sparkling methods that bridge JavaScript and native code through LynxPipe.
+
+## Installation
+
+```bash
+npm install sparkling-method@latest
+```
+
+## Usage
+
+```typescript
+import LynxPipe from 'sparkling-method';
+
+// Callback-based call
+LynxPipe.call('methodName', { param: 'value' }, (response) => {
+  console.log(response);
+});
+
+// Promise-based call
+const result = await LynxPipe.callAsync('methodName', { param: 'value' });
+
+// Event handling
+const handler = LynxPipe.on('eventName', (data) => console.log(data));
+LynxPipe.off('eventName', handler);
+```
+
+## API
+
+| Method | Description |
+|--------|-------------|
+| `call(method, params, callback)` | Call native method with callback |
+| `callAsync(method, params)` | Call native method with Promise |
+| `on(event, callback)` | Subscribe to native event |
+| `off(event, callback)` | Unsubscribe from native event |

package/android/build.gradle.kts

@@ -0,0 +1,153 @@
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.tasks.bundling.Jar
+
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.kotlin.android)
+    id("maven-publish")
+    jacoco
+}
+
+android {
+    namespace = "com.tiktok.sparkling.method"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 21
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        debug {
+            enableUnitTestCoverage = true
+        }
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+    
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+            all {
+                it.jvmArgs("-Xmx2048m", "-XX:MaxMetaspaceSize=512m")
+                it.systemProperty("robolectric.logging.enabled", "true")
+            }
+        }
+    }
+}
+
+dependencies {
+
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.appcompat)
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+
+    // Testing dependencies
+    testImplementation("io.mockk:mockk:1.13.8")
+    testImplementation("org.robolectric:robolectric:4.10.3")
+    testImplementation("org.bouncycastle:bcprov-jdk18on:1.75")
+    testImplementation("androidx.test:core:1.5.0")
+    testImplementation("androidx.test.ext:junit:1.1.5")
+    testImplementation("org.mockito:mockito-core:5.2.0")
+    testImplementation("org.mockito:mockito-inline:5.2.0")
+    testImplementation("androidx.test:runner:1.5.2")
+    testImplementation("androidx.test:rules:1.5.0")
+    // Removed PowerMock due to compatibility issues with Robolectric and Java 11
+
+    api(libs.lynx)
+    api("com.google.code.gson:gson:2.8.9")
+}
+
+tasks.register<JacocoReport>("jacocoTestReport") {
+    dependsOn(tasks.named("testDebugUnitTest"))
+
+    reports {
+        xml.required.set(true)
+        html.required.set(true)
+    }
+
+    val fileFilter = listOf(
+        "**/R.class",
+        "**/R$*.class",
+        "**/BuildConfig.*",
+        "**/Manifest*.*",
+        "**/*Test*.*",
+        "android/**/*.*"
+    )
+
+    val mainSrc = "${project.projectDir}/src/main/java"
+    sourceDirectories.setFrom(files(mainSrc))
+
+    val debugJavaTree = layout.buildDirectory.dir("intermediates/javac/debug").map { dir ->
+        dir.asFileTree.matching {
+            exclude(fileFilter)
+        }
+    }
+    val debugKotlinTree = layout.buildDirectory.dir("tmp/kotlin-classes/debug").map { dir ->
+        dir.asFileTree.matching {
+            exclude(fileFilter)
+        }
+    }
+    classDirectories.setFrom(debugJavaTree, debugKotlinTree)
+
+    val unitTestCoverageExec = layout.buildDirectory.file("outputs/unit_test_code_coverage/debugUnitTest/testDebugUnitTest.exec")
+    val jacocoExec = layout.buildDirectory.file("jacoco/testDebugUnitTest.exec")
+    executionData.setFrom(files(unitTestCoverageExec, jacocoExec))
+
+    onlyIf {
+        executionData.files.any { it.exists() }
+    }
+    outputs.upToDateWhen { false }
+}
+
+val publishingGroupId = (findProperty("SPARKLING_PUBLISHING_GROUP_ID") as? String)
+    ?: System.getenv("SPARKLING_PUBLISHING_GROUP_ID")
+    ?: "com.tiktok.sparkling"
+val publishingVersion = (findProperty("SPARKLING_PUBLISHING_VERSION") as? String)
+    ?: System.getenv("SPARKLING_PUBLISHING_VERSION")
+    ?: "1.0.0"
+
+val androidSourcesJar by tasks.register<Jar>("androidSourcesJar") {
+    archiveClassifier.set("sources")
+    from(android.sourceSets.getByName("main").java.srcDirs)
+}
+
+val emptyJavadocJar by tasks.register<Jar>("javadocJar") {
+    archiveClassifier.set("javadoc")
+}
+
+afterEvaluate {
+    extensions.configure<PublishingExtension>("publishing") {
+        publications {
+            create<MavenPublication>("release") {
+                groupId = publishingGroupId
+                artifactId = "sparkling-method"
+                version = publishingVersion
+
+                from(components["release"])
+                artifact(androidSourcesJar)
+                artifact(emptyJavadocJar)
+
+                pom {
+                    name.set("sparkling-method")
+                    description.set("Sparkling method Android SDK module")
+                }
+            }
+        }
+    }
+}

package/android/gradle.properties

@@ -0,0 +1 @@
+SPARKLING_PUBLISHING_VERSION=2.0.0

package/android/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

package/android/src/androidTest/java/com/tiktok/sparkling/sparkling/methods/ExampleInstrumentedTest.kt

@@ -0,0 +1,27 @@
+// 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.sparkling.methods
+
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
+
+import org.junit.Test
+import org.junit.runner.RunWith
+
+import org.junit.Assert.*
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@RunWith(AndroidJUnit4::class)
+class ExampleInstrumentedTest {
+    @Test
+    fun useAppContext() {
+        // Context of the app under test.
+        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+        assertEquals("com.tiktok.sparkling.methods", appContext.packageName)
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+
+</manifest>

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

@@ -0,0 +1,74 @@
+// 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 com.tiktok.sparkling.method.registry.core.BridgePlatformType
+import com.tiktok.sparkling.method.registry.api.BusinessCallHandler
+import com.tiktok.sparkling.method.registry.api.DefaultCallHandler
+import com.tiktok.sparkling.method.registry.api.SparklingBridge
+import com.lynx.tasm.LynxBackgroundRuntime
+import com.lynx.tasm.LynxView
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.handler.BridgeDispatcher
+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.IBridgeMonitor
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeLifeClient
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeProtocol
+
+class BridgeContext {
+    companion object {
+        fun getPlatformByBridgeContext(bridgeContext: BridgeContext): BridgePlatformType {
+            return if (bridgeContext.platform == BridgePlatformType.LYNX) {
+                BridgePlatformType.LYNX
+            } else if (bridgeContext.platform == BridgePlatformType.WEB) {
+                BridgePlatformType.WEB
+            } else {
+                BridgePlatformType.ALL
+            }
+        }
+    }
+
+    var sparklingBridge: SparklingBridge? = null
+    var dispatcher: BridgeDispatcher? = null
+    var bridgeClient = DefaultBridgeClientImp(this)
+    val bridgeLifeClientImp = DefaultBridgeLifeClientImp(this)
+    var lynxView : LynxView? = null
+    var lynxBackgroundRuntime : LynxBackgroundRuntime? = null
+    var containerId : String?  = ""
+    var protocols : MutableList<IBridgeProtocol> = mutableListOf()
+    var monitor : MutableSet<IBridgeMonitor> = mutableSetOf()
+    val defaultCallHandler: DefaultCallHandler = DefaultCallHandler()
+    var businessCallHandler: BusinessCallHandler? = null
+    var jsbMockInterceptor : BridgeMockInterceptor? = null // for JSB Mock
+    var platform: BridgePlatformType = BridgePlatformType.ALL
+
+
+    /**
+     * force on context error, only record view level message in jsbExtension
+     */
+    val errorReportModel: JSBErrorReportModel = JSBErrorReportModel()
+
+    fun registerProtocol(protocol: IBridgeProtocol){
+        protocols.add(protocol)
+    }
+
+    fun getNamespace() = businessCallHandler?.nameSpace
+
+    fun shouldHandleWithBusinessHandler(call: BridgeCall): Boolean {
+        return if (businessCallHandler != null && (call.nameSpace == getNamespace() || call.nameSpace.isEmpty())) {
+            businessCallHandler?.getBridge(this, call.bridgeName) != null
+        } else false
+    }
+
+    fun registerIBridgeLifeClient(bridgeLifeClient: IBridgeLifeClient) {
+        bridgeLifeClientImp.registerIBridgeLifeClient(bridgeLifeClient)
+    }
+
+    fun getCurrentUrl() : String? {
+        return this.lynxView?.templateUrl ?: this.lynxBackgroundRuntime?.lastScriptUrl
+    }
+}

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

@@ -0,0 +1,47 @@
+// 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 com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeClient
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeHandler
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeProtocol
+import com.tiktok.sparkling.method.protocol.utils.LogUtils
+import org.json.JSONObject
+
+/**
+ *  default implementation
+ */
+class DefaultBridgeClientImp(val bridgeContext: BridgeContext): IBridgeClient {
+    private val TAG = "DefaultBridgeClientImp"
+
+    override fun shouldInterceptRequest(call: BridgeCall): BridgeResult? {
+        // TODO: implement by injection
+        return null
+    }
+
+    override fun onBridgeInvoked(protocol: IBridgeProtocol, detail: JSONObject) {
+        // FIXME pending
+    }
+
+    override fun onBridgeDispatched(call: BridgeCall) {
+        LogUtils.e(TAG, "onBridgeCallback: bridgeName: ${call.bridgeName}")
+    }
+
+    override fun onBridgeResultReceived(name: String, handler: IBridgeHandler, detail: JSONObject) {
+        LogUtils.e(TAG, "onBridgeCallback: bridgeName: $name")
+    }
+
+    override fun onBridgeCallback() {
+        LogUtils.e(TAG, "onBridgeCallback")
+    }
+
+    override fun onBridgeRejected() {
+        LogUtils.e(TAG, "onBridgeRejected")
+    }
+
+}

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

@@ -0,0 +1,233 @@
+// 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
+
+import com.tiktok.sparkling.method.registry.core.IDLBridgeMethod
+import com.tiktok.sparkling.method.registry.api.containsPiperData
+import com.lynx.react.bridge.JavaOnlyMap
+import com.tiktok.sparkling.method.protocol.entity.BridgeCall
+import com.tiktok.sparkling.method.protocol.entity.BridgeResult
+import com.tiktok.sparkling.method.protocol.impl.lifecycle.fe.FeCallMonitorModel
+import com.tiktok.sparkling.method.protocol.impl.monitor.MonitorEntity
+import com.tiktok.sparkling.method.protocol.interfaces.IBridgeLifeClient
+import com.tiktok.sparkling.method.protocol.interfaces.ShouldHandleBridgeCallResultModel
+import com.tiktok.sparkling.method.protocol.utils.BridgeConstants
+import com.tiktok.sparkling.method.protocol.utils.BridgeConverter
+
+/**
+ */
+class DefaultBridgeLifeClientImp(bridgeContext: BridgeContext) : IBridgeLifeClient() {
+
+    private var bridgeLifeClients = ArrayList<IBridgeLifeClient>()
+
+    fun registerIBridgeLifeClient(bridgeLifeClient: IBridgeLifeClient) {
+        bridgeLifeClients.add(bridgeLifeClient)
+    }
+
+
+    override fun shouldHandleBridgeCall(
+        call: BridgeCall,
+        bridgeContext: BridgeContext
+    ): ShouldHandleBridgeCallResultModel {
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            val currentHandleModel = it.shouldHandleBridgeCall(call, bridgeContext)
+            if (!currentHandleModel.shouldHandleBridgeCall) {
+               // TODO
+            }
+        }
+        return ShouldHandleBridgeCallResultModel(true, null)
+    }
+
+    override fun onBridgeCalledStart(bridgeCall: BridgeCall, bridgeContext: BridgeContext) {
+        val endConvertParamsTime = System.currentTimeMillis()
+        bridgeCall.jsbSDKErrorReportModel.apply {
+            setJsbBridgeSdk("SparklingBridge")
+            setJsbUrl(bridgeCall.url)
+            setJsbMethodName(bridgeCall.bridgeName)
+            setJsbEngine(bridgeCall.jsbEngine)
+            when (bridgeCall.platform) {
+                BridgeCall.PlatForm.Web -> Unit // TODO: Web related abilities will implement later
+                BridgeCall.PlatForm.Lynx -> setView(bridgeCall.context.lynxView)
+                else -> Unit
+            }
+        }
+
+        bridgeCall.feCallMonitorModel.view = bridgeContext.lynxView
+        bridgeCall.feCallMonitorModel.jsbNativeCallStart = System.currentTimeMillis()
+        bridgeCall.feCallMonitorModel.bridgeName = bridgeCall.bridgeName
+        bridgeCall.feCallMonitorModel.containerID = bridgeContext.containerId
+
+        when (bridgeCall.platform) {
+            BridgeCall.PlatForm.Web -> {
+                // TODO: Web related abilities will implement later
+            }
+
+            else -> {
+                (bridgeCall.params as? JavaOnlyMap)?.let { params ->
+                    (params?.getMap("data") ?: params).getMap(FeCallMonitorModel._JSB_CALLER_INFO)
+                        ?.asHashMap()?.forEach {
+                            bridgeCall.feCallMonitorModel.addCategory(
+                                "${FeCallMonitorModel.CALLER_PREFIX}${it.key}",
+                                it.value
+                            )
+                        }
+                    (params?.getMap("data") ?: params).getMap(FeCallMonitorModel._JSB_PERF_METRICS)
+                        ?.asHashMap()?.let {
+                            it.get(FeCallMonitorModel.JSB_FUNC_CALL_START).let {
+                                if (it is Long) {
+                                    bridgeCall.feCallMonitorModel.jsbFuncCallStart = it
+                                }
+                            }
+                            it.get(FeCallMonitorModel.JSB_FUNC_CALL_END).let {
+                                if (it is Long) {
+                                    bridgeCall.feCallMonitorModel.jsbFuncCallEnd = it
+                                }
+                            }
+                        }
+
+                }
+            }
+        }
+
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeCalledStart(bridgeCall, bridgeContext)
+        }
+    }
+
+    override fun onBridgeImplHandleStart(call: BridgeCall?, bridgeContext: BridgeContext) {
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeImplHandleStart(call, bridgeContext)
+        }
+    }
+
+    override fun onBridgeImplHandleEnd(call: BridgeCall?, bridgeContext: BridgeContext) {
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeImplHandleEnd(call, bridgeContext)
+        }
+    }
+
+    override fun onBridgeCallbackCallStart(
+        result: BridgeResult,
+        call: BridgeCall,
+        mContext: BridgeContext
+    ) {
+        when (call.platform) {
+            BridgeCall.PlatForm.Web -> {
+                // TODO
+            }
+
+            BridgeCall.PlatForm.Lynx -> {
+
+            }
+
+            else -> {}
+        }
+
+
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeCallbackCallStart(result, call, mContext)
+        }
+    }
+
+    override fun onBridgeCallbackInvokeStart(result: BridgeResult, call: BridgeCall) {
+
+        when (call.platform) {
+            BridgeCall.PlatForm.Web -> {
+               // TODO
+            }
+
+            BridgeCall.PlatForm.Lynx -> {
+                call.lynxCallbackMap?.let { map ->
+                    val monitor = MonitorEntity().apply {
+                        name = call?.bridgeName
+                        url = call?.url
+                        beginTime = call?.timestamp
+                        endTime = System.currentTimeMillis()
+                        if (map.hasKey("code")) {
+                            val code = map.getInt("code", IDLBridgeMethod.UNKNOWN_ERROR)
+                            if (code != IDLBridgeMethod.UNKNOWN_ERROR) this.code = code
+                        }
+                        message = map.getString("msg", "")
+
+                        rawResult = BridgeConverter.revertJavaOnlyMap2JSONObject(map).apply {
+                            put("usePiperData", map.containsPiperData())
+                            put("bridgeCallThreadType", call.bridgeCallThreadType)
+                        }
+                        call.params?.let {
+                            rawRequest =
+                                BridgeConverter.revertJavaOnlyMap2JSONObject(call.params as JavaOnlyMap)
+                        }
+                        hitBusinessHandler = call?.hitBusinessHandler ?: false
+                        nameSpace = call?.nameSpace
+                        isRunInMainThread = call.isInMainThread
+                    }
+                    if (monitor.code == BridgeConstants.BRIDGE_CALL_SUCCESS) {
+                        call.context.monitor.forEach {
+                            it.onBridgeResolved(monitor)
+                        }
+                    } else {
+                        call.context.monitor.forEach {
+                            it.onBridgeRejected(monitor)
+                        }
+                        call.jsbSDKErrorReportModel.apply {
+                            setJsbErrorCode(monitor.code)
+                            putJsbExtension("error_message", monitor.message)
+                            putJsbExtension("bridgeCallThreadType", call.bridgeCallThreadType)
+                        }
+                        call.jsbSDKErrorReportModel.reportJSBErrorModel(call.context.errorReportModel)
+                    }
+                }
+            }
+
+            else -> {}
+        }
+
+
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeCallbackInvokeStart(result, call)
+        }
+
+        call.feCallMonitorModel.jsbCallbackStart = System.currentTimeMillis()
+    }
+
+    override fun onBridgeCalledEnd(call: BridgeCall, bridgeContext: BridgeContext) {
+
+        when (call.platform) {
+            BridgeCall.PlatForm.Web -> {
+                // TODO
+            }
+            else -> {}
+        }
+
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeCalledEnd(call, bridgeContext)
+        }
+        call.feCallMonitorModel.jsbCallbackEnd = System.currentTimeMillis()
+        call.feCallMonitorModel.reportFeCallInfo()
+    }
+
+    //Event
+    override fun onBridgeEventStart(eventName: String, data: Any?) {
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeEventStart(eventName, data)
+        }
+    }
+
+    override fun onBridgeEventEnd(eventName: String, data: Any?) {
+        //call other lifeClient
+        bridgeLifeClients.forEach {
+            it.onBridgeEventEnd(eventName, data)
+        }
+    }
+}