Refactor plugin native library handling: update documentation for clarity on JNI integration and automatic packaging in the plugin JAR. Enhance build.gradle.kts to streamline native library synchronization and improve task dependencies. Add link to verify obfuscation in README.md.

Author: efraespada

README.md

@@ -79,7 +79,7 @@ For **Groovy** use `buildscript` / `apply plugin: 'dev.vyp.stringcare.plugin'` a
 
 **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`).
+**Plugin host natives:** With submodule `stringcare-jni` and `dist/` built, the plugin JAR picks up **`dist/{macos,linux,windows}/`** automatically on each **`preparePluginNativeLibraries`** (runs before `processResources`). Use **`./gradlew :plugin:syncPluginNativeLibraries`** only if you want to commit those binaries under `plugin/.../jni/`. macOS: universal `libsignKey.dylib`; Linux/Windows: x64 + arm64 `*.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`).
 

docs/README.md

@@ -15,5 +15,6 @@ StringCare Android provides **compile-time obfuscation** for strings and assets
 - [Architecture](architecture.md) — Mono-repo layout, library vs plugin, JNI, and Variant API.
 - [Contributing](contributing.md) — Release workflow secrets and local publish steps.
 - [Troubleshooting](troubleshooting.md) — Submodule, signing, plugin not found, publish job, JNI/NDK.
+- [Verify obfuscation](verify-obfuscation.md) — Comandos `gradlew` para comprobar que strings/assets se ofuscan (nativas del host, `syncPluginNativeLibraries`).
 
 For the main project README and badges, see the [root README](../README.md).

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** (`.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.
+- Contains **JNI** (`.dylib`, `.dll`, `.so`) for the **host** (Gradle on macOS, Windows, or Linux). Prebuilts come from **stringcare-jni** `dist/{macos,linux,windows}/`; **`preparePluginNativeLibraries`** (before `processResources`) copies them into `build/generated/stringcare-plugin-natives/` and they are packaged in the JAR. Optional checked-in copies live under `internal/jni/`. macOS: universal `libsignKey.dylib`; Linux/Windows: x64 + arm64. Separate from the app’s **sc-native-lib** in the library module.
 
 ## Flow
 

docs/build-and-ci.md

@@ -38,16 +38,16 @@ To run instrumented tests (requires an emulator or device):
 - **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 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
+### Plugin host natives in the JAR
 
