@airisu-dev/react-native-live2d-skia 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 airisu.dev
+
+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/Live2dSkia.podspec

@@ -0,0 +1,159 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+# Cubism SDK for Native: proprietary, so each app downloads it from Live2D and
+# sets its folder (app.plugin.js writes live2dSkia.cubismSdkPath to
+# Podfile.properties.json, relative to ios/).
+ios_dir = Pod::Config.instance.installation_root.to_s
+podfile_properties_path = File.join(ios_dir, "Podfile.properties.json")
+podfile_properties = File.exist?(podfile_properties_path) ? JSON.parse(File.read(podfile_properties_path)) : {}
+configured_sdk_dir = ENV["LIVE2D_SKIA_CUBISM_SDK"] || podfile_properties["live2dSkia.cubismSdkPath"]
+unless configured_sdk_dir
+  raise "[react-native-live2d-skia] Cubism SDK for Native isn't configured. Add the plugin to app.json: " \
+        "[\"@airisu-dev/react-native-live2d-skia\", { \"cubismSdkPath\": \"./vendor/CubismSdkForNative\" }], download the SDK with " \
+        "`@airisu-dev/react-native-live2d-skia fetch-sdk --accept-license` (through npx, bunx, yarn or pnpm), then prebuild."
+end
+cubism_sdk_dir = File.expand_path(configured_sdk_dir, ios_dir)
+cubism_info = File.join(cubism_sdk_dir, "cubism-info.yml")
+unless File.file?(cubism_info)
+  raise "[react-native-live2d-skia] Cubism SDK for Native not found at #{cubism_sdk_dir} (no cubism-info.yml). " \
+        "Download it with `@airisu-dev/react-native-live2d-skia fetch-sdk --accept-license` (through npx, bunx, yarn or pnpm)."
+end
+cubism_version = File.read(cubism_info)[/^version:\s*(\S+)/, 1] || "unknown"
+
+# A Cubism SDK version as a number: major * 10000 + release * 100 + patch, so
+# 5-r.4.1 is 50401 (a -beta suffix is ignored). Nil if it isn't one.
+cubism_version_number = lambda do |version|
+  m = version.match(/^(\d+)-r\.(\d+)(?:\.(\d+))?/)
+  m && m[1].to_i * 10000 + m[2].to_i * 100 + m[3].to_i
+end
+
+# Listed versions (cubismSdk.versions in package.json) are supported. A newer
+# release of a listed major only warns; anything else fails.
+listed_versions = package["cubismSdk"]["versions"].keys
+cubism_version_num = cubism_version_number.call(cubism_version)
+unless listed_versions.include?(cubism_version)
+  newest_of_major = cubism_version_num && listed_versions.map { |v| cubism_version_number.call(v) }
+                                                         .select { |n| n / 10000 == cubism_version_num / 10000 }.max
+  if newest_of_major.nil? || cubism_version_num < newest_of_major
+    raise "[react-native-live2d-skia] Cubism SDK for Native #{cubism_version} at #{cubism_sdk_dir} isn't supported: use #{listed_versions.join(', ')}."
+  end
+  Pod::UI.warn "[react-native-live2d-skia] Cubism SDK for Native #{cubism_version} found, tested with #{listed_versions.join(', ')}."
+end
+
+# CocoaPods only compiles files inside the pod, and the SDK ships one Core static
+# library per slice. So copy the Framework source in, and package the Core
+# slices as an xcframework (CocoaPods then links the right one for device or
+# simulator). Redone when the SDK's folder or version changes. Gitignored, not published.
+cubism_stage_dir = File.join(__dir__, "cubism-sdk")
+cubism_stamp = "#{cubism_sdk_dir}\n#{cubism_version}\n"
+cubism_stamp_path = File.join(cubism_stage_dir, ".stamp")
+unless File.exist?(cubism_stamp_path) && File.read(cubism_stamp_path) == cubism_stamp
+  require "fileutils"
+  require "tmpdir"
+  FileUtils.rm_rf(cubism_stage_dir)
+  FileUtils.mkdir_p(cubism_stage_dir)
+  FileUtils.cp_r(File.join(cubism_sdk_dir, "Framework", "src"), File.join(cubism_stage_dir, "Framework"))
+  core = File.join(cubism_sdk_dir, "Core")
+  FileUtils.mkdir_p(File.join(cubism_stage_dir, "Core"))
+  FileUtils.cp_r(File.join(core, "include"), File.join(cubism_stage_dir, "Core", "include"))
+  lib = File.join(core, "lib", "ios")
+  Dir.mktmpdir do |tmp|
+    simulator_lib = File.join(tmp, "libLive2DCubismCore.a")
+    run = lambda do |*cmd|
+      system(*cmd) or raise "[react-native-live2d-skia] Failed to package Cubism Core: #{cmd.join(' ')}"
+    end
+    run.call("lipo", "-create",
+             File.join(lib, "Release-iphonesimulator-arm64", "libLive2DCubismCore.a"),
+             File.join(lib, "Release-iphonesimulator-x86_64", "libLive2DCubismCore.a"),
+             "-output", simulator_lib)
+    run.call("xcodebuild", "-create-xcframework",
+             "-library", File.join(lib, "Release-iphoneos", "libLive2DCubismCore.a"),
+             "-headers", File.join(core, "include"),
+             "-library", simulator_lib, "-headers", File.join(core, "include"),
+             "-output", File.join(cubism_stage_dir, "Live2DCubismCore.xcframework"))
+  end
+  File.write(cubism_stamp_path, cubism_stamp)
+  Pod::UI.puts "[react-native-live2d-skia] Using Cubism SDK for Native #{cubism_version} from #{cubism_sdk_dir}"
+end
+
+# Draw in C++ onto Skia canvases (cpp/drawing/SkiaDrawer.cpp). Skia is linked statically
+# into the app by its pod (named react-native-skia in v3 and v2), so this only
+# needs its headers and the defines it's built with. Which Skia: the one
+# app.plugin.js found in the app's package.json (live2dSkia.skiaPackage), v3
+# (Graphite) or v2 (Ganesh), resolved from the app since a monorepo can have
+# both installed. Without it, models are drawn in JS.
+rn_skia_package = podfile_properties["live2dSkia.skiaPackage"].to_s
+rn_skia_dir = nil
+unless rn_skia_package.empty?
+  app_dir = File.dirname(ios_dir)
+  resolved = IO.popen(["node", "-p",
+                       "require('path').dirname(require.resolve(process.argv[1] + '/package.json', { paths: [process.argv[2]] }))",
+                       rn_skia_package, app_dir], err: File::NULL, &:read).to_s.strip
+  rn_skia_dir = resolved if $?.success? && File.file?(File.join(resolved, "cpp", "api", "JsiSkCanvas.h"))
+end
+rn_skia_graphite = rn_skia_package == "react-native-skia"
+
+Pod::Spec.new do |s|
+  s.name         = "Live2dSkia"
+  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/airisu-dev/react-native-live2d-skia.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+    # Cubism Native Framework (motions, physics, pose, ...)
+    "cubism-sdk/Framework/**/*.{hpp,cpp}",
+  ]
+  # Its Rendering/<backend> folders are left out: we draw with Skia
+  # (see cpp/cubism/CubismRendererStub.cpp).
+  s.exclude_files = "cubism-sdk/Framework/Rendering/*/**/*"
+
+  s.vendored_frameworks = "cubism-sdk/Live2DCubismCore.xcframework"
+  # Set before add_nitrogen_files, which merges its own settings into this.
+  header_search_paths = [
+    "\"$(PODS_TARGET_SRCROOT)/cubism-sdk/Core/include\"",
+    "\"$(PODS_TARGET_SRCROOT)/cubism-sdk/Framework\"",
+    "\"$(PODS_TARGET_SRCROOT)/cpp/hybrid\"",
+    "\"$(PODS_TARGET_SRCROOT)/cpp/cubism\"",
+    "\"$(PODS_TARGET_SRCROOT)/cpp/drawing\"",
+  ]
+  # The SDK's version, for cpp/cubism/CubismCompat.hpp.
+  preprocessor_definitions = ["$(inherited)", "LIVE2D_SKIA_CUBISM_SDK=#{cubism_version_num}"]
+  if rn_skia_dir
+    Pod::UI.puts "[Live2dSkia] Drawing with Skia in C++ (#{rn_skia_dir}, #{rn_skia_graphite ? 'Graphite' : 'Ganesh'})"
+    s.dependency "react-native-skia"
+    skia_headers = ["cpp", "cpp/skia", "cpp/api", "cpp/jsi", "cpp/rnskia", "cpp/rnskia/values", "cpp/utils"]
+    skia_headers << "cpp/dawn/include" if rn_skia_graphite
+    header_search_paths += skia_headers.map { |dir| "\"#{File.join(rn_skia_dir, dir)}\"" }
+    # Same as the Skia pod: struct layouts must match.
+    preprocessor_definitions += ["LIVE2D_SKIA=1",
+                                 "SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API=1",
+                                 "SK_DISABLE_LEGACY_SHAPER_FACTORY=1"]
+    preprocessor_definitions += rn_skia_graphite ? ["SK_GRAPHITE=1"] : ["SK_METAL=1", "SK_GANESH=1"]
+  else
+    Pod::UI.puts "[Live2dSkia] No Skia to draw with in C++, drawing in JS"
+  end
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => header_search_paths.join(" "),
+    "GCC_PREPROCESSOR_DEFINITIONS" => preprocessor_definitions.join(" "),
+  }
+
+  load 'nitrogen/generated/ios/Live2dSkia+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/README.md

