react-native-vroom-chart 0.16.0 → 0.18.0

package/README.md

@@ -15,7 +15,7 @@ import { VroomChart } from 'react-native-vroom-chart';
 
 ## Peer dependencies
 
-- `react-native` ≥ 0.76
+- `react-native` ≥ 0.78, New Architecture enabled — the chart installs its JSI bindings through the TurboModule JSI-bindings hooks, which have no legacy-bridge equivalent
 - `@shopify/react-native-skia` ≥ 2.11.0 — provides the Skia runtime we draw into. vroom links RN-Skia's native internals (`cpp/api`) and tracks that package closely; those headers have no semver guarantee.
 
 - `react-native-gesture-handler` ≥ 2.16 — long-press / pan / pinch recognition

package/android/CMakeLists.txt

@@ -2,7 +2,8 @@
 #
 # Builds libvroomchart.so from the same platform-agnostic JSI glue and chart
 # core the iOS podspec compiles (see ../react-native-vroom-chart.podspec),
-# plus this directory's small JNI entry point (src/main/cpp/VroomChartJni.cpp).
+# plus this directory's fbjni entry points (src/main/cpp/OnLoad.cpp and
+# src/main/cpp/VroomChartJsiBindings.cpp).
 #
 # RN-Skia's headers (JsiSkNativeObjects.h, JsiSkPicture.h, and the
 # RNSkPlatformContext.h they pull in) aren't consumed via CMake's prefab
@@ -27,6 +28,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
 # Prefab package name matches the Gradle project name AGP autolinking assigns
 # RN-Skia (":shopify_react-native-skia"), not the "rnskia" module name inside
 # its own `prefab { rnskia { ... } }` block — that block key becomes the
@@ -70,7 +72,8 @@ add_library(vroomchart SHARED
   "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomChartHostObject.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomFontMgr.cpp"
   ${VROOM_CORE_SOURCES}
-  "${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/VroomChartJni.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/VroomChartJsiBindings.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/OnLoad.cpp"
 )
 
 target_include_directories(vroomchart PRIVATE
@@ -132,9 +135,16 @@ target_link_options(vroomchart PRIVATE
     "-Wl,-z,common-page-size=16384"
 )
 
+# BindingsInstallerHolder's constructors are compiled into libreactnative.so
+# (RN folds the turbomodulejsijni object library into it), so linking
+# ReactAndroid::reactnative is what resolves the newObjectCxxArgs instantiation
+# in src/main/cpp/VroomChartJsiBindings.cpp. fbjni supplies the JavaClass /
+# registerNatives machinery that wraps it.
 target_link_libraries(vroomchart
   ${VROOM_LOG_LIB}
   ReactAndroid::jsi
+  ReactAndroid::reactnative
+  fbjni::fbjni
   shopify_react-native-skia::rnskia
   vroom_skia_prebuilt
 )

package/android/README.md

@@ -1,12 +1,22 @@
 # Android bridge
 
 Android equivalent of `../ios/`: a small TurboModule
-([`VroomChartModule.kt`](src/main/java/com/vroom/chart/VroomChartModule.kt)) whose
-`install()` hands the JSI runtime pointer to a native `vroomchart` library
-(built by [`CMakeLists.txt`](CMakeLists.txt)) that installs
-`global.VroomChartJSI` via the same platform-agnostic
-[`../cpp/VroomJsiInstaller.cpp`](../cpp/VroomJsiInstaller.cpp) the iOS bridge
-uses.
+([`VroomChartModule.kt`](src/main/java/com/vroom/chart/VroomChartModule.kt))
+implementing `TurboModuleWithJSIBindings`. `TurboModuleManager` calls its
+`getBindingsInstaller()` when it instantiates the module and runs the returned
+holder against the JSI runtime, which installs `global.VroomChartJSI` via the
+same platform-agnostic
+[`../cpp/VroomJsiInstaller.cpp`](../cpp/VroomJsiInstaller.cpp) the iOS module
+uses. The native `vroomchart` library (built by
+[`CMakeLists.txt`](CMakeLists.txt)) binds that method in
+[`src/main/cpp/VroomChartJsiBindings.cpp`](src/main/cpp/VroomChartJsiBindings.cpp),
+registered from [`src/main/cpp/OnLoad.cpp`](src/main/cpp/OnLoad.cpp).
+
+This replaced an earlier `install()`-driven path that read the runtime pointer
+out of `ReactContext.javaScriptContextHolder`. That still works on current
+React Native, but the bindings hook is the supported entry point and matches
+what iOS now has to do — `[RCTBridge currentBridge]` returns `nil` once
+`RCT_REMOVE_LEGACY_ARCH` is on, which is the default from React Native 0.85.
 
 The chart core (`../cpp/_core_src`) and the platform font-manager helper
 (`../cpp/VroomFontMgr.*`) are unmodified and shared across iOS and Android —

package/android/build.gradle

@@ -108,6 +108,16 @@ android {
     }
   }
 
