react-native-vroom-chart 0.5.0 → 0.7.0

package/android/CMakeLists.txt

@@ -0,0 +1,143 @@
+# android/CMakeLists.txt
+#
+# 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).
+#
+# RN-Skia's headers (JsiSkHostObjects.h, RNSkPlatformContext.h — needed by
+# ../cpp/VroomSkiaContext.cpp) aren't consumed via CMake's prefab mechanism;
+# instead we point directly at @shopify/react-native-skia's `cpp/` sources,
+# mirroring the podspec's `require.resolve('@shopify/react-native-skia/package.json')`
+# trick (VROOM_SKIA_CPP_DIR is computed the same way in build.gradle).
+#
+# IMPORTANT — SK_GRAPHITE ABI note: RNSkPlatformContext's vtable layout
+# differs depending on whether SK_GRAPHITE was defined when RN-Skia's own
+# Android build compiled RNSkAndroidPlatformContext (the concrete class whose
+# vtable we call into via VroomSkiaContext.cpp's `ctx->createFontMgr()`).
+# We must define SK_GRAPHITE identically to however RN-Skia's own CMakeLists
+# (android/CMakeLists.txt) decided it, or virtual calls resolve to the wrong
+# vtable slot. We replicate their libskia.a symbol probe below rather than
+# hard-coding an assumption.
+cmake_minimum_required(VERSION 3.22)
+project(vroomchart)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+find_package(ReactAndroid 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
+# `shopify_react-native-skia::rnskia` *target* name below, not the package.
+find_package(shopify_react-native-skia REQUIRED CONFIG)
+
+if(NOT DEFINED VROOM_SKIA_CPP_DIR)
+  message(FATAL_ERROR "VROOM_SKIA_CPP_DIR not set — passed from android/build.gradle.")
+endif()
+
+# RN-Skia's own package root is one level up from its cpp/ dir; its prebuilt
+# Skia static libs live at <root>/libs/android/<abi>/libskia.a.
+get_filename_component(VROOM_SKIA_PKG_DIR "${VROOM_SKIA_CPP_DIR}" DIRECTORY)
+set(VROOM_SKIA_LIBS_DIR "${VROOM_SKIA_PKG_DIR}/libs/android/${ANDROID_ABI}")
+
+# Our chart core calls Skia types (SkCanvas, SkPaint, SkFont, ...) and
+# RN-Skia's own JSI plumbing (RNJsi::JsiHostObject, JsiSkPicture, ...)
+# directly — none of that is header-only, and we need *both* libraries:
+#   - librnskia.so (RN-Skia's prefab-published `rnskia` module, consumed above
+#     via `implementation project(":shopify_react-native-skia")`) for RNJsi's
+#     own symbols (JsiHostObject, JsiSkPicture, ...), which only exist there.
+#   - libskia.a (RN-Skia's bundled prebuilt Skia static lib) for direct Skia
+#     calls (SkCanvas::drawRect, SkFont, ...): librnskia.so links libskia.a
+#     internally but doesn't re-export its symbols, so linking librnskia.so
+#     alone leaves every direct Skia call undefined.
+# Recompiling RN-Skia's cpp/jsi/*.cpp ourselves instead of linking librnskia.so
+# was considered and rejected — it would duplicate RNJsi's symbols (and their
+# static/global state) across two separately-loaded .so's, which is fine on
+# iOS's single static binary but not here.
+add_library(vroom_skia_prebuilt STATIC IMPORTED)
+set_property(TARGET vroom_skia_prebuilt PROPERTY
+  IMPORTED_LOCATION "${VROOM_SKIA_LIBS_DIR}/libskia.a")
+
+set(SK_GRAPHITE_AVAILABLE OFF)
+if(EXISTS "${VROOM_SKIA_LIBS_DIR}/libskia.a")
+  execute_process(
+    COMMAND nm "${VROOM_SKIA_LIBS_DIR}/libskia.a"
+    COMMAND grep "dawn::\\|wgpu\\|_ZN4dawn\\|DawnDevice\\|dawn_native"
+    OUTPUT_VARIABLE VROOM_NM_OUTPUT
+    ERROR_QUIET
+    RESULT_VARIABLE VROOM_NM_RESULT
+  )
+  if(VROOM_NM_RESULT EQUAL 0 AND NOT "${VROOM_NM_OUTPUT}" STREQUAL "")
+    set(SK_GRAPHITE_AVAILABLE ON)
+  endif()
+endif()
+
+# The chart core (shared across iOS/Android/WASM — see ../../core/CMakeLists.txt).
+set(VROOM_CORE_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/_core_include")
+set(VROOM_CORE_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/_core_src")
+file(GLOB VROOM_CORE_SOURCES CONFIGURE_DEPENDS "${VROOM_CORE_SRC_DIR}/*.cpp")
+
+add_library(vroomchart SHARED
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomJsiInstaller.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomChartHostObject.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomSkiaContext.cpp"
+  ${VROOM_CORE_SOURCES}
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/VroomChartJni.cpp"
+)
+
+target_include_directories(vroomchart PRIVATE
+  "${VROOM_CORE_INCLUDE_DIR}"
+  "${VROOM_CORE_SRC_DIR}"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp"
+  # RN-Skia headers — mirrors its own android/CMakeLists.txt include list.
+  "${VROOM_SKIA_CPP_DIR}"
+  "${VROOM_SKIA_CPP_DIR}/api"
+  "${VROOM_SKIA_CPP_DIR}/jsi"
+  "${VROOM_SKIA_CPP_DIR}/rnskia"
+  "${VROOM_SKIA_CPP_DIR}/rnskia/values"
+  "${VROOM_SKIA_CPP_DIR}/utils"
+  "${VROOM_SKIA_CPP_DIR}/skia"
+  "${VROOM_SKIA_CPP_DIR}/dawn/include"
+  # RNSkPlatformContext.h pulls in ReactCommon/CallInvoker.h directly, which
+  # isn't part of the prefab-published jsi headers — same dirs RN-Skia's own
+  # android/CMakeLists.txt adds for the same reason.
+  "${REACT_NATIVE_DIR}/ReactCommon"
+  "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+  "${REACT_NATIVE_DIR}/ReactCommon/runtimeexecutor"
+)
+
+target_compile_definitions(vroomchart PRIVATE
+  SK_BUILD_FOR_ANDROID
+  SK_DISABLE_LEGACY_SHAPER_FACTORY
+  SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API
+  ONANDROID
+  ON_ANDROID
+)
+if(SK_GRAPHITE_AVAILABLE)
+  target_compile_definitions(vroomchart PRIVATE SK_GRAPHITE)
+else()
+  target_compile_definitions(vroomchart PRIVATE SK_GL SK_GANESH)
+endif()
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
+  include("${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
+  target_compile_reactnative_options(vroomchart PRIVATE)
+else()
+  target_compile_options(vroomchart PRIVATE -fexceptions -frtti -std=c++20 -Wall)
+endif()
+
+# ../cpp/_core_include/vroom/vroom_chart.h forward-declares `struct SkCanvas;`
+# (to keep the public C facade header Skia-free); Skia itself declares
+# `class SkCanvas`. This tag mismatch is harmless but react-native-flags.cmake
+# enables -Werror, which would otherwise turn it into a build failure.
+target_compile_options(vroomchart PRIVATE -Wno-mismatched-tags)
+
+find_library(VROOM_LOG_LIB log)
+
+target_link_libraries(vroomchart
+  ${VROOM_LOG_LIB}
+  ReactAndroid::jsi
+  shopify_react-native-skia::rnskia
+  vroom_skia_prebuilt
+)

package/android/README.md

@@ -1,7 +1,62 @@
-# Android shim (placeholder)
+# Android bridge
 
-When native is wired up, this directory will hold the JNI bindings and a
-Java/Kotlin view that hosts the chart and forwards gestures into the C++ core.
+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.
 
-`build.gradle` (also to come) will compile `cpp/` + this directory + the
-linked `@vroomchart/core` static library via CMake.
+The chart core itself (`../cpp/_core_src`) and the RN-Skia font/context glue
+(`../cpp/VroomSkiaContext.*`) are unmodified and shared across iOS and
+Android — only the platform glue (this directory + `../ios/`) differs.
+`../cpp/VroomChartHostObject.cpp` has one small `#if defined(__ANDROID__)`
+branch (see "Cross-`.so` Skia objects" below).
+
+`build.gradle` resolves `@shopify/react-native-skia`'s `cpp/` sources via
+Node module resolution (mirroring `../react-native-vroom-chart.podspec`'s
+`require.resolve` trick) so `VroomSkiaContext.cpp` can include RN-Skia's
+`JsiSkHostObjects.h` / `RNSkPlatformContext.h`. `CMakeLists.txt` also
+replicates RN-Skia's own Graphite-vs-Ganesh detection (probing its bundled
+`libskia.a`) so `SK_GRAPHITE` is defined identically to however RN-Skia's own
+Android build was compiled — `RNSkPlatformContext`'s vtable layout depends on
+that macro, and a mismatch would corrupt the virtual call in
+`VroomJsiInstaller.cpp`'s `ensureAxisTypeface`.
+
+We link two RN-Skia-adjacent libraries into `libvroomchart.so`, for two
+different reasons:
+  - `shopify_react-native-skia::rnskia` (RN-Skia's own prefab-published
+    shared library, `librnskia.so`) — for `RNJsi::JsiHostObject` and friends,
+    whose out-of-line methods are compiled only there.
+  - RN-Skia's bundled `libskia.a` (imported directly by path, since it isn't
+    prefab-published) — for direct Skia calls (`SkCanvas::drawRect`, `SkFont`,
+    ...), since `librnskia.so` links `libskia.a` internally but doesn't
+    re-export its symbols.
+
+### Cross-`.so` Skia objects
+
+Unlike iOS (one static binary), Android compiles RN-Skia into its own
+`librnskia.so`, separate from `libvroomchart.so`. That's transparent for most
+of the JSI bridge, but **`RNSkia::JsiSkPicture` — the object `render()` /
+`pan()` / etc. return to JS — can't be constructed directly in
+`libvroomchart.so` on Android.** RN-Skia's own C++ (e.g.
+`cpp/api/recorder/Convertor.h`'s `getPropertyValue<sk_sp<SkPicture>>`, which
+runs whenever `<Picture>` reads the value) does
+`value.asObject(rt).asHostObject<JsiSkPicture>(rt)`, a `dynamic_pointer_cast`
+under the hood. A `JsiSkPicture` we construct ourselves has a vtable/typeinfo
+compiled into *our* `.so`; that cast — running inside `librnskia.so` — sees a
+different, unmerged RTTI record for "the same" class and fails with `Object
+is not a HostObject of desired type`.
+
+`VroomChartHostObject.cpp`'s `wrapPicture()` works around this only on
+Android: instead of constructing `RNSkia::JsiSkPicture` directly (as iOS
+does), it serializes the `SkPicture` (`SkPicture::serialize()`) and calls
+RN-Skia's own public JS API, `Skia.Picture.MakePicture(bytes)`, via JSI. That
+runs `JsiSkPictureFactory::MakePicture` — genuinely compiled inside
+`librnskia.so` — so the returned object's RTTI matches what
+`librnskia.so`'s own code expects. This costs a serialize + re-parse of the
+picture's draw commands on every `render()`/gesture call, which is real
+overhead on what's meant to be a 60fps hot path; if that shows up in
+profiling, revisit (e.g. a merged-`.so` build, or a lighter-weight bridge
+that avoids the round trip).

package/android/build.gradle

@@ -0,0 +1,115 @@
+// android/build.gradle
+//
+// Builds the Android half of the JSI bridge: a small `vroomchart` native
+// library (see CMakeLists.txt) plus the TurboModule that installs it
+// (see src/main/java/com/vroom/chart). Modeled on
+// @shopify/react-native-skia/android/build.gradle and
+// react-native-worklets/android/build.gradle, which solve the same
+// "compile custom C++ against the RN/RN-Skia JSI internals" problem.
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "arm64-v8a", "x86", "x86_64"]
+}
+
+// Resolves a package's directory via Node's own module resolution, so this
+// works whether react-native-vroom-chart is installed flat or (as in this
+// monorepo) via pnpm's nested .pnpm store.
+def resolvePackageDir(packageJsonSpecifier) {
+  def packageJsonPath = providers.exec {
+    workingDir(rootDir)
+    commandLine("node", "--print", "require.resolve('${packageJsonSpecifier}')")
+  }.standardOutput.asText.get().trim()
+  return file(packageJsonPath).parentFile
+}
+
+def reactNativeDir = resolvePackageDir("react-native/package.json")
+def skiaCppDir = new File(resolvePackageDir("@shopify/react-native-skia/package.json"), "cpp")
+
+// Mirror ../cpp/_core_{src,include} from ../../core/{src,include} whenever
+// the monorepo core is present, so edits to packages/core/ propagate on the
+// next build without a separate vendoring step. This matches
+// ../react-native-vroom-chart.podspec's iOS behavior; a published package
+// (no ../../core) falls back to the committed vendored copies instead
+// (see ../scripts/vendor-core.mjs).
+def coreRoot = file("${projectDir}/../../core")
+if (coreRoot.isDirectory()) {
+  ["src", "include"].each { sub ->
+    def dst = file("${projectDir}/../cpp/_core_${sub}")
+    delete dst
+    copy {
+      from "${coreRoot}/${sub}"
+      into dst
+    }
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.vroom.chart"
+  compileSdkVersion safeExtGet("compileSdkVersion", 36)
+
+  if (rootProject.hasProperty("ndkPath")) {
+    ndkPath rootProject.ext.ndkPath
+  }
+  if (rootProject.hasProperty("ndkVersion")) {
+    ndkVersion rootProject.ext.ndkVersion
+  }
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 36)
+
+    externalNativeBuild {
+      cmake {
+        abiFilters(*reactNativeArchitectures())
+        arguments "-DANDROID_STL=c++_shared",
+                  "-DREACT_NATIVE_DIR=${reactNativeDir}",
+                  "-DVROOM_SKIA_CPP_DIR=${skiaCppDir}"
+      }
+    }
+  }
+
+  buildFeatures {
+    // Consumes the `ReactAndroid` prefab package (published by
+    // com.facebook.react:react-android) so CMake can `find_package(ReactAndroid)`
+    // for the jsi headers/library without us hand-resolving RN's AAR layout.
+    prefab true
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  lintOptions {
+    abortOnError false
+  }
+}
+
+repositories {
+  maven {
+    url("${reactNativeDir}/android")
+  }
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  // ../cpp/VroomChartHostObject.cpp constructs RN-Skia JSI host objects
+  // (JsiSkPicture, etc.) whose base class (RNJsi::JsiHostObject) has
+  // out-of-line methods compiled into RN-Skia's own native library — we link
+  // against its prefab-published `rnskia` package (below, in CMakeLists.txt)
+  // rather than recompiling those .cpp files ourselves, to avoid duplicate
+  // definitions of RNSkia's internals across two separately-loaded .so's.
+  implementation project(":shopify_react-native-skia")
+}

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/VroomChartJni.cpp

