@gatekeeperx/cordova-plugin-devicex 1.2.5 → 1.2.7

package/README.md

@@ -1,484 +1,163 @@
-# cordova-plugin-devicex
+# @gatekeeperx/cordova-plugin-devicex
 
-[![npm version](https://badge.fury.io/js/cordova-plugin-devicex.svg)](https://www.npmjs.com/package/cordova-plugin-devicex)
+[![npm version](https://badge.fury.io/js/%40gatekeeperx%2Fcordova-plugin-devicex.svg)](https://www.npmjs.com/package/@gatekeeperx/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**
+Plugin oficial de Cordova para la integración del SDK **GatekeeperX Device Intelligence** en aplicaciones Android. Proporciona capacidades avanzadas de fingerprinting, detección de fraude (root, emuladores, hooks) y telemetría de seguridad.
 
 ---
 
-## 📋 Tabla de Contenidos
+## 📋 Requisitos
 
-- [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)
+Para integrar este plugin, asegúrate de cumplir con los siguientes requisitos:
 
----
-
-## ⚡ 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"
-```
+- **Cordova Android**: Versión `11.0.0` o superior.
+- **Java**: JDK 11 o 17.
+- **Android SDK**: API Level 21+ soportado (API 31+ recomendado).
+- **GatekeeperX Credentials**: Tenant ID y API Key válidos.
 
 ---
 
 ## 🔧 Instalación
 
-### Desde npm (recomendado)
+Instala el plugin utilizando el CLI de Cordova o Ionic. Esto descargará el paquete de npm y configurará automáticamente las dependencias nativas en tu proyecto.
 
 ```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);
-```
+# Usando Ionic CLI (Recomendado)
+ionic cordova plugin add @gatekeeperx/cordova-plugin-devicex
 
-#### 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);
+# Usando Cordova CLI
+cordova plugin add @gatekeeperx/cordova-plugin-devicex
 ```
 
-### Casos de uso reales
-
-### Casos de uso reales
+### Configuración de Plataforma
 
-#### Login seguro
+Asegúrate de tener la plataforma Android configurada correctamente:
 
-```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()
-  });
-}
+```bash
+cordova platform add android@11
 ```
 
 ---
 
 ## 📚 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. |
+El plugin expone el objeto global `Devicex` una vez que el evento `deviceready` se ha disparado.
 
-### `Devicex.configure(config)`
+### 1. `Devicex.configure(options)`
+Inicializa el SDK con las credenciales de tu proyecto. **Debe llamarse antes que cualquier otro método.**
 
+**Parámetros:**
+- `options` (`ConfigureOptions`):
+    - `tenant` (string, requerido): ID de tu tenant.
+    - `apiKey` (string, requerido): Tu clave de API.
+    - `environment` (string, opcional): `'SANDBOX'`, o `'PRODUCTION'`.
+    - `organizationId` (string, opcional): Identificador de organización.
 
-
-Configura el SDK. Este paso es obligatorio antes de realizar cualquier otra llamada.
-
+**Ejemplo:**
 ```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
+  tenant: 'mi-tenant',
+  apiKey: 'tu-api-key',
+  environment: 'PRODUCTION'
 });
 ```
 
-**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
+### 2. `Devicex.sendEvent(name, properties?, headers?)`
+Envía un evento de telemetría con señales de seguridad adjuntas automáticamente.
 
-**Retorna:** `Promise<void>`
-
----
-
-### `Devicex.isInitialized()`
-
-Verifica si el SDK está inicializado y listo para usarse.
+**Parámetros:**
+- `name` (string, requerido): Nombre del evento (ej: `'login'`, `'checkout'`).
+- `properties` (object, opcional): Metadatos adicionales del evento.
+- `headers` (object, opcional): Cabeceras HTTP personalizadas.
 
+**Ejemplo:**
 ```typescript
-const initialized = await Devicex.isInitialized();
+const result = await Devicex.sendEvent('login', { user: 'id_123' });
+if (result.ok) {
+  console.log('DeviceX ID:', result.deviceXId);
+}
 ```
 
-**Retorna:** `Promise<boolean>`
-
----
+### 3. `Devicex.isInitialized()`
+Verifica si el SDK ha sido configurado correctamente.
 
-### `Devicex.getVersion()`
-
-Obtiene la versión actual del SDK nativo.
+**Retorna:** `Promise<boolean>`
 
-```typescript
-const version = await Devicex.getVersion();
-// Ejemplo: "1.1.6"
-```
+### 4. `Devicex.getVersion()`
+Obtiene la versión del SDK nativo subyacente.
 
 **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
-}
-```
+### 5. `Devicex.evaluateRisk(options)` (Beta)
+Realiza una evaluación de riesgo específica enviando un payload al motor de decisión.
 
 ---
 
-## ⚙️ Configuración manual
-
-Es obligatorio configurar el SDK al inicio de la aplicación:
+## 🚀 Uso Rápido (Ionic/Angular)
 
 ```typescript
-// En tu app.component.ts o main.ts
-async ngOnInit() {
+// En app.component.ts
+async initializeApp() {
+  await this.platform.ready();
+  
   if (this.platform.is('cordova')) {
-    await (window as any).Devicex.configure({
-      tenant: 'gatekeeperx',
-      apiKey: 'your-api-key',
-      environment: 'PRODUCTION',
-      organizationId: 'org123'
-    });
+    declare const Devicex: any;
+    
+    try {
+      await Devicex.configure({
+        tenant: 'gatekeeperx', // tu tenant
+        apiKey: 'YOUR_API_KEY', // tu api key
+        environment: 'PRODUCTION' // PRODUCTION o SANDBOX
+      });
+      console.log('DeviceX Ready');
+    } catch (err) {
+      console.error('DeviceX Init Error', err);
+    }
   }
 }
-```
 
-### 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();
-  }
+async login() {
+    //,,, logica previo a enviar el login
+
+    loading.present();
+    try {
+        // Enviar evento de login para obtener deviceXId
+        const result = await this.deviceX.sendEvent('login', {
+            username: this.username,
+            method: 'password',
+            timestamp: new Date().toISOString(),
+            screen: 'login'
+        });
+        console.log('Evento enviado, deviceXId:', result.deviceXId);
+
+
+        /** EVALUACION DE RIESGO
+         *  Evaluar riesgo con GatekeeperX - debe hacerse back to back, no en el cliente.
+         *  debe ser dentro del proceso del login en el backend
+         *  si la decision es allow, se puede continuar con el login
+         *  si la decision es deny, se debe denegar el acceso
+         *  si la decision es unknown, se debe denegar el acceso
+         */
+       
+        //invocar proceso de login en el backend
+        const response = await this.http.post(BACKEND_URL, {
+            username: this.username,
+            password: this.password,
+            deviceXId: result.deviceXId
+        });
+        console.log('Login response:', JSON.stringify(response, null, 2));
+
+        loading.dismiss();
+
+
+        console.log('Login event result:', JSON.stringify(result, null, 2));
+
+    } catch (error) {
+        loading.dismiss();
+        console.error('Login event error:', error);
+        this.showAlert('Error', 'No se pudo enviar el evento de login', 'error');
+    }
 }
 ```
-
----
-
-## 🔒 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

@@ -1,6 +1,6 @@
 {
     "name": "@gatekeeperx/cordova-plugin-devicex",
-    "version": "1.2.5",
+    "version": "1.2.7",
     "description": "GatekeeperX Device Intelligence Cordova plugin (Android)",
     "license": "Apache-2.0",
     "keywords": [

package/plugin.xml

@@ -1,7 +1,7 @@
 <?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">
+  xmlns:android="http://schemas.android.com/apk/res/android" version="1.2.7">
   <name>Devicex</name>
   <description>GatekeeperX Device Intelligence Cordova plugin (Android)</description>
   <license>Apache-2.0</license>
@@ -31,7 +31,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" />
+    <lib-file src="src/android/libs/devicex-1.2.6.aar" arch="device" />
 
     <!-- Hook para configurar Gradle -->
     <hook type="after_plugin_install" src="src/android/hooks/configure-gradle.js" />
@@ -44,7 +44,8 @@
       </feature>
     </config-file>
 
-    <!-- Incluir la clase Java del plugin -->
+    <!-- Incluir las clases Java del plugin -->
     <source-file src="src/android/com/gatekeeperx/cordova/DevicexPlugin.java" target-dir="src/com/gatekeeperx/cordova" />
+    <source-file src="src/android/com/gatekeeperx/cordova/GatekeeperXClient.java" target-dir="src/com/gatekeeperx/cordova" />
   </platform>
 </plugin>

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

@@ -85,6 +85,9 @@ public class DevicexPlugin extends CordovaPlugin {
                     callbackContext.error(e.getMessage());
                 }
                 return true;
+            // case "evaluateRisk":
+            // evaluateRisk(args, callbackContext);
+            // return true;
             default:
                 return false;
         }
@@ -201,4 +204,36 @@ public class DevicexPlugin extends CordovaPlugin {
         }
         return list;
     }
+
+    private void evaluateRisk(JSONArray args, final CallbackContext cb) {
+        try {
+            JSONObject obj = args.optJSONObject(0);
+            if (obj == null)
+                obj = new JSONObject();
+
+            String apiUrl = obj.optString("apiUrl", "");
+            String orgId = obj.optString("organizationId", "");
+            String apiKey = obj.optString("apiKey", "");
+            JSONObject payload = obj.optJSONObject("payload");
+
+            if (apiUrl.isEmpty() || orgId.isEmpty() || payload == null) {
+                cb.error("apiUrl, organizationId and payload are required");
+                return;
+            }
+
+            GatekeeperXClient.evaluateRisk(apiUrl, orgId, apiKey, payload, new GatekeeperXClient.Callback() {
+                @Override
+                public void onSuccess(JSONObject response) {
+                    cb.success(response);
+                }
+
+                @Override
+                public void onError(String error) {
+                    cb.error(error);
+                }
+            });
+        } catch (Exception e) {
+            cb.error(e.getMessage());
+        }
+    }
 }

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

@@ -0,0 +1,110 @@
+package com.gatekeeperx.cordova;
+
+import android.os.AsyncTask;
+import android.util.Log;
+
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * Cliente HTTP para llamadas al API de GatekeeperX.
+ * Ejecuta requests en background para evitar bloquear el UI thread.
+ */
+public class GatekeeperXClient {
+
+    private static final String TAG = "GatekeeperXClient";
+    private static final int CONNECT_TIMEOUT = 30000;
+    private static final int READ_TIMEOUT = 30000;
+
+    public interface Callback {
+        void onSuccess(JSONObject response);
+
+        void onError(String error);
+    }
+
+    /**
+     * Evalúa el riesgo de un evento enviando datos al API de GatekeeperX.
+     *
+     * @param apiUrl         URL del endpoint (ej:
+     *                       https://api.gatekeeperx.com/gatekeeperx/events/v1)
+     * @param organizationId ID de la organización
+     * @param apiKey         API Key para autenticación (opcional)
+     * @param payload        JSON con los datos del evento
+     * @param callback       Callback para manejar respuesta/error
+     */
+    private static void evaluateRisk(
+            final String apiUrl,
+            final String organizationId,
+            final String apiKey,
+            final JSONObject payload,
+            final Callback callback) {
+
+        new AsyncTask<Void, Void, Object>() {
+            @Override
+            protected Object doInBackground(Void... voids) {
+                HttpURLConnection conn = null;
+                try {
+                    URL url = new URL(apiUrl);
+                    conn = (HttpURLConnection) url.openConnection();
+                    conn.setRequestMethod("POST");
+                    conn.setRequestProperty("Content-Type", "application/json");
+                    conn.setRequestProperty("X-Organization-Id", organizationId);
+                    if (apiKey != null && !apiKey.isEmpty()) {
+                        conn.setRequestProperty("X-Api-Key", apiKey);
+                    }
+                    conn.setDoOutput(true);
+                    conn.setConnectTimeout(CONNECT_TIMEOUT);
+                    conn.setReadTimeout(READ_TIMEOUT);
+
+                    OutputStream os = conn.getOutputStream();
+                    os.write(payload.toString().getBytes("UTF-8"));
+                    os.close();
+
+                    int responseCode = conn.getResponseCode();
+                    BufferedReader br;
+                    if (responseCode >= 200 && responseCode < 300) {
+                        br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
+                    } else {
+                        br = new BufferedReader(new InputStreamReader(conn.getErrorStream(), "UTF-8"));
+                    }
+
+                    StringBuilder response = new StringBuilder();
+                    String line;
+                    while ((line = br.readLine()) != null) {
+                        response.append(line);
+                    }
+                    br.close();
+
+                    Log.d(TAG, "Response code: " + responseCode);
+                    Log.d(TAG, "Response body: " + response.toString());
+
+                    if (responseCode >= 200 && responseCode < 300) {
+                        return new JSONObject(response.toString());
+                    } else {
+                        return "HTTP " + responseCode + ": " + response.toString();
+                    }
+                } catch (Exception e) {
+                    Log.e(TAG, "evaluateRisk error: " + e.getMessage(), e);
+                    return e.getMessage();
+                } finally {
+                    if (conn != null)
+                        conn.disconnect();
+                }
+            }
+
+            @Override
+            protected void onPostExecute(Object result) {
+                if (result instanceof JSONObject) {
+                    callback.onSuccess((JSONObject) result);
+                } else {
+                    callback.onError((String) result);
+                }
+            }
+        }.execute();
+    }
+}

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

@@ -43,7 +43,7 @@ repositories {
     // 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')
+    implementation files('libs/devicex-1.2.6.aar')
     
     // Dependencias del SDK Devicex
     implementation 'io.ktor:ktor-client-core:2.3.7'

package/www/devicex.js

@@ -26,3 +26,11 @@ exports.isInitialized = function () {
 exports.getVersion = function () {
   return call('getVersion', []).then(function (res) { return (res && res.value) || ''; });
 };
+
+// exports.evaluateRisk = function (options) {
+//   if (!options || !options.apiUrl || !options.organizationId || !options.payload) {
+//     return Promise.reject('apiUrl, organizationId and payload are required');
+//   }
+//   // apiKey es opcional
+//   return call('evaluateRisk', [options]);
+// };