+  // prefab copies every consumed module's .so into our intermediates. RN and
+  // RN-Skia already ship these in their own AARs, so packaging a second copy
+  // here makes app assembly fail on duplicate libraries.
+  packagingOptions {
+    exclude "**/libc++_shared.so"
+    exclude "**/libfbjni.so"
+    exclude "**/libjsi.so"
+    exclude "**/libreactnative.so"
+  }
+
   lintOptions {
     abortOnError false
   }

package/android/src/main/cpp/OnLoad.cpp

@@ -0,0 +1,10 @@
+#include <jni.h>
+
+#include <fbjni/fbjni.h>
+
+#include "VroomChartJsiBindings.h"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* /*reserved*/) {
+  return facebook::jni::initialize(
+      vm, [] { vroom::VroomChartJsiBindings::registerNatives(); });
+}

package/android/src/main/cpp/VroomChartJsiBindings.cpp

@@ -0,0 +1,35 @@
+#include "VroomChartJsiBindings.h"
+
+#include <memory>
+
+#include <jsi/jsi.h>
+
+#include "VroomJsiInstaller.h"
+
+namespace vroom {
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+using facebook::react::BindingsInstallerHolder;
+using facebook::react::CallInvoker;
+
+void VroomChartJsiBindings::registerNatives() {
+  // makeNativeMethod is a macro, so it cannot be namespace-qualified.
+  javaClassLocal()->registerNatives({
+      makeNativeMethod(
+          "getBindingsInstaller",
+          VroomChartJsiBindings::getBindingsInstaller),
+  });
+}
+
+jni::local_ref<BindingsInstallerHolder::javaobject>
+VroomChartJsiBindings::getBindingsInstaller(
+    jni::alias_ref<VroomChartJsiBindings> /*jobj*/) {
+  // callInvoker is unused: every chart call is synchronous on the JS thread.
+  return BindingsInstallerHolder::newObjectCxxArgs(
+      [](jsi::Runtime& runtime, const std::shared_ptr<CallInvoker>&) {
+        installJsi(runtime);
+      });
+}
+
+}  // namespace vroom

package/android/src/main/cpp/VroomChartJsiBindings.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <ReactCommon/BindingsInstallerHolder.h>
+#include <fbjni/fbjni.h>
+
+namespace vroom {
+
+// Binds com.vroom.chart.VroomChartModule.getBindingsInstaller() (see
+// ../java/com/vroom/chart/VroomChartModule.kt) to C++. The holder it returns
+// is invoked by TurboModuleManager with the JSI runtime, which is where
+// vroom::installJsi() runs. This is the Android counterpart of iOS's
+// -installJSIBindingsWithRuntime:callInvoker: in ../../ios/VroomChartModule.mm.
+class VroomChartJsiBindings
+    : public facebook::jni::JavaClass<VroomChartJsiBindings> {
+ public:
+  static constexpr const char* kJavaDescriptor =
+      "Lcom/vroom/chart/VroomChartModule;";
+
+  static void registerNatives();
+
+ private:
+  static facebook::jni::local_ref<
+      facebook::react::BindingsInstallerHolder::javaobject>
+  getBindingsInstaller(facebook::jni::alias_ref<VroomChartJsiBindings> jobj);
+};
+
+}  // namespace vroom