@@ -0,0 +1,24 @@
+// JNI entry point for VroomChartModule.install() (see
+// ../java/com/vroom/chart/VroomChartModule.kt). This is the Android
+// equivalent of ../../ios/VroomChartModule.mm's `-install` method: it
+// reinterprets the JSI runtime pointer handed over from Java and calls the
+// same platform-agnostic vroom::installJsi() the iOS bridge uses.
+
+#include <jni.h>
+
+#include <jsi/jsi.h>
+
+#include "VroomJsiInstaller.h"
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_vroom_chart_VroomChartModule_nativeInstall(JNIEnv* /*env*/,
+                                                      jobject /*thiz*/,
+                                                      jlong runtimePointer) {
+  auto* runtime =
+      reinterpret_cast<facebook::jsi::Runtime*>(runtimePointer);
+  if (runtime == nullptr) {
+    return JNI_FALSE;
+  }
+  vroom::installJsi(*runtime);
+  return JNI_TRUE;
+}

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

@@ -0,0 +1,31 @@
+package com.vroom.chart
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+// 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.
+//
+// `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) {
+
+  companion object {
+    init {
+      System.loadLibrary("vroomchart")
+    }
+  }
+
+  private external fun nativeInstall(runtimePointer: Long): Boolean
+
+  override fun install(): Boolean {
+    val runtimePointer =
+        reactApplicationContext.javaScriptContextHolder?.get() ?: return false
+    return nativeInstall(runtimePointer)
+  }
+}

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

@@ -0,0 +1,31 @@
+package com.vroom.chart
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class VroomChartPackage : BaseReactPackage() {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+      if (name == NativeVroomChartSpec.NAME) {
+        VroomChartModule(reactContext)
+      } else {
+        null
+      }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+    mutableMapOf(
+        NativeVroomChartSpec.NAME to
+            ReactModuleInfo(
+                NativeVroomChartSpec.NAME,
+                VroomChartModule::class.java.name,
+                /* canOverrideExistingModule = */ false,
+                /* needsEagerInit = */ false,
+                /* isCxxModule = */ false,
+                /* isTurboModule = */ true,
+            ),
+    )
+  }
+}