Update JNI submodule reference and enhance plugin native library handling. Modify README.md for clarity on submodule usage and CI integration. Adjust build.gradle.kts to enable native library obfuscation and improve task synchronization for different OS architectures.

Author: efraespada

.gitmodules

@@ -1,5 +1,5 @@
 # JNI native library (private repo). To init: git submodule update --init --recursive
-# If the repo URL is not accessible, place the JNI library at stringcare-jni/ (copy from ../stringcare-jni-android-library) or ensure library/CMakeLists.txt path is correct.
+# If the repo URL is not accessible, place the JNI library at stringcare-jni/ (copy from ../stringcare-android-c) or ensure library/CMakeLists.txt path is correct.
 [submodule "stringcare-jni"]
 	path = stringcare-jni
-	url = [email protected]:vypdev/stringcare-jni-android-library.git
+	url = [email protected]:vypdev/stringcare-android-c.git

README.md

@@ -77,7 +77,9 @@ For **Groovy** use `buildscript` / `apply plugin: 'dev.vyp.stringcare.plugin'` a
 
 #### [Resource Tips](https://github.com/StringCare/AndroidLibrary/wiki/Resource-Tips)
 
-**Build / CI:** This project uses the JNI native library as a Git submodule (`stringcare-jni`). Clone with submodules: `git clone --recurse-submodules ...` or run `git submodule update --init --recursive` after clone. CI workflows must use `checkout` with `submodules: true`.
+**Build / CI:** This project uses the JNI native library as a Git submodule (`stringcare-jni`, e.g. stringcare-android-c). Clone with submodules: `git clone --recurse-submodules ...` or run `git submodule update --init --recursive` after clone. CI workflows must use `checkout` with `submodules: true`.
+
+**Plugin host natives:** After building prebuilts in the submodule (`stringcare-jni/dist/{macos,linux,windows}/`), copy them into the plugin with **`./gradlew :plugin:syncPluginNativeLibraries`**. macOS ships a universal `libsignKey.dylib`; Linux and Windows ship x64 and arm64 variants (`*.so` / `*.dll`).
 
 **Publishing (release workflow):** See [CONTRIBUTING.md](CONTRIBUTING.md) for required secrets: `NEXUS_USERNAME`, `NEXUS_PASSWORD`, `GPG_KEY_ID`, `GPG_PASSPHRASE`, `PAT`. When dispatching the release workflow, set **Publish Maven** to `true` to run the publish job (publishes both `dev.vyp.stringcare:library` and `dev.vyp.stringcare:plugin`).
 