package/android/src/main/java/com/vroom/chart/VroomChartModule.kt

@@ -1,19 +1,24 @@
 package com.vroom.chart
 
+import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
+import com.facebook.react.turbomodule.core.interfaces.TurboModuleWithJSIBindings
 
-// TurboModule counterpart to ../../ios/VroomChartModule.mm. `install()` hands
-// the JSI runtime pointer to the native `vroomchart` library (see
-// ../../CMakeLists.txt), which installs `global.VroomChartJSI` via the same
-// platform-agnostic vroom::installJsi() the iOS bridge calls.
+// TurboModule counterpart to ../../ios/VroomChartModule.mm. TurboModuleManager
+// calls getBindingsInstaller() when it instantiates this module and runs the
+// returned installer against the JSI runtime, which exposes
+// `global.VroomChartJSI` via the same platform-agnostic vroom::installJsi()
+// the iOS module calls. Implemented in ../../cpp/VroomChartJsiBindings.cpp and
+// bound by ../../cpp/OnLoad.cpp.
 //
 // `NativeVroomChartSpec` is generated by React Native's codegen from
 // ../../../src/NativeVroomChart.ts (codegenConfig.android.javaPackageName in
 // package.json) — the same class name iOS's codegen generates.
 @ReactModule(name = NativeVroomChartSpec.NAME)
 class VroomChartModule(reactContext: ReactApplicationContext) :