-After building natives in the submodule (see that repo’s build output), run from the stringcare-android root:
+After building natives in the submodule (`stringcare-jni/dist/{macos,linux,windows}/`), **every** `:plugin:jar` / `:plugin:processResources` runs **`preparePluginNativeLibraries`**, which copies `dist/` into `plugin/build/generated/stringcare-plugin-natives/` and packages those files into the plugin JAR. No manual step is required for local builds as long as the submodule is present and `dist/` is populated.
+
+Optional — copy prebuilts into Git-tracked `jni/` (for publishing without submodule on CI):
 
 ```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
 
 For **GitHub Actions** (or any CI), always checkout the repo **with submodules** so that the JNI code is available:

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 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).
+- The **plugin** ships JNI for the **host** (Gradle runs on macOS, Windows, or Linux). Prebuilts live in **stringcare-jni** (`dist/macos`, `dist/linux`, `dist/windows`). The plugin build **automatically** packs `dist/` into the JAR via **`preparePluginNativeLibraries`** (as long as `stringcare-jni/dist` exists after submodule init + native build). Optional: **`./gradlew :plugin:syncPluginNativeLibraries`** copies `dist/` into `plugin/.../jni/` for Git. If your OS/arch binary is still missing from `dist/`, set **`skip = true`** or complete the native build. See [Build and CI](build-and-ci.md) and [Configuration](configuration.md).

docs/verify-obfuscation.md

@@ -0,0 +1,74 @@
+# Verificar ofuscación con Gradle
+
+La ofuscación de strings y assets en el **módulo `app`** depende de que el plugin cargue la librería nativa del **host** (el mismo OS y arquitectura que ejecuta Gradle). Si no carga, verás en consola:
+
+```text
+Skipping <variant> (native library not available for this architecture)
+```
+
+## 1. Requisitos
+
+1. Submódulo **`stringcare-jni`** inicializado y precompilados generados en `stringcare-jni/dist/` (tras el build en stringcare-android-c).
+2. **Automático:** al compilar el plugin (`:plugin:jar` o cualquier build que lo use), la tarea **`preparePluginNativeLibraries`** copia `stringcare-jni/dist/{macos,linux,windows}/` a `build/generated/stringcare-plugin-natives/` y **`processResources`** las empaqueta en el JAR. No hace falta `syncPluginNativeLibraries` salvo que quieras **commitear** las binarias en `src/.../jni/`.
+3. Si **no** existe `stringcare-jni/dist/`, se usan los ficheros ya presentes en `plugin/.../internal/jni/` (fallback).
+4. En el JAR del plugin deben estar, según tu máquina:
+   - **macOS:** `libsignKey.dylib` (universal o la variante correcta).
+   - **Linux:** `libsignKey.so` y/o `libsignKey-arm64.so`.
+   - **Windows:** `libsignKey.dll` y/o `libsignKey-arm64.dll`.
+
+Tras actualizar `dist/` en el submódulo, basta con **`./gradlew :plugin:jar`** o **`./gradlew :app:assemble...`** para volver a empaquetar las nativas.
+
+## 2. Tareas útiles
+
+Listar tareas del plugin en el app:
+
+```bash
+./gradlew :app:tasks --all | grep -i stringcare
+```
+
+Tareas típicas (por variante; ejemplo **prodDebug**):
+
+| Tarea | Rol |
+|-------|-----|
+| `stringcareBeforeMergeResourcesProdDebug` | Ofusca `strings.xml` antes del merge de recursos |
+| `stringcareAfterMergeResourcesProdDebug` | Restaura strings desde backup temporal |
+| `stringcareBeforeMergeAssetsProdDebug` | Ofusca assets (p. ej. `*.json`) |
+| `stringcareAfterMergeAssetsProdDebug` | Restaura assets |
+| `stringcarePreview` | Vista previa / diagnóstico |
+| `stringcareTestObfuscate` | Prueba de ofuscación (tests del plugin) |
+
+## 3. Comprobar que no se salta la ofuscación
+
+Con salida detallada:
+
+```bash
+./gradlew :app:stringcareBeforeMergeResourcesProdDebug --rerun-tasks --info 2>&1 | tee stringcare-verify.log
+```
+
+**Esperado si la nativa carga y hay huella de firma:** mensajes del plugin con variante y clave SHA1, backup de recursos, etc. **No** debe aparecer la línea de *Skipping … native library*.
+
+Comprobar también assets:
+
+```bash
+./gradlew :app:stringcareBeforeMergeAssetsProdDebug --rerun-tasks --info 2>&1 | tee -a stringcare-verify.log
+```
+
+## 4. Build completa
+
+```bash
+./gradlew :app:clean :app:assembleProdDebug --rerun-tasks --info 2>&1 | tee stringcare-assemble.log
+```
+
+Durante el merge, los recursos en disco pueden estar ofuscados de forma temporal; al final **`stringcareAfterMerge*`** restaura los fuentes del módulo. La comprobación fiable es el **log** de las tareas `BeforeMerge` (y que exista huella vía `signingReport` o configuración del plugin), no solo el `values.xml` final empaquetado.
+
+## 5. Huella de firma (SHA1)
+
+Si no hay `mockedFingerprint` en el bloque `stringcare { }`, el plugin usa `./gradlew signingReport` para la variante. Sin SHA1 válido, puede no ofuscar aunque la nativa cargue. Para depurar:
+
+```bash
+./gradlew :app:signingReport
+```
+
+---
+
+**Resumen:** Si ves *Skipping … native library*, comprueba que exista `stringcare-jni/dist/` con las tres plataformas (o al menos la del host), ejecuta **`./gradlew :plugin:clean :plugin:jar`** y repite. Si el submódulo no está inicializado, haz `git submodule update --init --recursive` o usa `syncPluginNativeLibraries` + commit en `jni/` como respaldo.

plugin/build.gradle.kts

@@ -94,24 +94,50 @@ if (project.hasProperty("signing.gnupg.keyName")) {
     }
 }
 
+/**
+ * Prebuilt natives from stringcare-android-c (submodule `stringcare-jni`).
+ * NOTE: With `includeBuild("plugin")`, this project's `rootProject` is the plugin dir, not stringcare-android —
+ * use a path relative to this project (`../stringcare-jni/dist`).
+ */
+val stringcareJniDist = layout.projectDirectory.dir("../stringcare-jni/dist")
+val pluginJniSource = layout.projectDirectory.dir("src/main/kotlin/dev/vyp/stringcare/plugin/internal/jni")
+val pluginNativesGenerated = layout.buildDirectory.dir("generated/stringcare-plugin-natives")
+
+/**
+ * Packs all host natives into the plugin JAR on every `processResources` / `jar`.
+ * - If `../stringcare-jni/dist/{macos,linux,windows}/` exists (after building in stringcare-android-c), copies from there.
+ * - Otherwise falls back to checked-in files under `internal/jni/`.
+ */
+tasks.register<Sync>("preparePluginNativeLibraries") {
+    into(pluginNativesGenerated)
+    if (stringcareJniDist.asFile.exists()) {
+        from(stringcareJniDist.dir("macos")) { include("*.dylib") }
+        from(stringcareJniDist.dir("linux")) { include("*.so") }
+        from(stringcareJniDist.dir("windows")) { include("*.dll") }
+    } else {
+        from(pluginJniSource) {
+            include("*.dylib", "*.dll", "*.so")
+        }
+    }
+}
+
 tasks.processResources {
     duplicatesStrategy = DuplicatesStrategy.INCLUDE
-    from("src/main/kotlin/dev/vyp/stringcare/plugin/internal/jni") {
+    dependsOn("preparePluginNativeLibraries")
+    from(pluginNativesGenerated) {
         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
+ * Optional: copy dist natives into `src/.../jni/` for committing prebuilts to Git (e.g. Maven publish without submodule on CI).
  */
 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")
+    val dist = stringcareJniDist
+    into(pluginJniSource)
     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(

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

@@ -68,13 +68,13 @@ open class Stark {
 
                     ZipFile(zipFile.absolutePath).use { zip ->
                         zip.entries().asSequence().forEach { entry ->
+                            if (entry.isDirectory) return@forEach
+                            val matches = entry.name == fileName || entry.name.endsWith("/$fileName")
+                            if (!matches) return@forEach
                             zip.getInputStream(entry).use { input ->
-                                if (entry.name == fileName) {
-
-                                    lib = File("${StringCarePlugin.tempFolder}${File.separator}${entry.name}").apply {
-                                        this.outputStream().use { output ->
-                                            input.copyTo(output)
-                                        }
+                                lib = File("${StringCarePlugin.tempFolder}${File.separator}$fileName").apply {
+                                    this.outputStream().use { output ->
+                                        input.copyTo(output)
                                     }
                                 }
                             }