@@ -1,3 +1,65 @@
-# Temporary Holding Version
+# react-native-live2d-skia
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+react-native-live2d-skia is a react native package built with Nitro
+
+[![Version](https://img.shields.io/npm/v/@airisu-dev/react-native-live2d-skia.svg)](https://www.npmjs.com/package/@airisu-dev/react-native-live2d-skia)
+[![Downloads](https://img.shields.io/npm/dm/@airisu-dev/react-native-live2d-skia.svg)](https://www.npmjs.com/package/@airisu-dev/react-native-live2d-skia)
+[![License](https://img.shields.io/npm/l/@airisu-dev/react-native-live2d-skia.svg)](https://github.com/airisu-dev/react-native-live2d-skia/blob/main/LICENSE)
+
+## Requirements
+
+- React Native v0.76.0 or higher
+- Node 18.0.0 or higher
+
+> [!IMPORTANT]  
+> To Support `Nitro Views` you need to install React Native version v0.78.0 or higher.
+
+## Installation
+
+```bash
+npx expo install @airisu-dev/react-native-live2d-skia react-native-nitro-modules react-native-skia react-native-reanimated react-native-worklets react-native-gesture-handler expo-asset expo-file-system
+```
+
+Expo apps only (development builds with prebuild); the React Native CLI isn't supported.
+
+Skia: either version works; install one, not both.
+
+| Skia | Package                              | Renderer                 |
+| ---- | ------------------------------------ | ------------------------ |
+| v3   | `react-native-skia` (3.3+)           | Graphite (Vulkan, Metal) |
+| v2   | `@shopify/react-native-skia` (2.10+) | Ganesh (OpenGL, Metal)   |
+
+For v2, install `@shopify/react-native-skia` instead of `react-native-skia` above, at 2.10 or later: `expo install` picks 2.6.2 for SDK 57, which hands Skia objects to C++ differently (JSI host objects, not native state), so pin a newer one, e.g. `npx expo install @shopify/react-native-skia@2.14.0`. The config plugin reads which one the app depends on, and models are drawn in C++ with it.
+
+### Cubism SDK for Native
+
+The package doesn't include Live2D's Cubism SDK: its Core is proprietary, and
+each app downloads it from Live2D, accepting
+[Live2D's license terms](https://www.live2d.com/eula/live2d-proprietary-software-license-agreement_en.html).
+1. Download it (it's checked against a SHA-256):
+
+   ```bash
+   npx @airisu-dev/react-native-live2d-skia fetch-sdk --accept-license   # or bunx, yarn, pnpm
+   ```
+
+   It extracts to `./vendor/CubismSdkForNative` (change it with `--out`). Add `/vendor/` to `.gitignore`, so it's never in a public repo. On EAS Build,
+   run the same command in an `eas-build-post-install` script.
+
+2. Point the config plugin at it, in `app.json`:
+
+   ```json
+   "plugins": [["@airisu-dev/react-native-live2d-skia", { "cubismSdkPath": "./vendor/CubismSdkForNative" }]]
+   ```
+
+3. `npx expo prebuild`, then build. A missing or unsupported SDK stops the build with the path it looked at.
+
+Publishing an app built on the SDK may also need Live2D's
+[Cubism SDK Release License](https://www.live2d.com/en/sdk/license/) (businesses above 10M JPY a year).
+
+## Credits
+
+Bootstrapped with [create-nitro-module](https://github.com/patrickkabwe/create-nitro-module).
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

package/android/CMakeLists.txt

@@ -0,0 +1,113 @@
+project(Live2dSkia)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME Live2dSkia)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_compile_options(-DRN_SERIALIZABLE_STATE=1)
+
+# Cubism SDK for Native: proprietary, downloaded by each app. build.gradle
+# passes its folder (and checks its version), see app.plugin.js.
+if (NOT CUBISM_SDK_DIR OR NOT CUBISM_SDK_VERSION_NUMBER)
+        message(FATAL_ERROR "[react-native-live2d-skia] CUBISM_SDK_DIR isn't set: build through Gradle, "
+                "with live2dSkia.cubismSdkPath set by the react-native-live2d-skia config plugin.")
+endif()
+# The SDK's version, for cpp/cubism/CubismCompat.hpp.
+add_compile_definitions(LIVE2D_SKIA_CUBISM_SDK=${CUBISM_SDK_VERSION_NUMBER})
+
+# Cubism Core (closed source): the prebuilt static library.
+set (CUBISM_CORE_DIR "${CUBISM_SDK_DIR}/Core")
+set (CUBISM_CORE_LIB "${CUBISM_CORE_DIR}/lib/android/${ANDROID_ABI}/libLive2DCubismCore.a")
+if (NOT EXISTS "${CUBISM_CORE_LIB}")
+        message(FATAL_ERROR "[react-native-live2d-skia] Cubism Core not found for ${ANDROID_ABI} at ${CUBISM_CORE_LIB}.")
+endif()
+add_library(Live2DCubismCore STATIC IMPORTED)
+set_target_properties(Live2DCubismCore PROPERTIES IMPORTED_LOCATION "${CUBISM_CORE_LIB}")
+
+# Cubism Native Framework (motions, physics, pose, ...): the source in the same
+# SDK, so it always matches the Core.
+# Its Rendering/<backend> folders are left out: we draw with Skia
+# (see ../cpp/cubism/CubismRendererStub.cpp).
+set (CUBISM_FRAMEWORK_DIR "${CUBISM_SDK_DIR}/Framework/src")
+if (NOT EXISTS "${CUBISM_FRAMEWORK_DIR}/CubismFramework.cpp")
+        message(FATAL_ERROR "[react-native-live2d-skia] Cubism Native Framework not found at ${CUBISM_FRAMEWORK_DIR}.")
+endif()
+file(GLOB_RECURSE CUBISM_FRAMEWORK_SOURCES "${CUBISM_FRAMEWORK_DIR}/*.cpp")
+list(FILTER CUBISM_FRAMEWORK_SOURCES EXCLUDE REGEX "/Rendering/[^/]+/")
+add_library(CubismFramework STATIC ${CUBISM_FRAMEWORK_SOURCES})
+target_include_directories(CubismFramework PUBLIC "${CUBISM_FRAMEWORK_DIR}" "${CUBISM_CORE_DIR}/include")
+# Third-party code: don't flood the build log with its warnings.
+target_compile_options(CubismFramework PRIVATE -w)
+
+add_library(${PACKAGE_NAME} SHARED
+	src/main/cpp/cpp-adapter.cpp
+	../cpp/hybrid/HybridLive2dSkia.cpp
+	../cpp/hybrid/HybridLive2DModel.cpp
+	../cpp/cubism/CubismSetup.cpp
+	../cpp/cubism/CubismRendererStub.cpp
+	../cpp/cubism/Live2DUserModel.cpp
+	../cpp/cubism/Live2DUserModelAnimation.cpp
+)
+
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/Live2dSkia+autolinking.cmake)
+
+include_directories(
+        "src/main/cpp"
+        "../cpp/hybrid"
+        "../cpp/cubism"
+        "../cpp/drawing"
+        "${CUBISM_CORE_DIR}/include"
+)
+
+# Draw in C++ onto Skia canvases (cpp/drawing/SkiaDrawer.cpp). librnskia.so doesn't
+# export Skia, so link the same prebuilt libskia.a it's built from and use its
+# headers and defines; objects cross over through virtual calls. build.gradle
+# passes the folders of the Skia the app uses, v3 (Graphite) or v2 (Ganesh).
+# Without them, models are drawn in JS (src/drawer.ts).
+set (RN_SKIA_LIBS_ABI "${RN_SKIA_LIBS}/${ANDROID_ABI}")
+if (RN_SKIA_DIR AND EXISTS "${RN_SKIA_LIBS_ABI}/libskia.a" AND EXISTS "${RN_SKIA_DIR}/cpp/api/JsiSkCanvas.h")
+        message(STATUS "react-native-live2d-skia: drawing with Skia in C++ (${RN_SKIA_DIR}, Graphite: ${RN_SKIA_GRAPHITE})")
+        add_library(skia STATIC IMPORTED)
+        set_target_properties(skia PROPERTIES IMPORTED_LOCATION "${RN_SKIA_LIBS_ABI}/libskia.a")
+        target_sources(${PACKAGE_NAME} PRIVATE ../cpp/drawing/SkiaDrawer.cpp ../cpp/drawing/MeshCache.cpp)
+        target_include_directories(${PACKAGE_NAME} PRIVATE
+                "${RN_SKIA_DIR}/cpp/skia"
+                "${RN_SKIA_DIR}/cpp/api"
+                "${RN_SKIA_DIR}/cpp/jsi"
+                "${RN_SKIA_DIR}/cpp/rnskia"
+                "${RN_SKIA_DIR}/cpp/rnskia/values"
+                "${RN_SKIA_DIR}/cpp/utils"
+                "${RN_SKIA_DIR}/cpp"
+                "${RN_SKIA_DIR}/android/cpp/rnskia-android"
+                "${RN_SKIA_DIR}/android/cpp/jni/include"
+                "${REACT_NATIVE_DIR}/ReactCommon"
+                "${REACT_NATIVE_DIR}/ReactCommon/callinvoker")
+        # Same as the Skia package's build: struct layouts must match.
+        target_compile_definitions(${PACKAGE_NAME} PRIVATE
+                LIVE2D_SKIA=1 SK_BUILD_FOR_ANDROID
+                SK_DISABLE_LEGACY_SHAPER_FACTORY SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API
+                FOLLY_NO_CONFIG=1 FOLLY_HAVE_CLOCK_GETTIME=1 FOLLY_HAVE_MEMRCHR=1
+                FOLLY_USE_LIBCPP=1 FOLLY_MOBILE=1 ON_ANDROID ONANDROID)
+        if (RN_SKIA_GRAPHITE)
+                target_include_directories(${PACKAGE_NAME} PRIVATE "${RN_SKIA_DIR}/cpp/dawn/include")
+                target_compile_definitions(${PACKAGE_NAME} PRIVATE SK_GRAPHITE)
+        else()
+                target_compile_definitions(${PACKAGE_NAME} PRIVATE SK_GL SK_GANESH)
+        endif()
+        set (LIVE2D_SKIA_LIBS skia)
+else()
+        message(STATUS "react-native-live2d-skia: no Skia to draw with in C++, drawing in JS")
+endif()
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        CubismFramework
+        Live2DCubismCore
+        ${LIVE2D_SKIA_LIBS}
+        android                                   # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,223 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.8.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/Live2dSkia+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+// Cubism SDK for Native: proprietary, so each app downloads it from Live2D and
+// sets its folder (app.plugin.js writes live2dSkia.cubismSdkPath, relative to android/).
+def findCubismSdk() {
+  def configured = System.getenv("LIVE2D_SKIA_CUBISM_SDK") ?: rootProject.findProperty("live2dSkia.cubismSdkPath")
+  if (!configured) {
+    throw new GradleException("[react-native-live2d-skia] Cubism SDK for Native isn't configured. Add the plugin to app.json: " +
+      "[\"@airisu-dev/react-native-live2d-skia\", { \"cubismSdkPath\": \"./vendor/CubismSdkForNative\" }], download the SDK with `@airisu-dev/react-native-live2d-skia fetch-sdk --accept-license` (through npx, bunx, yarn or pnpm), then prebuild.")
+  }
+  def dir = rootProject.file(configured)
+  def info = new File(dir, "cubism-info.yml")
+  if (!info.exists()) {
+    throw new GradleException("[react-native-live2d-skia] Cubism SDK for Native not found at ${dir} (no cubism-info.yml). " +
+      "Download it with `@airisu-dev/react-native-live2d-skia fetch-sdk --accept-license` (through npx, bunx, yarn or pnpm).")
+  }
+  def matcher = info.text =~ /(?m)^version:\s*(\S+)/
+  def version = matcher.find() ? matcher.group(1) : "unknown"
+  checkCubismSdkVersion(version, dir)
+  return [dir: dir.absolutePath.replace("\\", "/"), version: version]
+}
+
+// A Cubism SDK version as a number: major * 10000 + release * 100 + patch, so
+// 5-r.4.1 is 50401 (a -beta suffix is ignored). Null if it isn't one.
+def cubismSdkVersionNumber(String version) {
+  def m = version =~ /^(\d+)-r\.(\d+)(?:\.(\d+))?/
+  return m.find() ? m.group(1).toInteger() * 10000 + m.group(2).toInteger() * 100 + (m.group(3) ?: "0").toInteger() : null
+}
+
+// Listed versions (cubismSdk.versions in package.json) are supported. A newer
+// release of a listed major only warns; anything else fails.
+def checkCubismSdkVersion(String version, File dir) {
+  def listed = new groovy.json.JsonSlurper().parse(file("../package.json")).cubismSdk.versions.keySet()
+  if (listed.contains(version)) return
+  def number = cubismSdkVersionNumber(version)
+  def newestOfMajor = number == null ? null : listed.collect { cubismSdkVersionNumber(it) }
+    .findAll { it.intdiv(10000) == number.intdiv(10000) }.max()
+  if (newestOfMajor == null || number < newestOfMajor) {
+    throw new GradleException("[react-native-live2d-skia] Cubism SDK for Native ${version} at ${dir} isn't supported: use ${listed.join(', ')}.")
+  }
+  logger.warn("[react-native-live2d-skia] Cubism SDK for Native ${version} found, tested with ${listed.join(', ')}.")
+}
+
+// The folder of a node package, as `from` resolves it. Null if it isn't installed.
+def resolveNodePackage(String name, File from) {
+  def process = ["node", "-p",
+    "require('path').dirname(require.resolve(process.argv[1] + '/package.json', { paths: [process.argv[2]] }))",
+    name, from.absolutePath].execute()
+  def out = process.text.trim()
+  return process.waitFor() == 0 && out ? new File(out) : null
+}
+
+// Drawing in C++ onto Skia canvases (cpp/drawing/SkiaDrawer.cpp) needs the headers,
+// defines and prebuilt libskia.a of the Skia the app uses: react-native-skia
+// (v3, Graphite) or @shopify/react-native-skia (v2, Ganesh), as app.plugin.js
+// found in the app's package.json (live2dSkia.skiaPackage). Resolved from the
+// app, since a monorepo can have both installed. No arguments: drawn in JS.
+def skiaCmakeArguments() {
+  def name = rootProject.findProperty("live2dSkia.skiaPackage")
+  if (!name) return []
+  def appDir = rootProject.projectDir.parentFile
+  def skiaDir = resolveNodePackage(name, appDir)
+  def graphite = name == "react-native-skia"
+  def libsDir = skiaDir ? resolveNodePackage(graphite ? "react-native-skia-graphite-android" : "react-native-skia-android", skiaDir) : null
+  def reactNativeDir = resolveNodePackage("react-native", appDir)
+  if (!skiaDir || !libsDir || !reactNativeDir) {
+    logger.warn("[react-native-live2d-skia] ${name} or its Android binaries not found from ${appDir}: drawing in JS.")
+    return []
+  }
+  return ["-DRN_SKIA_DIR=${skiaDir.absolutePath.replace("\\", "/")}",
+          "-DRN_SKIA_LIBS=${new File(libsDir, "libs").absolutePath.replace("\\", "/")}",
+          "-DRN_SKIA_GRAPHITE=${graphite ? "ON" : "OFF"}",
+          "-DREACT_NATIVE_DIR=${reactNativeDir.absolutePath.replace("\\", "/")}"]
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Live2dSkia_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Live2dSkia_" + name]).toInteger()
+}
+
+android {
+  namespace "com.live2dskia"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        def cubismSdk = findCubismSdk()
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
+          "-DCUBISM_SDK_DIR=${cubismSdk.dir}",
+          "-DCUBISM_SDK_VERSION_NUMBER=${cubismSdkVersionNumber(cubismSdk.version)}", *skiaCmakeArguments()
+        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 {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  implementation project(":react-native-nitro-modules")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "Live2dSkia"
+    codegenJavaPackageName = "com.live2dskia"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Live2dSkia_kotlinVersion=2.1.20
+Live2dSkia_minSdkVersion=23
+Live2dSkia_targetSdkVersion=35
+Live2dSkia_compileSdkVersion=34
+Live2dSkia_ndkVersion=27.1.12297006

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,9 @@
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "Live2dSkiaOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::live2dskia::registerAllNatives();
+  });
+}