-    NativeVroomChartSpec(reactContext) {
+    NativeVroomChartSpec(reactContext), TurboModuleWithJSIBindings {
 
   companion object {
     init {
@@ -21,11 +26,10 @@ class VroomChartModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  private external fun nativeInstall(runtimePointer: Long): Boolean
+  @DoNotStrip external override fun getBindingsInstaller(): BindingsInstallerHolder
 
-  override fun install(): Boolean {
-    val runtimePointer =
-        reactApplicationContext.javaScriptContextHolder?.get() ?: return false
-    return nativeInstall(runtimePointer)
-  }
+  // Reaching this module from JS means TurboModuleManager already ran the
+  // installer above. JS verifies global.VroomChartJSI itself rather than
+  // trusting this return value — see ../../../src/useChartCore.ts.
+  override fun install(): Boolean = true
 }

package/cpp/VroomChartHostObject.cpp

@@ -58,6 +58,10 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "preservePriceEnvelope"));
   out.push_back(jsi::PropNameID::forAscii(rt, "beginIntervalMorph"));
   out.push_back(jsi::PropNameID::forAscii(rt, "beginStreamMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setLoading"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "beginLoadingMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setLoadingMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "beginLoadingReveal"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setIntervalMorph"));
   out.push_back(jsi::PropNameID::forAscii(rt, "pan"));
   out.push_back(jsi::PropNameID::forAscii(rt, "translate"));
@@ -532,6 +536,83 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setLoading") {
+    // setLoading(on, animate?) — show or hide the loading line. `on` must mean
+    // "loading *and* holding no data"; the core takes it at face value.
+    // `animate` defaults to true; pass false for reduced motion.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setLoading"),
+        2,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1) return jsi::Value::undefined();
+          const bool on = args[0].isBool() ? args[0].getBool()
+                                           : args[0].asNumber() != 0;
+          bool animate = true;
+          if (count >= 2 && !args[1].isUndefined() && !args[1].isNull()) {
+            animate = args[1].isBool() ? args[1].getBool()
+                                       : args[1].asNumber() != 0;
+          }
+          vroom_chart_set_loading(chart_, on ? 1 : 0, animate ? 1 : 0);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "beginLoadingMorph") {
+    // beginLoadingMorph() — hand-off stage one: aim the loading line at the
+    // centres of the candles that just landed. Call *after* setCandles, then
+    // drive setLoadingMorph from 0 to 1.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "beginLoadingMorph"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_begin_loading_morph(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setLoadingMorph") {
+    // setLoadingMorph(t) — advance stage one. 0 = the frozen sine, 1 = the
+    // polyline through the candle centres.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setLoadingMorph"),
+        1,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1) return jsi::Value::undefined();
+          vroom_chart_set_loading_morph(
+              chart_, static_cast<float>(args[0].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "beginLoadingReveal") {
+    // beginLoadingReveal() — hand-off stage two: collapse every candle onto the
+    // line at zero alpha so it grows outward from there. Call once stage one
+    // reaches 1, then drive setIntervalMorph from 0 to 1.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "beginLoadingReveal"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_begin_loading_reveal(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "setIntervalMorph") {
     // setIntervalMorph(t) — advance the capture toward the new candles. `t` is
     // pre-eased progress: 0 = the captured frame, 1 = settled (capture freed).

package/cpp/VroomJsiInstaller.cpp

@@ -75,6 +75,12 @@ static void ensureAxisTypeface() {
 }
 
 void installJsi(jsi::Runtime& runtime) {
+  // Honor the idempotence the header promises: re-running this would replace
+  // the global with a fresh `create`, orphaning handles JS already holds.
+  if (runtime.global().hasProperty(runtime, "VroomChartJSI")) {
+    return;
+  }
+
   ensureAxisTypeface();
 
   auto create = jsi::Function::createFromHostFunction(

package/cpp/_core_include/vroom/vroom_chart.h

@@ -438,6 +438,9 @@ typedef enum {
     VROOM_COLOR_ACCENT_BULL,       // generic up color: price indicator, volume, MACD
     VROOM_COLOR_ACCENT_BEAR,       // generic down color
     VROOM_COLOR_LINE,              // line-chart-mode close-price polyline
+    // The loading line. Its own alpha is honored, then scaled by the fade-in
+    // and the stage-3 fade-out, so an opaque color here is the usual choice.
+    VROOM_COLOR_SKELETON,
     VROOM_COLOR_COUNT_
 } VroomColorKey;
 
@@ -586,6 +589,44 @@ void vroom_chart_begin_interval_morph(VroomChart* chart, int32_t mode);
 // translate.
 void vroom_chart_begin_stream_morph(VroomChart* chart);
 
+// Shows or hides the loading line: a single stroke drawn across the plot in a
+// slow travelling sine, for a chart that has been laid out but has no data yet.
+// Suppresses the axis text, price badge, crosshair and indicator panes for as
+// long as it's up.
+//
+// `on` must mean "loading *and* holding no data for the series being shown";
+// the core takes it at face value rather than checking the candle buffer,
+// because a host mid-asset-switch can still be holding the previous asset's
+// bars. Pass `animate` 0 for reduced motion: the line draws still, and the
+// chart is allowed to go idle instead of pinning a redraw loop.
+//
+// Passing 0 abandons any hand-off in flight, which is what a failed or
+// superseded fetch wants. To hand off to data instead, use the two stages
+// below.
+void vroom_chart_set_loading(VroomChart* chart, int32_t on, int32_t animate);
+
+// Hand-off stage one: reshapes the line into the series. Freezes the sine where
+// it is and aims each vertex at the vertical centre of the candle that will
+// occupy its column, so the line resolves into the silhouette of the data.
+//
+// Call *after* set_candles — it reads them to know where to aim — then drive
+// vroom_chart_set_loading_morph from 0 to 1. The axes and the candles stay
+// suppressed throughout; stage two brings them in. No-op if the line isn't up.
+void vroom_chart_begin_loading_morph(VroomChart* chart);
+
+// Advances stage one. `t` (clamped to 0..1) is the eased progress: 0 renders the
+// frozen sine, 1 the polyline through the candle centres.
+void vroom_chart_set_loading_morph(VroomChart* chart, float t);
+
+// Hand-off stage two: the candles take over. Captures each one collapsed onto
+// its own vertical centre at zero alpha and leaves the loading state, so the
+// bars grow outward from the line and their color fades up as it fades out.
+//
+// Call once stage one has reached 1, then drive vroom_chart_set_interval_morph
+// from 0 to 1 as usual — the line's fade-out rides that same clock, so the two
+// finish together. No-op if the line isn't up.
+void vroom_chart_begin_loading_reveal(VroomChart* chart);
+
 // Advances the morph started by either begin_*_morph above. `t` (clamped to
 // 0..1) is the eased progress: 0 renders the captured geometry pixel-identically
 // to the pre-swap frame, 1 renders the new candles and releases the capture.

package/cpp/_core_src/candles.cpp

@@ -9,6 +9,7 @@
 
 #include <algorithm>
 
+#include "color_lerp.h"
 #include "theme.h"
 #include "viewport.h"
 
@@ -21,18 +22,6 @@ inline uint32_t resolve_color(uint32_t color, uint32_t fill) {
     return (color >> 24) == 0 ? fill : color;
 }
 
-// Channel-wise ARGB blend, for a candle that changes direction mid-morph.
-inline uint32_t lerp_argb(uint32_t a, uint32_t b, float t) {
-    uint32_t out = 0;
-    for (int shift = 0; shift < 32; shift += 8) {
-        const float ca = static_cast<float>((a >> shift) & 0xFFu);
-        const float cb = static_cast<float>((b >> shift) & 0xFFu);
-        const auto v = static_cast<uint32_t>(ca + (cb - ca) * t + 0.5f);
-        out |= v << shift;
-    }
-    return out;
-}
-
 inline uint32_t scale_alpha(uint32_t argb, float a) {
     const auto alpha =
         static_cast<uint32_t>(static_cast<float>((argb >> 24) & 0xFFu) * a + 0.5f);
@@ -90,6 +79,7 @@ void draw(SkCanvas* canvas,
 
     const uint32_t fill_bull = theme.colors[VROOM_COLOR_BULL];
     const uint32_t fill_bear = theme.colors[VROOM_COLOR_BEAR];
+    const uint32_t skeleton_color = theme.colors[VROOM_COLOR_SKELETON];
 
     const float body_r = theme.floats[VROOM_FLOAT_CANDLE_RADIUS_PX];
     const bool wick_round = theme.floats[VROOM_FLOAT_WICK_ROUND_CAP] > 0.5f;
@@ -207,10 +197,21 @@ void draw(SkCanvas* canvas,
         bool draw_border = bull ? draw_border_bull : draw_border_bear;
 
         const bool flip = frm && to && frm->bull != bull;
-        if (flip || alpha < 0.999f) {
+        // A slot handed over from the loading skeleton starts grey, whatever its
+        // direction — so it takes the per-slot path from a different origin
+        // color than a flip does, and overrides it when both apply.
+        const bool from_skeleton = frm && to && frm->skeleton;
+        if (flip || from_skeleton || alpha < 0.999f) {
             const auto blend = [&](uint32_t c_bull, uint32_t c_bear) {
                 uint32_t c = bull ? c_bull : c_bear;
-                if (flip) c = lerp_argb(bull ? c_bear : c_bull, c, morph_t);
+                if (from_skeleton) {
+                    // lerp_argb covers the alpha channel too, so the bar's
+                    // opacity rides in on the same blend as its color.
+                    c = lerp_argb(scale_alpha(skeleton_color, frm->skeleton_alpha),
+                                  c, morph_t);
+                } else if (flip) {
+                    c = lerp_argb(bull ? c_bear : c_bull, c, morph_t);
+                }
                 return scale_alpha(c, alpha);
             };
             slot_wick = *wick_p;