@gatekeeperx/cordova-plugin-devicex 1.2.5

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+## [1.0.0] - 2026-01-19
+### Added
+- Initial release
+- Android support with cordova-android >= 11
+- Pre-compiled AAR bridge (Kotlin)
+- Device Intelligence SDK integration
+- Auto-configuration via plugin variables
+- TypeScript definitions

package/LICENSE

@@ -0,0 +1,11 @@
+Apache License 2.0
+Copyright 2026 GatekeeperX
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,484 @@
+# cordova-plugin-devicex
+
+[![npm version](https://badge.fury.io/js/cordova-plugin-devicex.svg)](https://www.npmjs.com/package/cordova-plugin-devicex)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+Plugin Cordova oficial que expone la potencia del SDK nativo **GatekeeperX Device Intelligence Android**. Actúa como un **Bridge** directo hacia la librería `device-intelligence-android`, exponiendo capacidades de fingerprinting profundo, detección de fraude y telemetría de seguridad en tiempo real.
+
+## 🚀 Features
+
+- ✅ **Detección de rooting/jailbreak** (Magisk, Frida, Xposed, Superuser)
+- ✅ **Identificación de emuladores** (AVD, Genymotion, Bluestacks)
+- ✅ **Risk scoring** basado en +50 señales del dispositivo
+- ✅ **Deep Fingerprinting**:
+  - 🔋 Batería & Energía
+  - 📷 Cámaras & Codecs
+  - 💾 CPU, GPU & Memoria
+  - 📡 Sensores & Input Devices
+  - 📦 Package Manager & Settings
+- ✅ **Event tracking** con telemetría de seguridad automática
+- ✅ **Configuración manual** flexible desde el código
+- ✅ **TypeScript definitions** incluidas
+- ✅ **Integration Bridge**: Mapeo directo 1:1 con `device-intelligence-android`
+- ✅ **Soporte cordova-android >= 11**
+
+---
+
+## 📋 Tabla de Contenidos
+
+- [Requisitos](#-requisitos)
+- [Instalación](#-instalación)
+- [Uso](#-uso)
+  - [Ejemplos básicos](#ejemplos-básicos)
+  - [Casos de uso reales](#casos-de-uso-reales)
+- [API Reference](#-api-reference)
+- [Configuración avanzada](#-configuración-avanzada)
+- [Seguridad y mejores prácticas](#-seguridad-y-mejores-prácticas)
+- [Solución de problemas](#-solución-de-problemas)
+- [Desarrollo y contribución](#-desarrollo-y-contribución)
+- [Licencia](#licencia)
+
+---
+
+## ⚡ Quick Start
+
+```bash
+# 1. Instalar plugin desde npm
+ionic cordova plugin add cordova-plugin-devicex
+
+# 2. Agregar plataforma Android 11+
+ionic cordova platform add android@11
+
+# 3. Construir
+ionic cordova build android
+```
+
+**Uso en tu app:**
+
+```typescript
+declare const Devicex: any;
+
+// El SDK debe ser inicializado manualmente antes de su uso
+await Devicex.configure({
+  tenant: 'gatekeeperx',
+  apiKey: 'tu-api-key',
+  environment: 'SANDBOX'
+});
+
+// Enviar eventos con telemetría de seguridad automática
+const result = await Devicex.sendEvent('app_start');
+console.log('Event sent:', result.ok, 'DeviceXId:', result.deviceXId);
+```
+
+---
+
+## 📦 Requisitos
+
+- **Node.js** y npm
+- **Java JDK 11 o 17** (para cordova-android 11+)
+- **Android SDK** instalado y configurado
+- **Ionic CLI** (si usas Ionic)
+
+```bash
+# Configurar Java y Android SDK
+export JAVA_HOME="$(/usr/libexec/java_home -v 17)"
+export ANDROID_SDK_ROOT="$HOME/Library/Android/sdk"
+```
+
+---
+
+## 🔧 Instalación
+
+### Desde npm (recomendado)
+
+```bash
+ionic cordova plugin add cordova-plugin-devicex
+```
+
+### Agregar plataforma Android
+
+```bash
+ionic cordova platform add android@11
+# O versión superior (12, 13, etc.)
+```
+
+### Construir y ejecutar
+
+```bash
+# Build
+ionic cordova build android
+
+# Ejecutar en dispositivo
+ionic cordova run android --device
+
+# Ejecutar en emulador
+ionic cordova run android --emulator
+
+# Ver logs
+adb logcat | grep -i -E "devicex|gatekeeperx"
+```
+
+---
+
+## 💻 Uso
+
+### Declaración TypeScript
+
+```typescript
+// Declarar el objeto global Devicex
+declare const Devicex: any;
+```
+
+### Ejemplos básicos
+
+#### 1. Verificar inicialización
+
+```typescript
+const initialized = await Devicex.isInitialized();
+console.log('SDK initialized:', initialized);
+```
+
+#### 2. Obtener versión del SDK
+
+```typescript
+const version = await Devicex.getVersion();
+console.log('SDK version:', version);
+```
+
+#### 3. Enviar evento personalizado
+
+```typescript
+const result = await Devicex.sendEvent(
+  'view_product',
+  { productId: '12345', category: 'electronics' },
+  { 'X-Trace-Id': 'abc-123' }
+);
+
+console.log('Event sent:', result.ok);
+console.log('Device ID:', result.deviceXId);
+```
+
+### Casos de uso reales
+
+### Casos de uso reales
+
+#### Login seguro
+
+```typescript
+async function handleLogin(username: string, password: string) {
+  // Proceder con login
+  const loginResult = await authenticate(username, password);
+
+  // Enviar evento de login (el SDK adjunta fingerprint y risk signals internamente)
+  await Devicex.sendEvent('login', {
+    method: 'password',
+    success: loginResult.success
+  });
+}
+```
+
+#### Monitoreo de pantallas
+
+```typescript
+// En tu componente/página (Ionic)
+async ionViewDidEnter() {
+  await Devicex.sendEvent('view_screen', {
+    screen: 'home',
+    timestamp: Date.now()
+  });
+}
+```
+
+---
+
+## 📚 API Reference
+
+Este plugin utiliza `DevicexPlugin.kt` para mapear las llamadas JavaScript directamente a los métodos nativos del SDK:
+
+| Método JS | Método Nativo (Kotlin) | Descripción |
+|-----------|------------------------|-------------|
+| `configure()` | `Devicex.configure()` | Inicializa el SDK con tu API Key y Tenant. |
+| `sendEvent()` | `Devicex.sendEvent()` | Envía eventos de negocio asegurados con fingerprinting. |
+| `getVersion()` | `Devicex.getVersion()` | Retorna la versión del SDK nativo subyacente. |
+| `isInitialized()` | `Devicex.isInitialized()` | Verifica si la instancia `agent` está lista. |
+
+### `Devicex.configure(config)`
+
+
+
+Configura el SDK. Este paso es obligatorio antes de realizar cualquier otra llamada.
+
+```typescript
+await Devicex.configure({
+  tenant: 'gatekeeperx',
+  apiKey: 'your-api-key',
+  environment: 'PRODUCTION', // 'DEVELOPMENT' | 'SANDBOX' | 'PRODUCTION'
+  organizationId: 'your-org-id',
+  headers: { 'X-Custom-Header': 'value' } // opcional
+});
+```
+
+**Parámetros:**
+- `tenant` (string, requerido): Tenant de GatekeeperX
+- `apiKey` (string, requerido): API Key de autenticación
+- `environment` (string, opcional): Entorno del SDK
+- `organizationId` (string, opcional): ID de organización
+- `headers` (object, opcional): Headers HTTP personalizados
+
+**Retorna:** `Promise<void>`
+
+---
+
+### `Devicex.isInitialized()`
+
+Verifica si el SDK está inicializado y listo para usarse.
+
+```typescript
+const initialized = await Devicex.isInitialized();
+```
+
+**Retorna:** `Promise<boolean>`
+
+---
+
+### `Devicex.getVersion()`
+
+Obtiene la versión actual del SDK nativo.
+
+```typescript
+const version = await Devicex.getVersion();
+// Ejemplo: "1.1.6"
+```
+
+**Retorna:** `Promise<string>`
+
+---
+
+
+
+### `Devicex.sendEvent(eventType, metadata?, headers?)`
+
+Envía un evento personalizado al backend de GatekeeperX.
+
+```typescript
+const result = await Devicex.sendEvent(
+  'login',
+  { method: 'oauth', provider: 'google' },
+  { 'X-Request-ID': 'abc-123' }
+);
+```
+
+**Parámetros:**
+- `eventType` (string, requerido): Tipo de evento (ej: `'login'`, `'checkout'`, `'view_screen'`)
+- `metadata` (object, opcional): Datos adicionales del evento
+- `headers` (object, opcional): Headers HTTP personalizados para esta request
+
+**Retorna:** `Promise<EventResult>`
+
+```typescript
+interface EventResult {
+  ok: boolean;               // true si el evento se envió exitosamente
+  code?: string;             // Código de respuesta del backend
+  deviceXId?: string;        // ID del dispositivo
+  message?: string;          // Mensaje de éxito
+  errorCode?: string;        // Código de error (si ok=false)
+  errorMessage?: string;     // Mensaje de error (si ok=false)
+  httpCode?: number;         // Código HTTP de la respuesta
+}
+```
+
+---
+
+## ⚙️ Configuración manual
+
+Es obligatorio configurar el SDK al inicio de la aplicación:
+
+```typescript
+// En tu app.component.ts o main.ts
+async ngOnInit() {
+  if (this.platform.is('cordova')) {
+    await (window as any).Devicex.configure({
+      tenant: 'gatekeeperx',
+      apiKey: 'your-api-key',
+      environment: 'PRODUCTION',
+      organizationId: 'org123'
+    });
+  }
+}
+```
+
+### Guardias de plataforma
+
+Siempre verifica que estás en Cordova antes de usar el plugin:
+
+```typescript
+import { Platform } from '@ionic/angular';
+
+constructor(private platform: Platform) {}
+
+async doSomething() {
+  if (this.platform.is('cordova') && (window as any).Devicex) {
+    const risk = await (window as any).Devicex.getRiskAssessment();
+  }
+}
+```
+
+---
+
+## 🔒 Seguridad y mejores prácticas
+
+### ✅ DO
+
+- **Configura el SDK al inicio** mediante el método `configure`
+- **Protege API keys** en CI/CD con secret managers
+- **Usa `DEVELOPMENT`** para desarrollo/pruebas
+- **Usa `PRODUCTION`** solo en builds release
+- **Verifica `platform.is('cordova')`** antes de usar el plugin
+- **Implementa rate limiting** en eventos personalizados
+
+### ❌ DON'T
+
+- ❌ **No hardcodees** API keys en código fuente
+- ❌ **No commitees** credenciales en Git
+- ❌ **No envíes** PII (datos personales) en metadata de eventos
+- ❌ **No uses** el mismo API key para dev y prod
+
+### Ejemplo de integración segura
+
+### Ejemplo de integración segura
+
+```typescript
+async ionViewDidLoad() {
+  if (!this.platform.is('cordova')) return;
+
+  // El SDK adjuntará automáticamente las señales de seguridad
+  const result = await (window as any).Devicex.sendEvent('page_view', {
+    page: 'home'
+  });
+  
+  console.log('Security telemetry sent:', result.ok);
+}
+```
+
+---
+
+## 🛠 Solución de problemas
+
+### Error: "class not found" o referencias no resueltas
+
+**Causa:** AAR no incluidos o Gradle no configurado correctamente.
+
+**Solución:**
+```bash
+# Verifica que existan los AAR
+ls -lh platforms/android/app/libs/devicex*.aar
+
+# Re-agregar plugin
+ionic cordova plugin rm cordova-plugin-devicex
+ionic cordova plugin add cordova-plugin-devicex
+
+# Limpiar y rebuild
+ionic cordova platform rm android
+ionic cordova platform add android@11
+ionic cordova build android
+```
+
+---
+
+### Error: Conflictos de dependencias Kotlin
+
+**Causa:** Versiones incompatibles de Kotlin en tu proyecto.
+
+**Solución:**
+
+Este plugin usa:
+- `kotlin-stdlib:1.9.25`
+- `kotlinx-coroutines-android:1.7.3`
+
+Asegúrate de no forzar versiones diferentes en tu `build.gradle`.
+
+---
+
+### Warning: "Mutating configuration after resolution"
+
+**Causa:** Warning de Gradle 8.x relacionado con el hook de configuración.
+
+**Solución:** Este es un aviso no bloqueante. La build funcionará correctamente. Se resolverá en futuras versiones del plugin.
+
+---
+
+### Plugin no disponible en runtime
+
+**Causa:** No verificaste que Cordova esté cargado.
+
+**Solución:**
+```typescript
+// Espera a que Cordova esté listo
+this.platform.ready().then(() => {
+  if ((window as any).Devicex) {
+    // Usa el plugin aquí
+  }
+});
+```
+
+---
+
+## 🏗 Desarrollo y contribución
+
+### Qué incluye este plugin
+
+- `src/android/libs/devicex-bridge.aar`: Bridge Kotlin con API Cordova
+- `src/android/libs/devicex-1.1.3.aar`: SDK Device Intelligence empaquetado
+- `www/devicex.js`: Interfaz JavaScript
+- `types/index.d.ts`: Definiciones TypeScript
+- Dependencias: `kotlin-stdlib:1.9.25`, `kotlinx-coroutines-android:1.7.3`
+
+### Reconstruir AARs (solo mantenedores)
+
+**Compilar SDK:**
+```bash
+cd device-intelligence-android
+export JAVA_HOME="$(/usr/libexec/java_home -v 11)"
+./gradlew :devicex:clean :devicex:assembleProdEnvRelease
+./gradlew :devicex:publishAgentProductionReleasePublicationToMavenLocal
+```
+
+**Compilar bridge:**
+```bash
+cd devicex-bridge-android
+export JAVA_HOME="$(/usr/libexec/java_home -v 11)"
+./gradlew :bridge:clean :bridge:assembleRelease
+```
+
+**Copiar AARs al plugin:**
+```bash
+cp devicex-bridge-android/bridge/build/outputs/aar/devicex-bridge.aar \
+   cordova-plugin-devicex/src/android/libs/
+
+cp ~/.m2/repository/com/gatekeeperx/devicex/1.1.6/devicex-1.1.3.aar \
+   cordova-plugin-devicex/src/android/libs/
+```
+
+### Publicar a npm
+
+```bash
+# Actualizar versión
+npm version patch  # o minor/major
+
+# Publicar
+npm publish --access public
+```
+
+---
+
+## Licencia
+
+Apache-2.0
+
+---
+
+## Soporte
+
+- **Documentación:** [https://docs.gatekeeperx.com](https://docs.gatekeeperx.com)
+- **Issues:** [GitHub Issues](https://github.com/gatekeeperx/cordova-plugin-devicex/issues)
+- **npm:** [cordova-plugin-devicex](https://www.npmjs.com/package/cordova-plugin-devicex)

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@gatekeeperx/cordova-plugin-devicex",
+    "version": "1.2.5",
+    "description": "GatekeeperX Device Intelligence Cordova plugin (Android)",
+    "license": "Apache-2.0",
+    "keywords": [
+        "cordova",
+        "cordova-android",
+        "gatekeeperx",
+        "device",
+        "security",
+        "intelligence"
+    ],
+    "engines": [
+        {
+            "name": "cordova-android",
+            "version": ">=11.0.0"
+        }
+    ],
+    "cordova": {
+        "id": "cordova-plugin-devicex",
+        "platforms": [
+            "android"
+        ]
+    },
+    "main": "www/devicex.js",
+    "types": "types/index.d.ts",
+    "files": [
+        "plugin.xml",
+        "www/",
+        "types/",
+        "src/android/",
+        "README.md",
+        "CHANGELOG.md",
+        "LICENSE"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gatekeeperx/deviceX-plugins.git"
+    },
+    "author": "GatekeeperX",
+    "bugs": {
+        "url": "https://github.com/gatekeeperx/deviceX-plugins/issues"
+    },
+    "homepage": "https://github.com/gatekeeperx/deviceX-plugins/tree/master/cordova/cordova-plugin-devicex"
+}

package/plugin.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin id="@gatekeeperx/cordova-plugin-devicex"
+  xmlns="http://apache.org/cordova/ns/plugins/1.0"
+  xmlns:android="http://schemas.android.com/apk/res/android" version="1.2.1">
+  <name>Devicex</name>
+  <description>GatekeeperX Device Intelligence Cordova plugin (Android)</description>
+  <license>Apache-2.0</license>
+  <keywords>cordova, gatekeeperx, device, intelligence, security</keywords>
+
+  <js-module name="Devicex" src="www/devicex.js">
+    <clobbers target="DeviceX" />
+  </js-module>
+
+  <engines>
+    <engine name="cordova-android" version=">=11.0.0" />
+  </engines>
+
+  <platform name="android">
+    <!-- Runtime dependencies -->
+    <!-- Kotlin stdlib alineado con el bridge -->
+    <framework src="org.jetbrains.kotlin:kotlin-stdlib:1.9.25" />
+    <framework src="org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3" />
+
+    <!-- Kotlinx Serialization (requerido por Ktor) -->
+    <framework src="org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2" />
+
+    <!-- Ktor Client (HTTP engine del SDK) -->
+    <framework src="io.ktor:ktor-client-cio:2.3.7" />
+    <framework src="io.ktor:ktor-client-logging:2.3.7" />
+    <framework src="io.ktor:ktor-client-content-negotiation:2.3.7" />
+    <framework src="io.ktor:ktor-serialization-kotlinx-json:2.3.7" />
+    <!-- AARs locales -->
+    <lib-file src="src/android/libs/devicex-bridge.aar" arch="device" />
+    <lib-file src="src/android/libs/devicex-1.2.5.aar" arch="device" />
+
+    <!-- Hook para configurar Gradle -->
+    <hook type="after_plugin_install" src="src/android/hooks/configure-gradle.js" />
+
+    <!-- Registrar el plugin nativo en config.xml -->
+    <config-file target="res/xml/config.xml" parent="/*">
+      <feature name="Devicex">
+        <param name="android-package" value="com.gatekeeperx.cordova.DevicexPlugin" />
+        <param name="onload" value="true" />
+      </feature>
+    </config-file>
+
+    <!-- Incluir la clase Java del plugin -->
+    <source-file src="src/android/com/gatekeeperx/cordova/DevicexPlugin.java" target-dir="src/com/gatekeeperx/cordova" />
+  </platform>
+</plugin>

package/src/android/com/gatekeeperx/cordova/DevicexPlugin.java

@@ -0,0 +1,204 @@
+package com.gatekeeperx.cordova;
+
+import android.content.Context;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class DevicexPlugin extends CordovaPlugin {
+
+    @Override
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        try {
+            Context ctx = cordova.getActivity().getApplicationContext();
+            android.util.Log.d("DevicexPlugin", "Reading meta-data from manifest...");
+
+            android.content.pm.ApplicationInfo ai = ctx.getPackageManager()
+                    .getApplicationInfo(ctx.getPackageName(), android.content.pm.PackageManager.GET_META_DATA);
+            android.os.Bundle meta = ai.metaData;
+
+            if (meta == null) {
+                android.util.Log.e("DevicexPlugin", "No meta-data found in manifest");
+                return;
+            }
+
+            String tenant = meta.getString("com.gatekeeperx.deviceintelligence.TENANT");
+            String apiKey = meta.getString("com.gatekeeperx.deviceintelligence.API_KEY");
+            String env = meta.getString("com.gatekeeperx.deviceintelligence.ENVIRONMENT");
+            String orgId = meta.getString("com.gatekeeperx.deviceintelligence.ORGANIZATION_ID");
+
+            android.util.Log.d("DevicexPlugin", "Tenant: " + tenant + ", Env: " + env);
+
+            if (tenant == null || tenant.trim().isEmpty() || apiKey == null || apiKey.trim().isEmpty()) {
+                android.util.Log.d("DevicexPlugin", "Auto-config skipped: no credentials provided");
+                return;
+            }
+
+            boolean ok = DevicexBridge.INSTANCE.configure(
+                    ctx,
+                    tenant.trim(),
+                    apiKey.trim(),
+                    env != null ? env.trim() : "PRODUCTION",
+                    orgId != null ? orgId.trim() : null,
+                    null);
+
+            android.util.Log.d("DevicexPlugin", "Manual configure result: " + ok);
+        } catch (Throwable e) {
+            android.util.Log.e("DevicexPlugin", "Error initializing: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
+        switch (action) {
+            case "configure":
+                configure(args, callbackContext);
+                return true;
+            case "sendEvent":
+                sendEvent(args, callbackContext);
+                return true;
+            case "isInitialized":
+                try {
+                    boolean value = DevicexBridge.INSTANCE.isInitialized();
+                    callbackContext.success(new JSONObject().put("value", value));
+                } catch (JSONException e) {
+                    callbackContext.error(e.getMessage());
+                }
+                return true;
+            case "getVersion":
+                try {
+                    String value = DevicexBridge.INSTANCE.getVersion();
+                    callbackContext.success(new JSONObject().put("value", value));
+                } catch (JSONException e) {
+                    callbackContext.error(e.getMessage());
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private void configure(JSONArray args, CallbackContext cb) {
+        try {
+            JSONObject obj = args.optJSONObject(0);
+            if (obj == null)
+                obj = new JSONObject();
+            Context ctx = cordova.getActivity().getApplicationContext();
+            String tenant = obj.optString("tenant", "").trim();
+            String apiKey = obj.optString("apiKey", "").trim();
+            String orgId = obj.optString("organizationId", "").trim();
+            String env = obj.optString("environment", "PRODUCTION").trim();
+            JSONObject headersObj = obj.optJSONObject("headers");
+            Map<String, String> headers = headersObj != null ? toStringMap(headersObj) : new HashMap<>();
+
+            if (tenant.isEmpty() || apiKey.isEmpty()) {
+                cb.error("tenant and apiKey are required");
+                return;
+            }
+
+            boolean ok = DevicexBridge.INSTANCE.configure(
+                    ctx,
+                    tenant,
+                    apiKey,
+                    env,
+                    orgId.isEmpty() ? null : orgId,
+                    headers);
+            if (ok)
+                cb.success();
+            else
+                cb.error("configure failed");
+        } catch (Throwable e) {
+            cb.error(e.getMessage());
+        }
+    }
+
+    private void sendEvent(JSONArray args, final CallbackContext cb) {
+        try {
+            JSONObject obj = args.optJSONObject(0);
+            if (obj == null)
+                obj = new JSONObject();
+            String name = obj.optString("name", "").trim();
+            if (name.isEmpty()) {
+                cb.error("name is required");
+                return;
+            }
+            JSONObject propsObj = obj.optJSONObject("properties");
+            JSONObject headersObj = obj.optJSONObject("headers");
+            Map<String, Object> properties = propsObj != null ? toAnyMap(propsObj) : new HashMap<String, Object>();
+            Map<String, String> headers = headersObj != null ? toStringMap(headersObj) : new HashMap<String, String>();
+
+            @SuppressWarnings("unchecked")
+            DevicexBridge.EventCallback callback = new DevicexBridge.EventCallback() {
+                @Override
+                public void onResult(Map result) {
+                    try {
+                        cb.success(new JSONObject(result));
+                    } catch (Throwable t) {
+                        cb.error(t.getMessage());
+                    }
+                }
+            };
+            DevicexBridge.INSTANCE.sendEvent(name, properties, headers, callback);
+        } catch (Throwable e) {
+            cb.error(e.getMessage());
+        }
+    }
+
+    // Helpers
+    private static Map<String, String> toStringMap(JSONObject obj) {
+        Map<String, String> map = new HashMap<>();
+        Iterator<String> it = obj.keys();
+        while (it.hasNext()) {
+            String k = it.next();
+            String v = obj.optString(k, null);
+            if (v != null)
+                map.put(k, v);
+        }
+        return map;
+    }
+
+    private static Map<String, Object> toAnyMap(JSONObject obj) {
+        Map<String, Object> map = new HashMap<>();
+        Iterator<String> it = obj.keys();
+        while (it.hasNext()) {
+            String k = it.next();
+            Object v = obj.opt(k);
+            map.put(k, fromJson(v));
+        }
+        return map;
+    }
+
+    private static Object fromJson(Object v) {
+        if (v == null || v == JSONObject.NULL)
+            return null;
+        if (v instanceof JSONObject)
+            return toAnyMap((JSONObject) v);
+        if (v instanceof JSONArray)
+            return toList((JSONArray) v);
+        if (v instanceof String || v instanceof Boolean || v instanceof Integer || v instanceof Long
+                || v instanceof Double)
+            return v;
+        return String.valueOf(v);
+    }
+
+    private static List<Object> toList(JSONArray arr) {
+        List<Object> list = new ArrayList<>();
+        for (int i = 0; i < arr.length(); i++) {
+            Object v = arr.opt(i);
+            list.add(fromJson(v));
+        }
+        return list;
+    }
+}

package/src/android/hooks/configure-gradle.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+module.exports = function (context) {
+    const platforms = context.opts.cordova.platforms;
+    if (platforms.indexOf('android') === -1) return;
+
+    const buildGradlePath = path.join(
+        context.opts.projectRoot,
+        'platforms',
+        'android',
+        'app',
+        'build.gradle'
+    );
+
+    if (!fs.existsSync(buildGradlePath)) {
+        console.log('[devicex] build.gradle no encontrado');
+        return;
+    }
+
+    let buildGradle = fs.readFileSync(buildGradlePath, 'utf8');
+
+    // Agregar repositorio flatDir si no existe en el bloque principal
+    if (buildGradle.indexOf('flatDir') === -1) {
+        const repoBlock = `
+repositories {
+    flatDir {
+        dirs 'libs'
+    }
+}
+`;
+        // Insertar antes del último bloque dependencies (el principal)
+        const lastDepsIndex = buildGradle.lastIndexOf('dependencies {');
+        if (lastDepsIndex !== -1) {
+            buildGradle = buildGradle.slice(0, lastDepsIndex) +
+                repoBlock + '\n' +
+                buildGradle.slice(lastDepsIndex);
+        }
+    }
+
+    // Agregar dependencias de AARs después de fileTree si no existen
+    if (buildGradle.indexOf('devicex-bridge') === -1) {
+        const depsBlock = `    implementation files('libs/devicex-bridge.aar')
+    implementation files('libs/devicex-1.2.5.aar')
+    
+    // Dependencias del SDK Devicex
+    implementation 'io.ktor:ktor-client-core:2.3.7'
+    implementation 'io.ktor:ktor-client-okhttp:2.3.7'
+    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2'
+`;
+        // Buscar después de fileTree en el bloque principal
+        buildGradle = buildGradle.replace(
+            /(implementation fileTree\(dir: 'libs', include: '\*\.jar'\))/,
+            '$1\n' + depsBlock
+        );
+    }
+
+    fs.writeFileSync(buildGradlePath, buildGradle, 'utf8');
+    console.log('[devicex] build.gradle configurado con AARs locales');
+};

package/types/index.d.ts

@@ -0,0 +1,52 @@
+// Type definitions for cordova-plugin-devicex
+// Project: https://npmjs.com/package/cordova-plugin-devicex
+// Definitions by: GatekeeperX
+
+export type Environment = 'DEV' | 'DEVELOPMENT' | 'SANDBOX' | 'STAGE' | 'STAGING' | 'PROD' | 'PRODUCTION';
+
+export interface ConfigureOptions {
+    tenant: string;
+    apiKey: string;
+    organizationId?: string;
+    environment?: Environment;
+    headers?: Record<string, string>;
+}
+
+export interface EventSuccess {
+    ok: true;
+    code: number;
+    deviceXId: string;
+    message?: string;
+}
+
+export interface EventFailure {
+    ok: false;
+    errorCode: string;
+    errorMessage: string;
+    httpCode?: number | null;
+}
+
+export type EventResult = EventSuccess | EventFailure;
+
+export interface RiskAssessment {
+    isRooted: boolean;
+    isFridaDetected: boolean;
+    isXposedDetected: boolean;
+    isMagiskDetected: boolean;
+    isEmulator: boolean;
+    isDebuggerAttached: boolean;
+    isHookingDetected: boolean;
+    riskScore: number;
+    riskLevel: string;
+}
+
+declare const Devicex: {
+    configure(options: ConfigureOptions): Promise<void>;
+    sendEvent(name: string, properties?: Record<string, any>, headers?: Record<string, string>): Promise<EventResult>;
+    getRiskAssessment(): Promise<RiskAssessment>;
+    isInitialized(): Promise<boolean>;
+    getVersion(): Promise<string>;
+};
+
+export default Devicex;
+export as namespace Devicex;

package/www/devicex.js

@@ -0,0 +1,28 @@
+var exec = require('cordova/exec');
+var PLUGIN = 'Devicex';
+
+function call(action, args) {
+  return new Promise(function (resolve, reject) {
+    exec(function (res) { resolve(res); }, function (err) { reject(err); }, PLUGIN, action, args || []);
+  });
+}
+
+exports.configure = function (options) {
+  options = options || {};
+  return call('configure', [options]);
+};
+
+exports.sendEvent = function (name, properties, headers) {
+  if (!name || typeof name !== 'string') {
+    return Promise.reject('name is required');
+  }
+  return call('sendEvent', [{ name: name, properties: properties || {}, headers: headers || {} }]);
+};
+
+exports.isInitialized = function () {
+  return call('isInitialized', []).then(function (res) { return res && res.value === true; });
+};
+
+exports.getVersion = function () {
+  return call('getVersion', []).then(function (res) { return (res && res.value) || ''; });
+};