react-native-sherpa-onnx 0.2.0 → 0.3.0

package/android/src/main/cpp/CMakeLists.txt

@@ -1,129 +1,166 @@
-cmake_minimum_required(VERSION 3.22.1)
-
-project("sherpaonnx")
-
-# Set C++ standard
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Android specific settings
-set(CMAKE_ANDROID_ARCH_ABI ${ANDROID_ABI})
-set(CMAKE_SYSTEM_NAME Android)
-set(CMAKE_SYSTEM_VERSION ${ANDROID_PLATFORM_LEVEL})
-
-# Set Windows path length limit
-if(WIN32)
-    set(CMAKE_OBJECT_PATH_MAX 500)
-endif()
-
-# Calculate path relative to project root: android/src/main/cpp -> android -> project root
-get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../.." ABSOLUTE)
-
-# Fixed location where Gradle extracts native libraries
-set(EXTRACTED_LIBS_DIR "${PROJECT_ROOT}/build/extracted_native_libs/jni/${ANDROID_ABI}")
-
-# Try to find library directly by path (most reliable)
-set(SHERPA_ONNX_LIB_CXX "${EXTRACTED_LIBS_DIR}/libsherpa-onnx-cxx-api.so")
-set(SHERPA_ONNX_LIB_C "${EXTRACTED_LIBS_DIR}/libsherpa-onnx-c-api.so")
-
-if(EXISTS "${SHERPA_ONNX_LIB_CXX}")
-    set(SHERPA_ONNX_LIB "${SHERPA_ONNX_LIB_CXX}")
-    message(STATUS "Found sherpa-onnx library (cxx-api): ${SHERPA_ONNX_LIB}")
-elseif(EXISTS "${SHERPA_ONNX_LIB_C}")
-    set(SHERPA_ONNX_LIB "${SHERPA_ONNX_LIB_C}")
-    message(STATUS "Found sherpa-onnx library (c-api): ${SHERPA_ONNX_LIB}")
-else()
-    # Fallback: use find_library
-    find_library(SHERPA_ONNX_LIB
-        NAMES sherpa-onnx-cxx-api libsherpa-onnx-cxx-api sherpa-onnx-c-api libsherpa-onnx-c-api
-        PATHS ${EXTRACTED_LIBS_DIR}
-        NO_DEFAULT_PATH
-    )
-    
-    if(NOT SHERPA_ONNX_LIB)
-        message(FATAL_ERROR "sherpa-onnx library not found in ${EXTRACTED_LIBS_DIR}\n"
-                            "Expected files:\n"
-                            "  - ${SHERPA_ONNX_LIB_CXX}\n"
-                            "  - ${SHERPA_ONNX_LIB_C}\n"
-                            "Please ensure extractNativeLibs task ran successfully.")
-    endif()
-endif()
-
-# Source files
-set(SOURCES
-    jni/sherpa-onnx-stt-jni.cpp
-    jni/sherpa-onnx-tts-jni.cpp
-    jni/sherpa-onnx-model-detect.cpp
-    jni/sherpa-onnx-stt-wrapper.cpp
-    jni/sherpa-onnx-tts-wrapper.cpp
-)
-
-# Create shared library
-add_library(sherpaonnx SHARED
-    ${SOURCES}
-)
-
-# Try to find sherpa-onnx headers
-# Priority order:
-# 1. Local include directory (bundled in npm package) - preferred for published packages
-# 2. Git submodule (for local development)
-# The headers use "sherpa-onnx/c-api/..." includes, so we need to add
-# the directory that contains "sherpa-onnx" as a subdirectory
-set(SHERPA_ONNX_INCLUDE_DIRS "")
-set(POSSIBLE_BASE_PATHS
-    "${CMAKE_CURRENT_SOURCE_DIR}/include"  # Bundled headers in npm package
-    "${PROJECT_ROOT}/android/src/main/cpp/include"  # Alternative path for bundled headers
-    "${PROJECT_ROOT}/sherpa-onnx"  # Git submodule (for local development)
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../../../sherpa-onnx"  # Alternative submodule path
-)
-
-set(HEADER_SOURCE_TYPE "")
-foreach(BASE_PATH ${POSSIBLE_BASE_PATHS})
-    if(EXISTS "${BASE_PATH}/sherpa-onnx/c-api/cxx-api.h")
-        list(APPEND SHERPA_ONNX_INCLUDE_DIRS "${BASE_PATH}")
-        
-        # Determine header source type for logging
-        if("${BASE_PATH}" MATCHES "include")
-            set(HEADER_SOURCE_TYPE "bundled (npm package)")
-        else()
-            set(HEADER_SOURCE_TYPE "git submodule")
-        endif()
-        
-        message(STATUS "Found sherpa-onnx headers from ${HEADER_SOURCE_TYPE} at: ${BASE_PATH}")
-        # Also output as regular message to ensure visibility in Gradle logs
-        message("-- Using sherpa-onnx headers from: ${HEADER_SOURCE_TYPE}")
-        break()  # Found it, no need to check other paths
-    endif()
-endforeach()
-
-if(SHERPA_ONNX_INCLUDE_DIRS STREQUAL "")
-    message(FATAL_ERROR "sherpa-onnx headers not found.\n"
-                        "Please ensure:\n"
-                        "  1. Headers are copied by running: yarn copy-headers\n"
-                        "  2. Or git submodule is initialized: git submodule update --init --recursive")
-endif()
-
-# Include directories (must be after add_library)
-target_include_directories(sherpaonnx PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-    ${CMAKE_CURRENT_SOURCE_DIR}/jni
-    ${SHERPA_ONNX_INCLUDE_DIRS}
-)
-
-# Also link onnxruntime (required dependency)
-set(ONNXRUNTIME_LIB "${EXTRACTED_LIBS_DIR}/libonnxruntime.so")
-
-# Link libraries
-target_link_libraries(sherpaonnx
-    ${SHERPA_ONNX_LIB}
-    ${ONNXRUNTIME_LIB}
-    log
-    android
-)
-
-# Compiler flags
-target_compile_options(sherpaonnx PRIVATE
-    -Wall
-    -Wextra
-    -fvisibility=hidden
-)
+cmake_minimum_required(VERSION 3.22.1)
+
+project("sherpaonnx")
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# ANDROID_ABI MUST be set by Gradle - it should never be empty
+if(NOT ANDROID_ABI)
+    message(FATAL_ERROR "ANDROID_ABI not set. This is a normal error.\n\n"
+                        "How to fix:\n"
+                        "  1. Use: cd example && yarn android\n"
+                        "     (This runs Gradle which sets ANDROID_ABI)\n\n"
+                        "  2. Or if building manually with CMake, specify:\n"
+                        "     cmake -B build -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-24 ...\n\n"
+                        "Supported ABIs: arm64-v8a, armeabi-v7a, x86, x86_64")
+endif()
+
+# Set Windows path length limit
+if(WIN32)
+    set(CMAKE_OBJECT_PATH_MAX 500)
+endif()
+
+# Calculate path relative to project root: android/src/main/cpp -> android -> project root
+get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../.." ABSOLUTE)
+
+# FFmpeg: libs and headers from (1) third_party/ffmpeg_prebuilt/android (local build) or (2) jniLibs + cpp/include/ffmpeg (GitHub release zip).
+# PROJECT_ROOT = android/; repo root = PROJECT_ROOT/..
+set(FFMPEG_PREBUILT_BASE "${PROJECT_ROOT}/../third_party/ffmpeg_prebuilt/android")
+set(FFMPEG_PREBUILT_LIB "${FFMPEG_PREBUILT_BASE}/${ANDROID_ABI}/lib")
+set(FFMPEG_JNILIBS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
+set(FFMPEG_INCLUDE_CPP "${PROJECT_ROOT}/src/main/cpp/include/ffmpeg")
+if(EXISTS "${FFMPEG_PREBUILT_BASE}/include")
+    set(FFMPEG_INCLUDE_DIR "${FFMPEG_PREBUILT_BASE}/include")
+    message(STATUS "FFmpeg headers: prebuilts ${FFMPEG_INCLUDE_DIR}")
+elseif(EXISTS "${FFMPEG_INCLUDE_CPP}")
+    set(FFMPEG_INCLUDE_DIR "${FFMPEG_INCLUDE_CPP}")
+    message(STATUS "FFmpeg headers: jniLibs/release ${FFMPEG_INCLUDE_DIR}")
+else()
+    message(FATAL_ERROR "FFmpeg headers missing. Either:\n"
+                        "  - Build: cd third_party/ffmpeg_prebuilt && ./build_ffmpeg.sh (creates android/include)\n"
+                        "  - Or use a release that includes include/ (Gradle extracts to ${FFMPEG_INCLUDE_CPP})")
+endif()
+if(EXISTS "${FFMPEG_PREBUILT_LIB}/libavcodec.so")
+    set(FFMPEG_LIB_DIR "${FFMPEG_PREBUILT_LIB}")
+    message(STATUS "FFmpeg libs: prebuilts ${FFMPEG_LIB_DIR}")
+elseif(EXISTS "${FFMPEG_JNILIBS}/libavcodec.so")
+    set(FFMPEG_LIB_DIR "${FFMPEG_JNILIBS}")
+    message(STATUS "FFmpeg libs: jniLibs ${FFMPEG_LIB_DIR}")
+else()
+    message(FATAL_ERROR "FFmpeg libs missing for ABI ${ANDROID_ABI}. Run third_party/ffmpeg_prebuilt/copy_prebuilts_to_sdk.js or ensure ANDROID_RELEASE_TAG release is downloaded.")
+endif()
+
+# Source files by domain (see docs/NATIVE_NAMING_CONVENTION.md). Move .cpp into subdirs; .h go alongside for include path.
+set(SOURCES
+    jni/module/sherpa-onnx-module-jni.cpp
+    jni/archive/sherpa-onnx-archive-helper.cpp
+    jni/archive/sherpa-onnx-archive-jni.cpp
+    jni/model_detect/sherpa-onnx-model-detect-helper.cpp
+    jni/model_detect/sherpa-onnx-model-detect-stt.cpp
+    jni/model_detect/sherpa-onnx-model-detect-tts.cpp
+    jni/model_detect/sherpa-onnx-detect-jni-common.cpp
+    jni/model_detect/sherpa-onnx-stt-wrapper.cpp
+    jni/model_detect/sherpa-onnx-tts-wrapper.cpp
+    jni/audio/sherpa-onnx-audio-convert-jni.cpp
+    jni/tts/sherpa-onnx-tts-zipvoice-jni.cpp
+    crypto/sha256.cpp
+)
+
+# libarchive: (1) prebuilt from third_party/libarchive_prebuilt or jniLibs + cpp/include/libarchive (Maven/GitHub), or (2) build from source.
+set(LIBARCHIVE_PREBUILT_BASE "${PROJECT_ROOT}/../third_party/libarchive_prebuilt/android")
+set(LIBARCHIVE_PREBUILT_LIB "${LIBARCHIVE_PREBUILT_BASE}/${ANDROID_ABI}/lib")
+set(LIBARCHIVE_JNILIBS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
+set(LIBARCHIVE_INCLUDE_CPP "${PROJECT_ROOT}/src/main/cpp/include/libarchive")
+set(USE_LIBARCHIVE_PREBUILT OFF)
+if(EXISTS "${LIBARCHIVE_PREBUILT_LIB}/libarchive.so")
+    set(USE_LIBARCHIVE_PREBUILT ON)
+    set(LIBARCHIVE_LIB_DIR "${LIBARCHIVE_PREBUILT_LIB}")
+    if(EXISTS "${LIBARCHIVE_PREBUILT_BASE}/include")
+        set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_PREBUILT_BASE}/include")
+    elseif(EXISTS "${LIBARCHIVE_INCLUDE_CPP}/archive.h")
+        set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_INCLUDE_CPP}")
+    endif()
+elseif(EXISTS "${LIBARCHIVE_JNILIBS}/libarchive.so")
+    set(USE_LIBARCHIVE_PREBUILT ON)
+    set(LIBARCHIVE_LIB_DIR "${LIBARCHIVE_JNILIBS}")
+    if(EXISTS "${LIBARCHIVE_INCLUDE_CPP}/archive.h")
+        set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_INCLUDE_CPP}")
+    endif()
+endif()
+if(USE_LIBARCHIVE_PREBUILT AND LIBARCHIVE_INCLUDE_DIR)
+    message(STATUS "libarchive: using prebuilt (libs: ${LIBARCHIVE_LIB_DIR}, include: ${LIBARCHIVE_INCLUDE_DIR})")
+else()
+    message(STATUS "Building libarchive from bundled source...")
+    add_subdirectory(${PROJECT_ROOT}/../third_party/libarchive ${CMAKE_BINARY_DIR}/libarchive)
+    message(STATUS "libarchive built successfully")
+endif()
+
+# Create shared library
+add_library(sherpaonnx SHARED
+    ${SOURCES}
+)
+
+# sherpa-onnx C-API: link by directory + library name only (no IMPORTED target).
+# The .so and headers land in jniLibs and cpp/include/sherpa-onnx via:
+#   (1) local third_party build, (2) Maven AAR extraction (libs + c-api headers), or (3) GitHub release zip (last resort).
+# If we used IMPORTED here, AGP would also copy .so from CMake → duplicate in mergeNativeLibs.
+set(SHERPA_ONNX_PREBUILT_BASE "${PROJECT_ROOT}/../third_party/sherpa-onnx-prebuilt/android")
+set(SHERPA_ONNX_ABI_LIB "${SHERPA_ONNX_PREBUILT_BASE}/${ANDROID_ABI}/lib")
+set(SHERPA_C_API_LIB_DIR "")
+if(EXISTS "${SHERPA_ONNX_ABI_LIB}/libsherpa-onnx-c-api.so")
+    set(SHERPA_C_API_LIB_DIR "${SHERPA_ONNX_ABI_LIB}")
+    message(STATUS "sherpa-onnx C-API (link only): ${SHERPA_C_API_LIB_DIR}")
+elseif(EXISTS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}/libsherpa-onnx-c-api.so")
+    set(SHERPA_C_API_LIB_DIR "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
+    message(STATUS "sherpa-onnx C-API (link only, jniLibs): ${SHERPA_C_API_LIB_DIR}")
+else()
+    message(WARNING "sherpa-onnx C-API not found. Zipvoice TTS will not be available. "
+                    "Build prebuilts: cd third_party/sherpa-onnx-prebuilt && ./build_sherpa_onnx.sh")
+endif()
+
+# Include directories (must be after add_library). Subdirs so #include "sherpa-onnx-*.h" resolves after move.
+target_include_directories(sherpaonnx PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/jni
+    ${CMAKE_CURRENT_SOURCE_DIR}/jni/module
+    ${CMAKE_CURRENT_SOURCE_DIR}/jni/archive
+    ${CMAKE_CURRENT_SOURCE_DIR}/jni/model_detect
+    ${CMAKE_CURRENT_SOURCE_DIR}/jni/audio
+    ${CMAKE_CURRENT_SOURCE_DIR}/jni/tts
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+    ${FFMPEG_INCLUDE_DIR}
+)
+if(USE_LIBARCHIVE_PREBUILT AND LIBARCHIVE_INCLUDE_DIR)
+    target_include_directories(sherpaonnx PRIVATE ${LIBARCHIVE_INCLUDE_DIR})
+endif()
+target_compile_definitions(sherpaonnx PRIVATE HAVE_FFMPEG=1)
+
+# Link libraries (Kotlin API from AAR handles STT/TTS; C-API only for Zipvoice)
+target_link_directories(sherpaonnx PRIVATE ${FFMPEG_LIB_DIR})
+if(USE_LIBARCHIVE_PREBUILT AND LIBARCHIVE_LIB_DIR)
+    target_link_directories(sherpaonnx PRIVATE ${LIBARCHIVE_LIB_DIR})
+endif()
+if(SHERPA_C_API_LIB_DIR)
+    target_link_directories(sherpaonnx PRIVATE ${SHERPA_C_API_LIB_DIR})
+    target_link_libraries(sherpaonnx PRIVATE sherpa-onnx-c-api)
+endif()
+target_link_libraries(sherpaonnx
+    PRIVATE
+    archive
+    avcodec
+    avformat
+    avutil
+    avfilter
+    swresample
+    log
+    android
+)
+
+# Compiler flags for our library
+target_compile_options(sherpaonnx PRIVATE
+    -Wall
+    -Wextra
+    -fvisibility=hidden
+)

package/android/src/main/cpp/CMakePresets.json

@@ -0,0 +1,54 @@
+{
+  "version": 3,
+  "configurePresets": [
+    {
+      "name": "default",
+      "description": "Android NDK development preset",
+      "hidden": false,
+      "binaryDir": "${sourceDir}/../../../build",
+      "cacheVariables": {
+        "ANDROID_ABI": "arm64-v8a",
+        "ANDROID_PLATFORM": "android-24",
+        "CMAKE_EXPORT_COMPILE_COMMANDS": true
+      }
+    },
+    {
+      "name": "android-arm64",
+      "inherits": "default",
+      "description": "Build for Android ARM64",
+      "cacheVariables": {
+        "ANDROID_ABI": "arm64-v8a"
+      }
+    },
+    {
+      "name": "android-armv7",
+      "inherits": "default",
+      "description": "Build for Android ARMv7",
+      "cacheVariables": {
+        "ANDROID_ABI": "armeabi-v7a"
+      }
+    },
+    {
+      "name": "android-x86",
+      "inherits": "default",
+      "description": "Build for Android x86",
+      "cacheVariables": {
+        "ANDROID_ABI": "x86"
+      }
+    },
+    {
+      "name": "android-x86_64",
+      "inherits": "default",
+      "description": "Build for Android x86_64",
+      "cacheVariables": {
+        "ANDROID_ABI": "x86_64"
+      }
+    }
+  ],
+  "buildPresets": [
+    {
+      "name": "default",
+      "configurePreset": "default"
+    }
+  ]
+}

package/android/src/main/cpp/crypto/sha256.cpp

@@ -0,0 +1,174 @@
+/**
+ * sha256.cpp
+ *
+ * Purpose: SHA-256 implementation for file hashing. Used by the archive helper (Android) for
+ * integrity verification of extracted model archives.
+ */
+#include "crypto/sha256.h"
+
+#include <cstring>
+
+namespace {
+constexpr uint32_t kInitState[8] = {
+    0x6a09e667u,
+    0xbb67ae85u,
+    0x3c6ef372u,
+    0xa54ff53au,
+    0x510e527fu,
+    0x9b05688cu,
+    0x1f83d9abu,
+    0x5be0cd19u,
+};
+
+constexpr uint32_t kRoundConstants[64] = {
+    0x428a2f98u, 0x71374491u, 0xb5c0fbcfu, 0xe9b5dba5u, 0x3956c25bu,
+    0x59f111f1u, 0x923f82a4u, 0xab1c5ed5u, 0xd807aa98u, 0x12835b01u,
+    0x243185beu, 0x550c7dc3u, 0x72be5d74u, 0x80deb1feu, 0x9bdc06a7u,
+    0xc19bf174u, 0xe49b69c1u, 0xefbe4786u, 0x0fc19dc6u, 0x240ca1ccu,
+    0x2de92c6fu, 0x4a7484aau, 0x5cb0a9dcu, 0x76f988dau, 0x983e5152u,
+    0xa831c66du, 0xb00327c8u, 0xbf597fc7u, 0xc6e00bf3u, 0xd5a79147u,
+    0x06ca6351u, 0x14292967u, 0x27b70a85u, 0x2e1b2138u, 0x4d2c6dfcu,
+    0x53380d13u, 0x650a7354u, 0x766a0abbu, 0x81c2c92eu, 0x92722c85u,
+    0xa2bfe8a1u, 0xa81a664bu, 0xc24b8b70u, 0xc76c51a3u, 0xd192e819u,
+    0xd6990624u, 0xf40e3585u, 0x106aa070u, 0x19a4c116u, 0x1e376c08u,
+    0x2748774cu, 0x34b0bcb5u, 0x391c0cb3u, 0x4ed8aa4au, 0x5b9cca4fu,
+    0x682e6ff3u, 0x748f82eeu, 0x78a5636fu, 0x84c87814u, 0x8cc70208u,
+    0x90befffau, 0xa4506cebu, 0xbef9a3f7u, 0xc67178f2u,
+};
+
+inline uint32_t rotr(uint32_t value, uint32_t bits) {
+  return (value >> bits) | (value << (32 - bits));
+}
+
+inline uint32_t ch(uint32_t x, uint32_t y, uint32_t z) {
+  return (x & y) ^ (~x & z);
+}
+
+inline uint32_t maj(uint32_t x, uint32_t y, uint32_t z) {
+  return (x & y) ^ (x & z) ^ (y & z);
+}
+
+inline uint32_t big_sigma0(uint32_t x) {
+  return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
+}
+
+inline uint32_t big_sigma1(uint32_t x) {
+  return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
+}
+
+inline uint32_t small_sigma0(uint32_t x) {
+  return rotr(x, 7) ^ rotr(x, 18) ^ (x >> 3);
+}
+
+inline uint32_t small_sigma1(uint32_t x) {
+  return rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10);
+}
+
+void process_block(Sha256Context* ctx, const uint8_t block[64]) {
+  uint32_t w[64];
+  for (int i = 0; i < 16; ++i) {
+    int idx = i * 4;
+    w[i] = (static_cast<uint32_t>(block[idx]) << 24) |
+           (static_cast<uint32_t>(block[idx + 1]) << 16) |
+           (static_cast<uint32_t>(block[idx + 2]) << 8) |
+           (static_cast<uint32_t>(block[idx + 3]));
+  }
+  for (int i = 16; i < 64; ++i) {
+    w[i] = small_sigma1(w[i - 2]) + w[i - 7] + small_sigma0(w[i - 15]) + w[i - 16];
+  }
+
+  uint32_t a = ctx->state[0];
+  uint32_t b = ctx->state[1];
+  uint32_t c = ctx->state[2];
+  uint32_t d = ctx->state[3];
+  uint32_t e = ctx->state[4];
+  uint32_t f = ctx->state[5];
+  uint32_t g = ctx->state[6];
+  uint32_t h = ctx->state[7];
+
+  for (int i = 0; i < 64; ++i) {
+    uint32_t t1 = h + big_sigma1(e) + ch(e, f, g) + kRoundConstants[i] + w[i];
+    uint32_t t2 = big_sigma0(a) + maj(a, b, c);
+    h = g;
+    g = f;
+    f = e;
+    e = d + t1;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2;
+  }
+
+  ctx->state[0] += a;
+  ctx->state[1] += b;
+  ctx->state[2] += c;
+  ctx->state[3] += d;
+  ctx->state[4] += e;
+  ctx->state[5] += f;
+  ctx->state[6] += g;
+  ctx->state[7] += h;
+}
+}  // namespace
+
+void sha256_init(Sha256Context* ctx) {
+  ctx->total_bits = 0;
+  ctx->buffer_size = 0;
+  std::memcpy(ctx->state, kInitState, sizeof(kInitState));
+}
+
+void sha256_update(Sha256Context* ctx, const uint8_t* data, size_t len) {
+  if (len == 0) {
+    return;
+  }
+
+  ctx->total_bits += static_cast<uint64_t>(len) * 8u;
+  size_t offset = 0;
+
+  if (ctx->buffer_size > 0) {
+    size_t to_copy = 64 - ctx->buffer_size;
+    if (to_copy > len) {
+      to_copy = len;
+    }
+    std::memcpy(ctx->buffer + ctx->buffer_size, data, to_copy);
+    ctx->buffer_size += to_copy;
+    offset += to_copy;
+    if (ctx->buffer_size == 64) {
+      process_block(ctx, ctx->buffer);
+      ctx->buffer_size = 0;
+    }
+  }
+
+  while (offset + 64 <= len) {
+    process_block(ctx, data + offset);
+    offset += 64;
+  }
+
+  if (offset < len) {
+    ctx->buffer_size = len - offset;
+    std::memcpy(ctx->buffer, data + offset, ctx->buffer_size);
+  }
+}
+
+void sha256_final(Sha256Context* ctx, uint8_t out[32]) {
+  uint64_t message_bits = ctx->total_bits;
+  uint8_t padding[64] = {};
+  padding[0] = 0x80;
+
+  size_t pad_len = (ctx->buffer_size < 56) ? (56 - ctx->buffer_size) : (120 - ctx->buffer_size);
+  sha256_update(ctx, padding, pad_len);
+
+  uint8_t length_bytes[8];
+  uint64_t total_bits = message_bits;
+  for (int i = 7; i >= 0; --i) {
+    length_bytes[i] = static_cast<uint8_t>(total_bits & 0xFFu);
+    total_bits >>= 8;
+  }
+  sha256_update(ctx, length_bytes, 8);
+
+  for (int i = 0; i < 8; ++i) {
+    out[i * 4] = static_cast<uint8_t>((ctx->state[i] >> 24) & 0xFFu);
+    out[i * 4 + 1] = static_cast<uint8_t>((ctx->state[i] >> 16) & 0xFFu);
+    out[i * 4 + 2] = static_cast<uint8_t>((ctx->state[i] >> 8) & 0xFFu);
+    out[i * 4 + 3] = static_cast<uint8_t>(ctx->state[i] & 0xFFu);
+  }
+}

package/android/src/main/cpp/crypto/sha256.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+// Minimal SHA-256 implementation for Android builds (no external deps).
+struct Sha256Context {
+  uint64_t total_bits = 0;
+  uint32_t state[8] = {};
+  uint8_t buffer[64] = {};
+  size_t buffer_size = 0;
+};
+
+void sha256_init(Sha256Context* ctx);
+void sha256_update(Sha256Context* ctx, const uint8_t* data, size_t len);
+void sha256_final(Sha256Context* ctx, uint8_t out[32]);