app/build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 
 stringcare {
     debug = false
-    skip = true  // Set to false when running on x86_64 or when arm64 dylib is available; plugin JNI is x86_64 only
+    skip = false  // Obfuscation runs when native lib is available (x86_64 or arm64); otherwise tasks skip automatically
     assetsFiles = mutableListOf("*.json")
     stringFiles = mutableListOf("strings.xml")
     srcFolders = mutableListOf("src/main")

docs/architecture.md

@@ -23,7 +23,7 @@ The **plugin** module:
 
 - Implements the Gradle plugin entry point **`StringCarePlugin`** (implements `Plugin<Project>`), creates the **`stringcare`** extension (`StringCareExtension`) and registers tasks.
 - Uses the **AGP 8.7 Variant API**: it does **not** use `BuildListener`. It uses `project.plugins.withId("com.android.application")` and then `project.extensions.getByType(AndroidComponentsExtension::class.java)` and **`onVariants`** to register per-variant tasks (e.g. `stringcareBeforeMergeResourcesDebug`, `stringcareAfterMergeResourcesDebug`, and the same for Assets). Each variant gets before/after merge tasks for resources and for assets; the “before” tasks obfuscate, the “after” tasks restore originals from backup.
-- Contains **JNI** (dll/dylib) in `src/main/kotlin/.../internal/jni` for development (e.g. signing/fingerprint on the host). These are packaged via `processResources` and are separate from the library’s native code (stringcare-jni).
+- Contains **JNI** (`.dylib`, `.dll`, `.so`) in `src/main/kotlin/.../internal/jni` for the **host** (Gradle on macOS, Windows, or Linux). Prebuilts are built in **stringcare-jni** under `dist/{macos,linux,windows}/` and copied with `:plugin:syncPluginNativeLibraries`. macOS uses a universal `libsignKey.dylib`; Linux and Windows ship x64 and arm64 binaries. Packaged via `processResources`; separate from the app’s **sc-native-lib** in the library module.
 
 ## Flow
 

docs/build-and-ci.md

@@ -36,7 +36,17 @@ To run instrumented tests (requires an emulator or device):
 - **app** — Demo Android application; applies the StringCare plugin and depends on the library.
 - **library** — Android library (AAR) that provides the runtime API (`SC`, `SCTextView`, etc.) and loads the native library from **stringcare-jni** via CMake.
 - **plugin** — Gradle plugin (JVM); included as a **composite build** via `includeBuild("plugin")` in the root `settings.gradle.kts`, not as `include(":plugin")`. So the plugin is built from the `plugin/` directory and applied to the app by ID `dev.vyp.stringcare.plugin`.
-- **stringcare-jni** — Git submodule containing the native C++ code used by the library (and optionally by the plugin for signing/fingerprint). The library’s `CMakeLists.txt` points to `../stringcare-jni/lib` for the native source.
+- **stringcare-jni** — Git submodule containing the native C++ code used by the library and the **plugin host** prebuilts. The library’s `CMakeLists.txt` points to `../stringcare-jni/lib` for the Android JNI source. Plugin host binaries are produced under **`stringcare-jni/dist/`** (`macos/`, `linux/`, `windows/`).
+
+### Syncing plugin host natives into the plugin JAR
+
+After building natives in the submodule (see that repo’s build output), run from the stringcare-android root:
+
+```bash
+./gradlew :plugin:syncPluginNativeLibraries
+```
+
+This copies `dist/macos/*.dylib`, `dist/linux/*.so`, and `dist/windows/*.dll` into `plugin/src/main/kotlin/dev/vyp/stringcare/plugin/internal/jni/` so they are packaged with the plugin.
 
 ## CI
 

docs/troubleshooting.md

@@ -60,4 +60,4 @@ See [Build and CI](build-and-ci.md).
 
 - The **library** requires **minSdk 21** and a valid NDK/CMake setup. The **stringcare-jni** submodule must be present (see “Submodule not loaded” above).
 - **ABI filters:** The library builds for the default ABIs (e.g. armeabi-v7a, arm64-v8a, x86, x86_64). If you restrict ABIs in your app, ensure the library is compatible.
-- The **plugin** ships JNI (dylib/dll) for development (e.g. fingerprint on the host). These are for the plugin’s own use (e.g. signing report); on some environments (e.g. non-x86_64 or when the host library is missing) you may need to set **`skip = true`** in the `stringcare` block to skip obfuscation and still build. See [Build and CI](build-and-ci.md) and [Configuration](configuration.md).
+- The **plugin** ships JNI for the **host** (Gradle runs on macOS, Windows, or Linux). Prebuilts are produced in **stringcare-jni** (stringcare-android-c): `dist/macos/libsignKey.dylib` (universal x86_64+arm64), `dist/linux/libsignKey.so` / `libsignKey-arm64.so`, `dist/windows/libsignKey.dll` / `libsignKey-arm64.dll`. After building there, sync into this repo with **`./gradlew :plugin:syncPluginNativeLibraries`** (requires submodule at `stringcare-jni/`). If the native library for your OS/arch is missing, set **`skip = true`** in the `stringcare` block or run the sync task. See [Build and CI](build-and-ci.md) and [Configuration](configuration.md).

library/CMakeLists.txt

@@ -8,7 +8,7 @@ project("stringcare-native" CXX)
 if(EXISTS "${CMAKE_SOURCE_DIR}/../stringcare-jni/lib/sc-native-lib.cpp")
     set(JNI_SOURCE_DIR "${CMAKE_SOURCE_DIR}/../stringcare-jni/lib")
 else()
-    set(JNI_SOURCE_DIR "${CMAKE_SOURCE_DIR}/../../stringcare-jni-android-library/lib")
+    set(JNI_SOURCE_DIR "${CMAKE_SOURCE_DIR}/../../stringcare-android-c/lib")
 endif()
 
 add_library(sc-native-lib SHARED

plugin/build.gradle.kts

@@ -97,6 +97,27 @@ if (project.hasProperty("signing.gnupg.keyName")) {
 tasks.processResources {
     duplicatesStrategy = DuplicatesStrategy.INCLUDE
     from("src/main/kotlin/dev/vyp/stringcare/plugin/internal/jni") {
-        include("*.dylib", "*.dll")
+        include("*.dylib", "*.dll", "*.so")
+    }
+}
+
+/**
+ * Copy prebuilt plugin natives from the stringcare-jni submodule (stringcare-android-c dist/).
+ * Run after building natives there: ./gradlew :plugin:syncPluginNativeLibraries
+ */
+tasks.register<Copy>("syncPluginNativeLibraries") {
+    val dist = rootProject.layout.projectDirectory.dir("stringcare-jni/dist")
+    val jni = layout.projectDirectory.dir("src/main/kotlin/dev/vyp/stringcare/plugin/internal/jni")
+    from(dist.dir("macos")) { include("*.dylib") }
+    from(dist.dir("linux")) { include("*.so") }
+    from(dist.dir("windows")) { include("*.dll") }
+    into(jni)
+    doFirst {
+        if (!dist.asFile.exists()) {
+            throw GradleException(
+                "stringcare-jni/dist not found. Init submodule: git submodule update --init --recursive " +
+                    "then build natives in stringcare-android-c (see that repo's docs)."
+            )
+        }
     }
 }

plugin/src/main/kotlin/dev/vyp/stringcare/plugin/internal/Execution.kt

@@ -23,7 +23,7 @@ private fun execute(runtime: Runtime, command: String): ExecutionResult {
                     process.outputString()
                 )
             }
-            Os.OSX -> {
+            Os.OSX, Os.LINUX -> {
                 ExecutionResult(
                     command,
                     runtime.exec(

plugin/src/main/kotlin/dev/vyp/stringcare/plugin/internal/Extensions.kt

@@ -51,7 +51,7 @@ fun String.normalizePath(): String {
         .replace("\\\\", "/")
         .replace("//", "/")
     return when (getOs()) {
-        Os.OSX -> unixPath
+        Os.OSX, Os.LINUX -> unixPath
         Os.WINDOWS -> unixPath.replace("/", "\\")
     }
 }