@onekeyfe/react-native-chart-webview 3.0.39

package/ChartWebview.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ChartWebview"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-views/react-native-chart-webview.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/ChartWebview+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OneKey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @onekeyfe/react-native-chart-webview
+
+ChartWebview view for React Native
+
+## Installation
+
+```sh
+yarn add @onekeyfe/react-native-chart-webview
+```
+
+## Usage
+
+```js
+import { ChartWebviewView } from '@onekeyfe/react-native-chart-webview';
+
+// ...
+
+<ChartWebviewView color="#ff0000" style={{ width: 100, height: 100 }} />
+```
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(chartwebview)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME chartwebview)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/chartwebview+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,131 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ChartWebview_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/chartwebview+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ChartWebview_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.chartwebview"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+  // WebViewAssetLoader + WebViewClientCompat for offline virtual same-origin
+  // hosting of the local chart bundle from the APK assets.
+  implementation "androidx.webkit:webkit:1.11.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "chartwebviewOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::chartwebview::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/chartwebview/ChartWebview.kt

@@ -0,0 +1,331 @@
+package com.margelo.nitro.chartwebview
+
+import android.graphics.Bitmap
+import android.view.View
+import android.widget.FrameLayout
+import android.widget.ImageView
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.uimanager.ThemedReactContext
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Thin host for a chart WebView. It owns only a container [FrameLayout]; the
+ * real WebView lives in a [PooledChartWebView] which can be **shared** across
+ * hosts that use the same `reuseKey` (singleton via reparenting). The host:
+ *
+ *  - claims the backing WebView into its container when it is attached AND
+ *    active (`isActive != false`), and releases (detaches) it otherwise;
+ *  - forwards page events to its Nitro callbacks while it is the active owner;
+ *  - delegates `postMessage` / `reload` to the backing WebView.
+ *
+ * Ownership arbitration: native attach is the fast claim path; `isActive`
+ * (driven by JS `useIsFocused`) is the authoritative arbiter of who, among
+ * hosts sharing a key, currently displays the single WebView.
+ */
+@DoNotStrip
+class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSpec() {
+
+  companion object {
+    private val instanceIds = AtomicInteger(0)
+    // Substring of the chart's render-ready bridge message (method
+    // 'tradingview_renderReady'); cheaper than JSON-parsing every page message.
+    private const val RENDER_READY_MARKER = "tradingview_renderReady"
+    // Safety-net: reveal the live chart even if the render-ready signal is missed.
+    private const val REVEAL_FALLBACK_MS = 2000L
+    // The one host currently holding a snapshot over a switch, waiting for the
+    // render-ready signal. Shared so render-ready (which arrives on whichever host
+    // owns the WebView at that instant — not necessarily the awaiting one) reveals
+    // the correct host regardless of the owner-handoff timing.
+    private var pendingRevealHost: HybridChartWebview? = null
+  }
+
+  private val instanceId = instanceIds.incrementAndGet()
+
+  // Fabric lays its views out top-down and ignores layout requests from children
+  // we add at runtime (the WebView / placeholder). Without forcing a measure +
+  // layout pass here, those children stay 0x0 and the slot renders blank. This
+  // requestLayout override is the standard RN fix for custom ViewGroups.
+  private inner class ChartContainer(ctx: android.content.Context) : FrameLayout(ctx) {
+    private val relayout = Runnable {
+      measure(
+        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+      )
+      layout(left, top, right, bottom)
+    }
+
+    override fun requestLayout() {
+      super.requestLayout()
+      post(relayout)
+    }
+  }
+
+  private val container: FrameLayout = ChartContainer(context).apply {
+    addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener {
+      override fun onViewAttachedToWindow(v: View) {
+        attached = true
+        scheduleReconcile()
+      }
+
+      override fun onViewDetachedFromWindow(v: View) {
+        attached = false
+        reconcile()
+      }
+    })
+  }
+
+  override val view: View = container
+
+  /** The WebView backing this host (a shared pool entry, or a private one). */
+  private var backing: PooledChartWebView? = null
+  private var attached = false
+
+  // --- Source props ---
+
+  private var _uri: String? = null
+  override var uri: String?
+    get() = _uri
+    set(value) { _uri = value; applySourceIfOwner() }
+
+  private var _localBundle: String? = null
+  override var localBundle: String?
+    get() = _localBundle
+    set(value) { _localBundle = value; applySourceIfOwner() }
+
+  private var _entry: String? = null
+  override var entry: String?
+    get() = _entry
+    set(value) { _entry = value; applySourceIfOwner() }
+
+  private var _paramsJson: String? = null
+  override var paramsJson: String?
+    get() = _paramsJson
+    set(value) { _paramsJson = value; applySourceIfOwner() }
+
+  // Document-start bridge JS (single source of truth in the TS layer). Stored and
+  // handed to the pooled WebView when we claim it, before its first load.
+  private var _bridgeScript: String? = null
+  override var bridgeScript: String?
+    get() = _bridgeScript
+    // Re-apply the source: if this prop lands after the source props (a load can't
+    // run before the bridge is registered, so setSource deferred), this triggers it.
+    set(value) { _bridgeScript = value; applySourceIfOwner() }
+
+  // --- Singleton props ---
+  // `pooled` + non-empty `reuseKey` => the backing WebView is shared (keyed by
+  // reuseKey) across hosts; otherwise the host owns a private WebView.
+  private var _reuseKey: String? = null
+  override var reuseKey: String?
+    get() = _reuseKey
+    set(value) { _reuseKey = value; scheduleReconcile() }
+
+  private var _pooled: Boolean? = null
+  override var pooled: Boolean?
+    get() = _pooled
+    set(value) { _pooled = value; scheduleReconcile() }
+
+  // `active` (JS useIsFocused) decides which host, among those sharing a key,
+  // owns the single WebView. null is treated as active (single-host case).
+  private var _active: Boolean? = null
+  override var active: Boolean?
+    get() = _active
+    set(value) {
+      val wasActive = _active != false
+      _active = value
+      // Becoming active: cover with our last frame NOW (synchronously, before the
+      // JS symbol-change fires this commit) and wait for the chart's render-ready,
+      // so the switch holds the snapshot until the new content paints. Doing it
+      // here rather than in the coalesced reconcile is essential — a cached symbol
+      // can render + signal before the posted reconcile even runs. ownSnapshot is
+      // non-null only for pooled hosts that have been shown before (first show
+      // just reveals the live WebView as it loads).
+      if (value != false && !wasActive && ownSnapshot != null) {
+        showPlaceholder(ownSnapshot)
+        awaitContentReveal()
+      }
+      scheduleReconcile()
+    }
+
+  // --- Event callbacks ---
+  override var onMessage: ((message: String) -> Unit)? = null
+  override var onLoadEnd: (() -> Unit)? = null
+  override var onError: ((message: String) -> Unit)? = null
+
+  // Called by the backing PooledChartWebView while this host is the owner.
+  fun dispatchMessage(message: String) {
+    // The chart reports it has painted the new symbol after a switch; that's our
+    // cue to drop the snapshot we held over the switch and reveal the live chart.
+    if (message.contains(RENDER_READY_MARKER)) onContentRendered()
+    onMessage?.invoke(message)
+  }
+  fun dispatchLoadEnd() { onLoadEnd?.invoke() }
+  fun dispatchError(message: String) { onError?.invoke(message) }
+
+  // --- Methods ---
+  override fun postMessage(message: String) { backing?.postMessage(message) }
+  override fun reload() { backing?.reload() }
+  override fun clearSnapshot() { backing?.clearSnapshot() }
+
+  // --- Ownership reconciliation ---
+
+  private fun isPooled(): Boolean = (_pooled == true) && !_reuseKey.isNullOrEmpty()
+
+  private fun effectiveKey(): String =
+    if (isPooled()) _reuseKey!! else "private:$instanceId"
+
+  private fun wantsOwnership(): Boolean = attached && (_active != false)
+
+  // A single React commit applies props one at a time, so the intermediate
+  // states are inconsistent (e.g. `pooled` re-applied while `active` is still
+  // stale). Reacting to each setter synchronously makes the wrong host claim
+  // mid-commit. Coalesce to ONE reconcile at the end of the run-loop, by which
+  // point every prop in the commit holds its final value.
+  private var reconcileScheduled = false
+  private val reconcileRunnable = Runnable {
+    reconcileScheduled = false
+    reconcile()
+  }
+
+  private fun scheduleReconcile() {
+    if (reconcileScheduled) return
+    reconcileScheduled = true
+    container.post(reconcileRunnable)
+  }
+
+  private fun reconcile() {
+    if (isPooled()) reconcilePooled() else reconcilePrivate()
+  }
+
+  // Pooled: every host sharing the key references the one entry. The active host
+  // displays the live WebView; inactive hosts display the cached frame snapshot
+  // so their slot isn't blank (and the live WebView reparents on hand-off).
+  private fun reconcilePooled() {
+    val entry = ChartWebviewPool.acquireShared(effectiveKey(), context)
+    backing = entry
+    if (wantsOwnership()) {
+      entry.owner = this
+      // Register the document-start bridge before the first load (the prop is set
+      // by now; the pool may have been created earlier by a window-attach reconcile).
+      entry.setBridgeScript(_bridgeScript ?: "")
+      entry.attachTo(container)
+      entry.setSource(_uri, _localBundle, _entry, _paramsJson)
+      // Keep a fresh frame of OUR content while we own the WebView, so that when
+      // we later go inactive (and the shared WebView reloads the other slot's
+      // chart) our slot freezes to its own last frame, not the other content.
+      startOwnCapture()
+      // The snapshot hold/reveal over a switch is driven by the `active` setter +
+      // render-ready, not here. Just keep a held snapshot on top of the freshly
+      // attached WebView, or clear a stale one if we're not holding.
+      if (awaitingReveal) placeholder?.bringToFront() else removePlaceholder()
+    } else {
+      // Inactive: give up ownership only if we still hold it, and freeze to our
+      // own last captured frame. We do NOT detach (that races a rapid re-claim).
+      val wasOwner = entry.owner == this
+      if (wasOwner) entry.owner = null
+      stopOwnCapture()
+      showPlaceholder(ownSnapshot)
+    }
+  }
+
+  // Non-pooled: a private WebView, claimed when active, kept on this host so a
+  // later re-claim reuses it without a reload. No placeholder (single host).
+  private fun reconcilePrivate() {
+    if (!wantsOwnership()) return
+    val pooled = backing ?: PooledChartWebView.create(context, effectiveKey())
+    backing = pooled
+    pooled.owner = this
+    pooled.setBridgeScript(_bridgeScript ?: "")
+    pooled.attachTo(container)
+    pooled.setSource(_uri, _localBundle, _entry, _paramsJson)
+  }
+
+  private fun applySourceIfOwner() {
+    val pooled = backing ?: return
+    if (pooled.owner == this) {
+      // Register the bridge before any load setSource may trigger (setSource
+      // defers loading until the bridge is registered).
+      pooled.setBridgeScript(_bridgeScript ?: "")
+      pooled.setSource(_uri, _localBundle, _entry, _paramsJson)
+    }
+  }
+
+  // --- Per-host snapshot (this host's own last frame, shown while inactive) ---
+
+  private var placeholder: ImageView? = null
+  // OUR content's last frame. Because the WebView is shared and reloads other
+  // slots' charts, we can't read the snapshot off the pooled entry — we keep our
+  // own, captured periodically while we own the WebView.
+  private var ownSnapshot: Bitmap? = null
+
+  private val ownCaptureRunnable = object : Runnable {
+    override fun run() {
+      val entry = backing ?: return
+      if (entry.owner != this@HybridChartWebview) return
+      // Late async results are dropped if we've meanwhile yielded ownership, so
+      // ownSnapshot only ever holds a frame captured while WE were showing.
+      entry.captureNow { bmp ->
+        if (bmp != null && entry.owner == this@HybridChartWebview) ownSnapshot = bmp
+      }
+      container.postDelayed(this, 1200)
+    }
+  }
+
+  private fun startOwnCapture() {
+    container.removeCallbacks(ownCaptureRunnable)
+    container.postDelayed(ownCaptureRunnable, 500)
+  }
+
+  private fun stopOwnCapture() {
+    container.removeCallbacks(ownCaptureRunnable)
+  }
+
+  // --- Reveal coordination: hold the snapshot over a switch until the chart
+  // reports the new symbol has painted (with a safety-net timeout). ---
+
+  private var awaitingReveal = false
+  private val revealFallbackRunnable = Runnable { doReveal() }
+
+  private fun awaitContentReveal() {
+    awaitingReveal = true
+    pendingRevealHost = this
+    container.removeCallbacks(revealFallbackRunnable)
+    // Safety net: if the render-ready signal never arrives, reveal anyway so the
+    // slot can't get stuck on the snapshot.
+    container.postDelayed(revealFallbackRunnable, REVEAL_FALLBACK_MS)
+  }
+
+  // The chart signalled the post-switch render is done (see dispatchMessage).
+  // Reveal whichever host is holding a snapshot — render-ready may land on a
+  // different host than the one waiting, depending on owner-handoff timing.
+  private fun onContentRendered() {
+    pendingRevealHost?.doReveal()
+  }
+
+  private fun doReveal() {
+    if (!awaitingReveal) return
+    awaitingReveal = false
+    if (pendingRevealHost == this) pendingRevealHost = null
+    container.removeCallbacks(revealFallbackRunnable)
+    removePlaceholder()
+  }
+
+  private fun showPlaceholder(bmp: Bitmap?) {
+    if (bmp == null) return
+    val iv = placeholder ?: ImageView(context).apply {
+      scaleType = ImageView.ScaleType.FIT_XY
+      layoutParams = FrameLayout.LayoutParams(
+        FrameLayout.LayoutParams.MATCH_PARENT,
+        FrameLayout.LayoutParams.MATCH_PARENT,
+      )
+      container.addView(this)
+      placeholder = this
+    }
+    iv.setImageBitmap(bmp)
+    iv.bringToFront()
+  }
+
+  private fun removePlaceholder() {
+    placeholder?.let { container.removeView(it) }
+    placeholder = null
+  }
+}

package/android/src/main/java/com/margelo/nitro/chartwebview/ChartWebviewPackage.kt

@@ -0,0 +1,29 @@
+package com.margelo.nitro.chartwebview
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+import com.margelo.nitro.chartwebview.views.HybridChartWebviewManager
+
+class ChartWebviewPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(HybridChartWebviewManager())
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("chartwebview")
+        }
+    }
+}