@shenai/capacitor-sdk 3.1.1

package/android/src/main/java/ai/mxlabs/shenai_sdk/plugins/capacitor/ShenaiSdkCapacitorPlugin.java

@@ -0,0 +1,1476 @@
+package ai.mxlabs.shenai_sdk.plugins.capacitor;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import android.util.Base64;
+import android.util.Log;
+import android.Manifest;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.graphics.Color;
+import android.util.DisplayMetrics;
+import android.util.TypedValue;
+import android.widget.FrameLayout;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import java.util.Optional;
+import java.util.List;
+import java.util.ArrayList;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import ai.mxlabs.shenai_sdk.ShenAIAndroidSDK;
+import ai.mxlabs.shenai_sdk.ShenAIView;
+
+
+@CapacitorPlugin(name = "ShenaiSdkCapacitor")
+public class ShenaiSdkCapacitorPlugin extends Plugin {
+  // ────────────────────────────────────────────────────────────── state
+  private static final String TAG = "shen-capacitor";
+  private static final int CONTAINER_VIEW_ID = 15835421;
+  private ShenAIAndroidSDK sdk;
+  private ShenAIView       shenaiView;
+  private FrameLayout      containerView;
+  private boolean          isTouchForwardingActive;
+
+  // ────────────────────────────────────────────────────────────── JS API
+
+    // demo echo method
+    @PluginMethod
+    public void echo(PluginCall call) {
+        String value = call.getString("value", "");
+        Log.i(TAG, value);
+        JSObject ret = new JSObject();
+        ret.put("value", value);
+        call.resolve(ret);
+    }
+
+  /**
+   * initialize(options: { apiKey: string, userId?: string, settings?: InitializationSettings }):
+   * Promise<InitializationResult>
+   */
+  @PluginMethod
+  public void initialize(PluginCall call) {
+    String apiKey = call.getString("apiKey");
+    if (apiKey == null || apiKey.isEmpty()) {
+      call.reject("apiKey is required");
+      return;
+    }
+
+    String userId = call.getString("userId", "");
+
+    // 1 · init SDK
+    sdk = new ShenAIAndroidSDK();
+    ShenAIAndroidSDK.InitializationSettings settings = sdk.getDefaultInitializationSettings();
+
+    JSObject settingsObj = call.getObject("settings", new JSObject());
+    if (settingsObj != null) {
+      try {
+        applyInitializationSettings(settingsObj, settings);
+      } catch (JSONException e) {
+        call.reject("Failed to parse initialization settings: " + e.getMessage());
+        return;
+      }
+    }
+
+    settings.eventCallback = new ShenAIAndroidSDK.EventCallback() {
+      @Override
+      public void onEvent(ShenAIAndroidSDK.Event event) {
+        String name;
+        switch (event) {
+          case START_BUTTON_CLICKED:
+            name = "START_BUTTON_CLICKED";
+            break;
+          case STOP_BUTTON_CLICKED:
+            name = "STOP_BUTTON_CLICKED";
+            break;
+          case MEASUREMENT_FINISHED:
+            name = "MEASUREMENT_FINISHED";
+            break;
+          case USER_FLOW_FINISHED:
+            name = "USER_FLOW_FINISHED";
+            break;
+          case SCREEN_CHANGED:
+            name = "SCREEN_CHANGED";
+            break;
+          default:
+            name = "UNKNOWN";
+            break;
+        }
+        JSObject data = new JSObject();
+        data.put("EventName", name);
+        notifyListeners("ShenAIEvent", data);
+      }
+    };
+
+    getActivity().runOnUiThread(() -> {
+      try {
+        ViewGroup root = (ViewGroup) getBridge().getWebView().getParent();
+        if (containerView != null && containerView.getParent() instanceof ViewGroup) {
+          ((ViewGroup) containerView.getParent()).removeView(containerView);
+        }
+
+        containerView = new FrameLayout(getContext());
+        containerView.setId(CONTAINER_VIEW_ID);
+
+        shenaiView = new ShenAIView(getContext());
+        containerView.addView(
+          shenaiView,
+          new FrameLayout.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.MATCH_PARENT));
+
+        root.addView(
+          containerView,
+          new ViewGroup.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.MATCH_PARENT));
+
+        getBridge().getWebView().setBackgroundColor(Color.TRANSPARENT);
+        getBridge().getWebView().setAlpha(1.0f);
+        root.bringChildToFront(getBridge().getWebView());
+        setupTouchForwarding();
+        shenaiView.onResume();
+        getActivity().getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        resolveInitialization(call, apiKey, userId, settings);
+      } catch (Throwable t) {
+        call.reject(
+          "Failed to initialize ShenAI SDK: " + t.getMessage(),
+          t instanceof Exception ? (Exception) t : new RuntimeException(t)
+        );
+      }
+    });
+  }
+
+  private void setupTouchForwarding() {
+    final View webView = getBridge().getWebView();
+    webView.setClickable(true);
+    webView.setOnTouchListener((v, event) -> {
+      if (containerView == null) {
+        return false;
+      }
+
+      int[] webLoc = new int[2];
+      int[] containerLoc = new int[2];
+      webView.getLocationOnScreen(webLoc);
+      containerView.getLocationOnScreen(containerLoc);
+
+      MotionEvent forwarded = MotionEvent.obtain(event);
+      forwarded.offsetLocation(webLoc[0] - containerLoc[0], webLoc[1] - containerLoc[1]);
+
+      int action = forwarded.getActionMasked();
+      if (action == MotionEvent.ACTION_DOWN) {
+        isTouchForwardingActive = isPointInsideView(forwarded.getX(), forwarded.getY(), containerView);
+      }
+
+      if (isTouchForwardingActive) {
+        containerView.dispatchTouchEvent(forwarded);
+      }
+
+      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+        isTouchForwardingActive = false;
+      }
+
+      forwarded.recycle();
+      return false;
+    });
+  }
+
+  private boolean isPointInsideView(float x, float y, View view) {
+    return x >= 0 && y >= 0 && x < view.getWidth() && y < view.getHeight();
+  }
+
+  private void resolveInitialization(
+      PluginCall call,
+      String apiKey,
+      String userId,
+      ShenAIAndroidSDK.InitializationSettings settings
+  ) {
+    ShenAIAndroidSDK.InitializationResult result =
+      sdk.initialize(getActivity(), apiKey, userId, settings);
+    JSObject ret = new JSObject();
+    ret.put("value", result.ordinal());
+    call.resolve(ret);
+  }
+
+  /** isInitialized(): Promise<boolean> */
+  @PluginMethod
+  public void isInitialized(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.isInitialized());
+    call.resolve(ret);
+  }
+
+  /** deinitialize(): Promise<void> */
+  @PluginMethod
+  public void deinitialize(PluginCall call) {
+    final ShenAIView capturedView = shenaiView;
+    final FrameLayout capturedContainer = containerView;
+    shenaiView = null;
+    containerView = null;
+    isTouchForwardingActive = false;
+
+    getActivity().runOnUiThread(() -> {
+      try {
+        getBridge().getWebView().setOnTouchListener(null);
+        getBridge().getWebView().setAlpha(1.0f);
+
+        if (capturedView != null) {
+          try { capturedView.activityPaused(); } catch (Throwable ignored) {}
+        }
+        if (capturedContainer != null) {
+          ViewGroup root = (ViewGroup) getBridge().getWebView().getParent();
+          root.removeView(capturedContainer);
+
+          getBridge().getWebView().setBackgroundColor(Color.WHITE);
+        }
+        if (shenaiView == null) {
+          try { getActivity().getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); } catch (Throwable ignored) {}
+        }
+      } catch (Throwable ignored) {}
+    });
+    try { if (sdk != null) sdk.deinitialize(); } catch (Throwable ignored) {}
+
+    sdk = null;
+
+    call.resolve();
+  }
+
+  /**
+   * setViewRect(options: { x?: number, y?: number, width?: number, height?: number }): Promise<void>
+   */
+  @PluginMethod
+  public void setViewRect(PluginCall call) {
+    final double x = call.getDouble("x", 0.0);
+    final double y = call.getDouble("y", 0.0);
+    final double width = call.getDouble("width", 0.0);
+    final double height = call.getDouble("height", 0.0);
+
+    getActivity().runOnUiThread(() -> {
+      if (containerView == null) {
+        call.reject("View not initialized");
+        return;
+      }
+
+      DisplayMetrics metrics = getActivity().getResources().getDisplayMetrics();
+
+      int computedX = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, (float) x, metrics);
+      int computedY = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, (float) y, metrics);
+      int computedWidth = width == 0.0 ? ViewGroup.LayoutParams.MATCH_PARENT :
+        (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, (float) width, metrics);
+      int computedHeight = height == 0.0 ? ViewGroup.LayoutParams.MATCH_PARENT :
+        (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, (float) height, metrics);
+
+      ViewGroup parent = (ViewGroup) containerView.getParent();
+      ViewGroup.LayoutParams layoutParams;
+
+      if (parent instanceof CoordinatorLayout) {
+        layoutParams = new CoordinatorLayout.LayoutParams(computedWidth, computedHeight);
+        ((CoordinatorLayout.LayoutParams) layoutParams).setMargins(computedX, computedY, 0, 0);
+      } else {
+        layoutParams = new FrameLayout.LayoutParams(computedWidth, computedHeight);
+        ((FrameLayout.LayoutParams) layoutParams).setMargins(computedX, computedY, 0, 0);
+      }
+
+      containerView.setLayoutParams(layoutParams);
+
+      call.resolve();
+    });
+  }
+
+  /**
+   * setOverlaysWebview(options: { overlay: boolean }): Promise<void>
+   */
+  @PluginMethod
+  public void setOverlaysWebview(PluginCall call) {
+    final Boolean overlay = call.getBoolean("overlay", null);
+    if (overlay == null) {
+      call.reject("overlays is required");
+      return;
+    }
+
+    getActivity().runOnUiThread(() -> {
+      if (containerView == null) {
+        call.reject("View not initialized");
+        return;
+      }
+
+      ViewGroup root = (ViewGroup) getBridge().getWebView().getParent();
+      if (overlay) {
+        root.bringChildToFront(containerView);
+      } else {
+        root.bringChildToFront(getBridge().getWebView());
+      }
+
+      call.resolve();
+    });
+  }
+
+  /** setOperatingMode(options: { mode: number }): Promise<void> */
+  @PluginMethod
+  public void setOperatingMode(PluginCall call) {
+    int mode = call.getInt("operatingMode", 0);
+    if (sdk != null) {
+      sdk.setOperatingMode(ShenAIAndroidSDK.OperatingMode.values()[mode]);
+    }
+    call.resolve();
+  }
+
+  @PluginMethod
+  public void startMeasurement(PluginCall call) {
+    if (sdk != null) {
+      sdk.startMeasurement();
+    }
+    call.resolve();
+  }
+
+  @PluginMethod
+  public void stopMeasurement(PluginCall call) {
+    if (sdk != null) {
+      sdk.stopMeasurement();
+    }
+    call.resolve();
+  }
+
+  @PluginMethod
+  public void resetMeasurementSession(PluginCall call) {
+    if (sdk != null) {
+      sdk.resetMeasurementSession();
+    }
+    call.resolve();
+  }
+
+  /** getOperatingMode(): Promise<number> */
+  @PluginMethod
+  public void getOperatingMode(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ret.put("value", sdk.getOperatingMode().ordinal());
+    } else {
+      ret.put("value", 0);
+    }
+    call.resolve(ret);
+  }
+
+  /** getCalibrationState(): Promise<number> */
+  @PluginMethod
+  public void getCalibrationState(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ret.put("value", sdk.getCalibrationState().ordinal());
+    } else {
+      ret.put("value", 0);
+    }
+    call.resolve(ret);
+  }
+
+  /** setPrecisionMode(options: { mode: number }): Promise<void> */
+  @PluginMethod
+  public void setPrecisionMode(PluginCall call) {
+    int mode = call.getInt("precisionMode", 0);
+    if (sdk != null) {
+      sdk.setPrecisionMode(ShenAIAndroidSDK.PrecisionMode.values()[mode]);
+    }
+    call.resolve();
+  }
+
+  /** getPrecisionMode(): Promise<number> */
+  @PluginMethod
+  public void getPrecisionMode(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ret.put("value", sdk.getPrecisionMode().ordinal());
+    } else {
+      ret.put("value", 0);
+    }
+    call.resolve(ret);
+  }
+
+  /** setMeasurementPreset(options: { preset:number }):Promise<void> */
+  @PluginMethod
+  public void setMeasurementPreset(PluginCall call) {
+    int preset = call.getInt("measurementPreset", 0);
+    if (sdk != null) {
+      sdk.setMeasurementPreset(ShenAIAndroidSDK.MeasurementPreset.values()[preset]);
+    }
+    call.resolve();
+  }
+
+  /** getMeasurementPreset(): Promise<number> */
+  @PluginMethod
+  public void getMeasurementPreset(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ret.put("value", sdk.getMeasurementPreset().ordinal());
+    } else {
+      ret.put("value", 0);
+    }
+    call.resolve(ret);
+  }
+
+  /** setCameraMode(options: { mode:number }):Promise<void> */
+  @PluginMethod
+  public void setCameraMode(PluginCall call) {
+    int mode = call.getInt("cameraMode", 0);
+    if (sdk != null) {
+      sdk.setCameraMode(ShenAIAndroidSDK.CameraMode.values()[mode]);
+    }
+    call.resolve();
+  }
+
+  /** getCameraMode(): Promise<number> */
+  @PluginMethod
+  public void getCameraMode(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ret.put("value", sdk.getCameraMode().ordinal());
+    } else {
+      ret.put("value", 0);
+    }
+    call.resolve(ret);
+  }
+
+  /** getLastCameraError(): Promise<number | null> */
+  @PluginMethod
+  public void getLastCameraError(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      final ShenAIAndroidSDK.CameraError cameraError = sdk.getLastCameraError();
+      if (cameraError != null) {
+        ret.put("value", cameraError.ordinal());
+      } else {
+        ret.put("value", JSObject.NULL);
+      }
+    } else {
+      ret.put("value", JSObject.NULL);
+    }
+    call.resolve(ret);
+  }
+
+  /** setScreen(options: { screen:number }):Promise<void> */
+  @PluginMethod
+  public void setScreen(PluginCall call) {
+    int screen = call.getInt("screen", 0);
+    if (sdk != null) {
+      sdk.setScreen(ShenAIAndroidSDK.Screen.values()[screen]);
+    }
+    call.resolve();
+  }
+
+  /** getScreen(): Promise<number> */
+  @PluginMethod
+  public void getScreen(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ret.put("value", sdk.getScreen().ordinal());
+    } else {
+      ret.put("value", 0);
+    }
+    call.resolve(ret);
+  }
+
+  /** setShowUserInterface(options: { value:boolean }) */
+  @PluginMethod
+  public void setShowUserInterface(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setShowUserInterface(value);
+    call.resolve();
+  }
+
+  /** getShowUserInterface():Promise<boolean> */
+  @PluginMethod
+  public void getShowUserInterface(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowUserInterface());
+    call.resolve(ret);
+  }
+
+  /** setShowFacePositioningOverlay(options: { value:boolean }) */
+  @PluginMethod
+  public void setShowFacePositioningOverlay(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setShowFacePositioningOverlay(value);
+    call.resolve();
+  }
+
+  /** getShowFacePositioningOverlay():Promise<boolean> */
+  @PluginMethod
+  public void getShowFacePositioningOverlay(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowFacePositioningOverlay());
+    call.resolve(ret);
+  }
+
+  /** setShowVisualWarnings(options: { value:boolean }) */
+  @PluginMethod
+  public void setShowVisualWarnings(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setShowVisualWarnings(value);
+    call.resolve();
+  }
+
+  /** getShowVisualWarnings():Promise<boolean> */
+  @PluginMethod
+  public void getShowVisualWarnings(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowVisualWarnings());
+    call.resolve(ret);
+  }
+
+  /** setEnableCameraSwap(options: { value:boolean} ) */
+  @PluginMethod
+  public void setEnableCameraSwap(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setEnableCameraSwap(value);
+    call.resolve();
+  }
+
+  /** getEnableCameraSwap():Promise<boolean> */
+  @PluginMethod
+  public void getEnableCameraSwap(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getEnableCameraSwap());
+    call.resolve(ret);
+  }
+
+  /** setShowFaceMask(options: { value:boolean }) */
+  @PluginMethod
+  public void setShowFaceMask(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setShowFaceMask(value);
+    call.resolve();
+  }
+
+  /** getShowFaceMask():Promise<boolean> */
+  @PluginMethod
+  public void getShowFaceMask(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowFaceMask());
+    call.resolve(ret);
+  }
+
+  /** setShowBloodFlow(options: { value:boolean }) */
+  @PluginMethod
+  public void setShowBloodFlow(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setShowBloodFlow(value);
+    call.resolve();
+  }
+
+  /** getShowBloodFlow():Promise<boolean> */
+  @PluginMethod
+  public void getShowBloodFlow(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowBloodFlow());
+    call.resolve(ret);
+  }
+
+  /** setIncludeTimestampInPdf(options: { value:boolean }) */
+  @PluginMethod
+  public void setIncludeTimestampInPdf(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setIncludeTimestampInPdf(value);
+    call.resolve();
+  }
+
+  /** getIncludeTimestampInPdf():Promise<boolean> */
+  @PluginMethod
+  public void getIncludeTimestampInPdf(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getIncludeTimestampInPdf());
+    call.resolve(ret);
+  }
+
+  /** setPdfEmailSubject(options: { subject:string }) */
+  @PluginMethod
+  public void setPdfEmailSubject(PluginCall call) {
+    String subject = call.getString("subject", "");
+    if (sdk != null) sdk.setPdfEmailSubject(subject);
+    call.resolve();
+  }
+
+  /** setPdfEmailBody(options: { body:string }) */
+  @PluginMethod
+  public void setPdfEmailBody(PluginCall call) {
+    String body = call.getString("body", "");
+    if (sdk != null) sdk.setPdfEmailBody(body);
+    call.resolve();
+  }
+
+  /** setShowStartStopButton(options: { value:boolean }) */
+  @PluginMethod
+  public void setShowStartStopButton(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setShowStartStopButton(value);
+    call.resolve();
+  }
+
+  /** getShowStartStopButton():Promise<boolean> */
+  @PluginMethod
+  public void getShowStartStopButton(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowStartStopButton());
+    call.resolve(ret);
+  }
+
+  /** setEnableMeasurementsDashboard(options: { value:boolean }) */
+  @PluginMethod
+  public void setEnableMeasurementsDashboard(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setEnableMeasurementsDashboard(value);
+    call.resolve();
+  }
+
+  /** getEnableMeasurementsDashboard():Promise<boolean> */
+  @PluginMethod
+  public void getEnableMeasurementsDashboard(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getEnableMeasurementsDashboard());
+    call.resolve(ret);
+  }
+
+  /** setShowInfoButton(options: { value:boolean }) */
+  @PluginMethod
+  public void setShowInfoButton(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setShowInfoButton(value);
+    call.resolve();
+  }
+
+  /** getShowInfoButton():Promise<boolean> */
+  @PluginMethod
+  public void getShowInfoButton(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowInfoButton());
+    call.resolve(ret);
+  }
+
+  /** getShowDisclaimer():Promise<boolean> */
+  @PluginMethod
+  public void getShowDisclaimer(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getShowDisclaimer());
+    call.resolve(ret);
+  }
+
+  /** setEnableStartAfterSuccess(options: { value:boolean }) */
+  @PluginMethod
+  public void setEnableStartAfterSuccess(PluginCall call) {
+    boolean value = call.getBoolean("value", true);
+    if (sdk != null) sdk.setEnableStartAfterSuccess(value);
+    call.resolve();
+  }
+
+  /** getEnableStartAfterSuccess():Promise<boolean> */
+  @PluginMethod
+  public void getEnableStartAfterSuccess(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getEnableStartAfterSuccess());
+    call.resolve(ret);
+  }
+
+  /** getFaceState():Promise<number> */
+  @PluginMethod
+  public void getFaceState(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ret.put("value", sdk.getFaceState().ordinal());
+    } else {
+      ret.put("value", 0);
+    }
+    call.resolve(ret);
+  }
+
+  /** getNormalizedFaceBbox():Promise<object|null> */
+  @PluginMethod
+  public void getNormalizedFaceBbox(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ShenAIAndroidSDK.NormalizedFaceBbox b = sdk.getNormalizedFaceBbox();
+      if (b != null) {
+        JSObject box = new JSObject();
+        box.put("x", b.x);
+        box.put("y", b.y);
+        box.put("width", b.width);
+        box.put("height", b.height);
+        ret.put("value", box);
+        call.resolve(ret);
+        return;
+      }
+    }
+    call.resolve();
+  }
+
+  /** getMeasurementState():Promise<number> */
+  @PluginMethod
+  public void getMeasurementState(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) ret.put("value", sdk.getMeasurementState().ordinal());
+    else ret.put("value", 0);
+    call.resolve(ret);
+  }
+
+  @PluginMethod
+  public void getCurrentViolatedMeasurementEnvironmentCondition(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      ShenAIAndroidSDK.MeasurementEnvironmentCondition value =
+        sdk.getCurrentViolatedMeasurementEnvironmentCondition();
+      ret.put("value", value == null ? JSObject.NULL : value.ordinal());
+    } else {
+      ret.put("value", JSObject.NULL);
+    }
+    call.resolve(ret);
+  }
+
+  /** isReadyToStartMeasurement():Promise<boolean> */
+  @PluginMethod
+  public void isReadyToStartMeasurement(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.isReadyToStartMeasurement());
+    call.resolve(ret);
+  }
+
+  /** areRequiredModelsDownloaded():Promise<boolean> */
+  @PluginMethod
+  public void areRequiredModelsDownloaded(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.areRequiredModelsDownloaded());
+    call.resolve(ret);
+  }
+
+  /** getMeasurementProgressPercentage():Promise<number> */
+  @PluginMethod
+  public void getMeasurementProgressPercentage(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) ret.put("value", sdk.getMeasurementProgressPercentage());
+    else ret.put("value", 0);
+    call.resolve(ret);
+  }
+
+  /** getHeartRate10s():Promise<number|null> */
+  @PluginMethod
+  public void getHeartRate10s(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk == null) {
+      ret.put("value", JSObject.NULL);
+    } else {
+      int v = sdk.getHeartRate10s();
+      if (v < 0) ret.put("value", JSObject.NULL); else ret.put("value", v);
+    }
+    call.resolve(ret);
+  }
+
+  /** getHeartRate4s():Promise<number|null> */
+  @PluginMethod
+  public void getHeartRate4s(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk == null) {
+      ret.put("value", JSObject.NULL);
+    } else {
+      int v = sdk.getHeartRate4s();
+      if (v < 0) ret.put("value", JSObject.NULL); else ret.put("value", v);
+    }
+    call.resolve(ret);
+  }
+
+  /** getMeasurementResults():Promise<object|null> */
+  @PluginMethod
+  public void getMeasurementResults(PluginCall call) {
+    if (sdk == null) {
+      JSObject wrapper = new JSObject();
+      wrapper.put("value", JSObject.NULL);
+      call.resolve(wrapper);
+      return;
+    }
+    ShenAIAndroidSDK.MeasurementResults r = sdk.getMeasurementResults();
+    if (r == null) {
+      JSObject wrapper = new JSObject();
+      wrapper.put("value", JSObject.NULL);
+      call.resolve(wrapper);
+      return;
+    }
+    JSObject ret = measurementResultsToJSObject(r);
+    JSObject wrapper = new JSObject();
+    wrapper.put("value", ret);
+    call.resolve(wrapper);
+  }
+
+  /** getMeasurementResultsHistory():Promise<object|null> */
+  @PluginMethod
+  public void getMeasurementResultsHistory(PluginCall call) {
+    if (sdk == null) { call.resolve(); return; }
+    ShenAIAndroidSDK.MeasurementResultsHistory hist = sdk.getMeasurementResultsHistory();
+    if (hist == null) { call.resolve(); return; }
+    JSONArray arr = new JSONArray();
+    if (hist.history != null) {
+      for (ShenAIAndroidSDK.MeasurementResultsWithMetadata md : hist.history) {
+        JSObject obj = measurementResultsWithMetadataToJSObject(md);
+        arr.put(obj);
+      }
+    }
+    JSObject ret = new JSObject();
+    ret.put("value", arr);
+    call.resolve(ret);
+  }
+
+  /** getRealtimeMetrics(periodSec:number):Promise<object|null> */
+  @PluginMethod
+  public void getRealtimeMetrics(PluginCall call) {
+    if (sdk == null) { call.resolve(); return; }
+    Double periodOpt = call.getDouble("periodSec", 1.0);
+    float period = periodOpt != null ? periodOpt.floatValue() : 1.0f;
+    ShenAIAndroidSDK.MeasurementResults r = sdk.getRealtimeMetrics(period);
+    if (r == null) { call.resolve(); return; }
+    JSObject ret = new JSObject();
+    ret.put("value", measurementResultsToJSObject(r));
+    call.resolve(ret);
+  }
+
+  /** getRealtimeHeartbeats(periodSec?:number):Promise<object[]> */
+  @PluginMethod
+  public void getRealtimeHeartbeats(PluginCall call) {
+    if (sdk == null) { call.resolve(); return; }
+    Double p = call.getDouble("periodSec");
+    ShenAIAndroidSDK.Heartbeat[] hb = sdk.getRealtimeHeartbeats(p == null ? null : p.floatValue());
+    JSONArray arr = heartbeatsToJSONArray(hb);
+    JSObject ret = new JSObject();
+    ret.put("value", arr);
+    call.resolve(ret);
+  }
+
+  /** getFullPpgSignal(): Promise<{ value: number[] }> */
+@PluginMethod
+public void getFullPpgSignal(PluginCall call) {
+  JSObject ret = new JSObject();
+  if (sdk != null) {
+    double[] signal = sdk.getFullPpgSignal();
+    JSONArray arr   = new JSONArray();
+    for (double v : signal) {
+      arr.put(Double.valueOf(v));
+    }
+
+    ret.put("value", arr);
+  }
+  call.resolve(ret);
+}
+  /** setRecordingEnabled(options: { enabled:boolean }): Promise<void> */
+  @PluginMethod
+  public void setRecordingEnabled(PluginCall call) {
+    boolean enabled = call.getBoolean("value", false);
+    if (sdk != null) sdk.setRecordingEnabled(enabled);
+    call.resolve();
+  }
+
+  /** getRecordingEnabled(): Promise<{ value: boolean }> */
+  @PluginMethod
+  public void getRecordingEnabled(PluginCall call) {
+    JSObject ret = new JSObject();
+    ret.put("value", sdk != null && sdk.getRecordingEnabled());
+    call.resolve(ret);
+  }
+
+  /** getTotalBadSignalSeconds(): Promise<{ value: number }> */
+  @PluginMethod
+  public void getTotalBadSignalSeconds(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) ret.put("value", sdk.getTotalBadSignalSeconds());
+    else ret.put("value", 0);
+    call.resolve(ret);
+  }
+
+  /** getCurrentSignalQualityMetric(): Promise<{ value: number }> */
+  @PluginMethod
+  public void getCurrentSignalQualityMetric(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) ret.put("value", sdk.getCurrentSignalQualityMetric());
+    else ret.put("value", 0);
+    call.resolve(ret);
+  }
+
+  /** setCustomMeasurementConfig(options: { config:object }): Promise<void> */
+  @PluginMethod
+  public void setCustomMeasurementConfig(PluginCall call) {
+    JSObject cfg = call.getObject("config", new JSObject());
+    if (sdk != null && cfg != null) {
+      ShenAIAndroidSDK.CustomMeasurementConfig c = sdk.new CustomMeasurementConfig();
+      if (cfg.has("durationSeconds"))
+        c.durationSeconds = Optional.of((float) cfg.optDouble("durationSeconds"));
+      if (cfg.has("infiniteMeasurement"))
+        c.infiniteMeasurement = Optional.of(cfg.optBoolean("infiniteMeasurement"));
+      if (cfg.has("instantMetrics")) {
+        JSONArray arr = cfg.optJSONArray("instantMetrics");
+        if (arr != null) {
+          List<ShenAIAndroidSDK.Metric> list = new ArrayList<>();
+          for (int i = 0; i < arr.length(); ++i) list.add(ShenAIAndroidSDK.Metric.values()[arr.optInt(i)]);
+          c.instantMetrics = Optional.of(list);
+        }
+      }
+      if (cfg.has("summaryMetrics")) {
+        JSONArray arr = cfg.optJSONArray("summaryMetrics");
+        if (arr != null) {
+          List<ShenAIAndroidSDK.Metric> list = new ArrayList<>();
+          for (int i = 0; i < arr.length(); ++i) list.add(ShenAIAndroidSDK.Metric.values()[arr.optInt(i)]);
+          c.summaryMetrics = Optional.of(list);
+        }
+      }
+      if (cfg.has("healthIndices")) {
+        JSONArray arr = cfg.optJSONArray("healthIndices");
+        if (arr != null) {
+          List<ShenAIAndroidSDK.HealthIndex> list = new ArrayList<>();
+          for (int i = 0; i < arr.length(); ++i) list.add(ShenAIAndroidSDK.HealthIndex.values()[arr.optInt(i)]);
+          c.healthIndices = Optional.of(list);
+        }
+      }
+      if (cfg.has("realtimeHrPeriodSeconds"))
+        c.realtimeHrPeriodSeconds = Optional.of((float) cfg.optDouble("realtimeHrPeriodSeconds"));
+      if (cfg.has("realtimeHrvPeriodSeconds"))
+        c.realtimeHrvPeriodSeconds = Optional.of((float) cfg.optDouble("realtimeHrvPeriodSeconds"));
+      if (cfg.has("realtimeCardiacStressPeriodSeconds"))
+        c.realtimeCardiacStressPeriodSeconds = Optional.of((float) cfg.optDouble("realtimeCardiacStressPeriodSeconds"));
+      sdk.setCustomMeasurementConfig(c);
+    }
+    call.resolve();
+  }
+
+  /** setCustomColorTheme(options: { theme:object }): Promise<void> */
+  @PluginMethod
+  public void setCustomColorTheme(PluginCall call) {
+    JSObject obj = call.getObject("theme", new JSObject());
+    if (sdk != null && obj != null) {
+      ShenAIAndroidSDK.CustomColorTheme t = sdk.new CustomColorTheme();
+      if (obj.has("themeColor")) t.themeColor = obj.getString("themeColor");
+      if (obj.has("textColor")) t.textColor = obj.getString("textColor");
+      if (obj.has("backgroundColor")) t.backgroundColor = obj.getString("backgroundColor");
+      if (obj.has("tileColor")) t.tileColor = obj.getString("tileColor");
+      if (obj.has("buttonMainColor")) t.buttonMainColor = obj.getString("buttonMainColor");
+      if (obj.has("buttonSecondaryColor")) t.buttonSecondaryColor = obj.getString("buttonSecondaryColor");
+      sdk.setCustomColorTheme(t);
+    }
+    call.resolve();
+  }
+
+  /** setLanguage(options: { lang:string }) */
+  @PluginMethod
+  public void setLanguage(PluginCall call) {
+    String lang = call.getString("language");
+    if (sdk != null && lang != null) {
+      sdk.setLanguage(lang);
+    }
+    call.resolve();
+  }
+
+  /** getHealthRisks():Promise<object> */
+  @PluginMethod
+  public void getHealthRisks(PluginCall call) {
+    if (sdk == null) { call.reject("not initialized"); return; }
+    ShenAIAndroidSDK.HealthRisks risks = sdk.getHealthRisks();
+    JSObject ret = new JSObject();
+    ret.put("value", healthRisksToJSObject(risks));
+    call.resolve(ret);
+  }
+
+  /** getHealthRisksFactors():Promise<object> */
+  @PluginMethod
+  public void getHealthRisksFactors(PluginCall call) {
+    if (sdk == null) { call.reject("not initialized"); return; }
+    ShenAIAndroidSDK.RisksFactors factors = sdk.getHealthRisksFactors();
+    JSObject ret = new JSObject();
+    ret.put("value", risksFactorsToJSObject(factors));
+    call.resolve(ret);
+  }
+
+  /** getMaximalRisks(options: { risksFactors: object }):Promise<object> */
+  @PluginMethod
+  public void getMaximalRisks(PluginCall call) {
+    if (sdk == null) { call.reject("not initialized"); return; }
+    JSObject obj = call.getObject("risksFactors", new JSObject());
+    try {
+      ShenAIAndroidSDK.RisksFactors factors = jsObjectToRisksFactors(obj);
+      ShenAIAndroidSDK.HealthRisks risks = sdk.getMaximalHealthRisks(factors);
+      JSObject ret = new JSObject();
+      ret.put("value", healthRisksToJSObject(risks));
+      call.resolve(ret);
+    } catch (JSONException e) {
+      call.reject("Failed to parse risks factors: " + e.getMessage());
+    }
+  }
+
+  /** getMinimalRisks(options: { risksFactors: object }):Promise<object> */
+  @PluginMethod
+  public void getMinimalRisks(PluginCall call) {
+    if (sdk == null) { call.reject("not initialized"); return; }
+    JSObject obj = call.getObject("risksFactors", new JSObject());
+    try {
+      ShenAIAndroidSDK.RisksFactors factors = jsObjectToRisksFactors(obj);
+      ShenAIAndroidSDK.HealthRisks risks = sdk.getMinimalHealthRisks(factors);
+      JSObject ret = new JSObject();
+      ret.put("value", healthRisksToJSObject(risks));
+      call.resolve(ret);
+    } catch (JSONException e) {
+      call.reject("Failed to parse risks factors: " + e.getMessage());
+    }
+  }
+
+  /** getReferenceRisks(options: { risksFactors: object }):Promise<object> */
+  @PluginMethod
+  public void getReferenceRisks(PluginCall call) {
+    if (sdk == null) { call.reject("not initialized"); return; }
+    JSObject obj = call.getObject("risksFactors", new JSObject());
+    try {
+      ShenAIAndroidSDK.RisksFactors factors = jsObjectToRisksFactors(obj);
+      ShenAIAndroidSDK.HealthRisks risks = sdk.getReferenceHealthRisks(factors);
+      JSObject ret = new JSObject();
+      ret.put("value", healthRisksToJSObject(risks));
+      call.resolve(ret);
+    } catch (JSONException e) {
+      call.reject("Failed to parse risks factors: " + e.getMessage());
+    }
+  }
+
+  /** computeHealthRisks(options: { risksFactors: object }):Promise<object> */
+  @PluginMethod
+  public void computeHealthRisks(PluginCall call) {
+    if (sdk == null) { call.reject("not initialized"); return; }
+    JSObject obj = call.getObject("risksFactors", new JSObject());
+    try {
+      ShenAIAndroidSDK.RisksFactors factors = jsObjectToRisksFactors(obj);
+      ShenAIAndroidSDK.HealthRisks risks = sdk.computeHealthRisks(factors);
+      JSObject ret = new JSObject();
+      ret.put("value", healthRisksToJSObject(risks));
+      call.resolve(ret);
+    } catch (JSONException e) {
+      call.reject("Failed to parse risks factors: " + e.getMessage());
+    }
+  }
+
+  /** getSignalQualityMapPng(): Promise<{ value: number[] }> */
+  @PluginMethod
+  public void getSignalQualityMapPng(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      byte[] data = sdk.getSignalQualityMapPng();
+      JSONArray arr = new JSONArray();
+      for (byte b : data) arr.put(b & 0xFF);
+      ret.put("value", arr);
+    }
+    call.resolve(ret);
+  }
+
+  /** getFaceTexturePng(): Promise<{ value: number[] }> */
+  @PluginMethod
+  public void getFaceTexturePng(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      byte[] data = sdk.getFaceTexturePng();
+      JSONArray arr = new JSONArray();
+      for (byte b : data) arr.put(b & 0xFF);
+      ret.put("value", arr);
+    }
+    call.resolve(ret);
+  }
+
+  /** openMeasurementResultsPdfInBrowser(): Promise<void> */
+  @PluginMethod
+  public void openMeasurementResultsPdfInBrowser(PluginCall call) {
+    if (sdk != null) sdk.openMeasurementResultsPdfInBrowser();
+    call.resolve();
+  }
+
+  /** sendMeasurementResultsPdfToEmail(options: { email:string }): Promise<void> */
+  @PluginMethod
+  public void sendMeasurementResultsPdfToEmail(PluginCall call) {
+    String email = call.getString("email");
+    if (sdk != null && email != null) sdk.sendMeasurementResultsPdfToEmail(email);
+    call.resolve();
+  }
+
+  /** requestMeasurementResultsPdfUrl(): Promise<void> */
+  @PluginMethod
+  public void requestMeasurementResultsPdfUrl(PluginCall call) {
+    if (sdk != null) sdk.requestMeasurementResultsPdfUrl();
+    call.resolve();
+  }
+
+  /** getMeasurementResultsPdfUrl(): Promise<{ value: string | null }> */
+  @PluginMethod
+  public void getMeasurementResultsPdfUrl(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      String url = sdk.getMeasurementResultsPdfUrl();
+      if (url == null || url.isEmpty()) ret.put("value", JSObject.NULL); else ret.put("value", url);
+    } else {
+      ret.put("value", JSObject.NULL);
+    }
+    call.resolve(ret);
+  }
+
+  /** requestMeasurementResultsPdfBytes(): Promise<void> */
+  @PluginMethod
+  public void requestMeasurementResultsPdfBytes(PluginCall call) {
+    if (sdk != null) sdk.requestMeasurementResultsPdfBytes();
+    call.resolve();
+  }
+
+  /** getMeasurementResultsPdfBytes(): Promise<{ value: number[] | null }> */
+  @PluginMethod
+  public void getMeasurementResultsPdfBytes(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      byte[] bytes = sdk.getMeasurementResultsPdfBytes();
+      if (bytes == null) {
+        ret.put("value", JSObject.NULL);
+      } else {
+        ret.put("valueBase64", Base64.encodeToString(bytes, Base64.NO_WRAP));
+      }
+    }
+    call.resolve(ret);
+  }
+
+  /** getResultAsFhirObservation(): Promise<{ value: string | null }> */
+  @PluginMethod
+  public void getResultAsFhirObservation(PluginCall call) {
+    JSObject ret = new JSObject();
+    if (sdk != null) {
+      String observation = sdk.getResultAsFhirObservation();
+      ret.put("value", (observation == null || observation.isEmpty()) ? JSObject.NULL : observation);
+    } else {
+      ret.put("value", JSObject.NULL);
+    }
+    call.resolve(ret);
+  }
+
+  /** sendResultFhirObservation({ url }): Promise<{ value: string | null }> */
+  @PluginMethod
+  public void sendResultFhirObservation(PluginCall call) {
+    String url = call.getString("url");
+    if (sdk == null) {
+      call.reject("SDK is not initialized");
+      return;
+    }
+    if (url == null || url.isEmpty()) {
+      call.reject("url is required");
+      return;
+    }
+
+    Handler mainHandler = new Handler(Looper.getMainLooper());
+    sdk.sendResultFhirObservation(url, response -> {
+      JSObject ret = new JSObject();
+      String normalized = (response == null || response.isEmpty()) ? null : response;
+      ret.put("value", normalized == null ? JSObject.NULL : normalized);
+      mainHandler.post(() -> call.resolve(ret));
+    });
+  }
+
+  // ──────────────────────────────────────────────────────────── helpers
+  private void applyInitializationSettings(JSObject obj,
+                                           ShenAIAndroidSDK.InitializationSettings settings) throws JSONException {
+    if (obj == null) return;
+
+    if (obj.has("precisionMode"))
+      settings.precisionMode = ShenAIAndroidSDK.PrecisionMode.values()[obj.getInt("precisionMode")];
+    if (obj.has("operatingMode"))
+      settings.operatingMode = ShenAIAndroidSDK.OperatingMode.values()[obj.getInt("operatingMode")];
+    if (obj.has("measurementPreset"))
+      settings.measurementPreset = ShenAIAndroidSDK.MeasurementPreset.values()[obj.getInt("measurementPreset")];
+    if (obj.has("cameraMode"))
+      settings.cameraMode = ShenAIAndroidSDK.CameraMode.values()[obj.getInt("cameraMode")];
+    if (obj.has("onboardingMode"))
+      settings.onboardingMode = ShenAIAndroidSDK.OnboardingMode.values()[obj.getInt("onboardingMode")];
+    if (obj.has("initializationMode"))
+      settings.initializationMode = ShenAIAndroidSDK.InitializationMode.values()[obj.getInt("initializationMode")];
+
+    if (obj.has("showUserInterface"))
+      settings.showUserInterface = obj.getBoolean("showUserInterface");
+    if (obj.has("showFacePositioningOverlay"))
+      settings.showFacePositioningOverlay = obj.getBoolean("showFacePositioningOverlay");
+    if (obj.has("showVisualWarnings"))
+      settings.showVisualWarnings = obj.getBoolean("showVisualWarnings");
+    if (obj.has("enableCameraSwap"))
+      settings.enableCameraSwap = obj.getBoolean("enableCameraSwap");
+    if (obj.has("showFaceMask"))
+      settings.showFaceMask = obj.getBoolean("showFaceMask");
+    if (obj.has("showBloodFlow"))
+      settings.showBloodFlow = obj.getBoolean("showBloodFlow");
+    if (obj.has("hideShenaiLogo"))
+      settings.hideShenaiLogo = obj.getBoolean("hideShenaiLogo");
+    if (obj.has("includeTimestampInPdf"))
+      settings.includeTimestampInPdf = obj.getBoolean("includeTimestampInPdf");
+    if (obj.has("pdfEmailSubject"))
+      settings.pdfEmailSubject = obj.getString("pdfEmailSubject");
+    if (obj.has("pdfEmailBody"))
+      settings.pdfEmailBody = obj.getString("pdfEmailBody");
+    if (obj.has("enableStartAfterSuccess"))
+      settings.enableStartAfterSuccess = obj.getBoolean("enableStartAfterSuccess");
+    if (obj.has("enableSummaryScreen"))
+      settings.enableSummaryScreen = obj.getBoolean("enableSummaryScreen");
+    if (obj.has("showResultsFinishButton"))
+      settings.showResultsFinishButton = obj.getBoolean("showResultsFinishButton");
+    if (obj.has("enableHealthRisks"))
+      settings.enableHealthRisks = obj.getBoolean("enableHealthRisks");
+    if (obj.has("showHealthIndicesFinishButton"))
+      settings.showHealthIndicesFinishButton = obj.getBoolean("showHealthIndicesFinishButton");
+    if (obj.has("saveHealthRisksFactors"))
+      settings.saveHealthRisksFactors = obj.getBoolean("saveHealthRisksFactors");
+    if (obj.has("showOutOfRangeResultIndicators"))
+      settings.showOutOfRangeResultIndicators = obj.getBoolean("showOutOfRangeResultIndicators");
+    if (obj.has("showTrialMetricLabels"))
+      settings.showTrialMetricLabels = obj.getBoolean("showTrialMetricLabels");
+    if (obj.has("showSignalQualityIndicator"))
+      settings.showSignalQualityIndicator = obj.getBoolean("showSignalQualityIndicator");
+    if (obj.has("showSignalTile"))
+      settings.showSignalTile = obj.getBoolean("showSignalTile");
+    if (obj.has("showStartStopButton"))
+      settings.showStartStopButton = obj.getBoolean("showStartStopButton");
+    if (obj.has("showInfoButton"))
+      settings.showInfoButton = obj.getBoolean("showInfoButton");
+    if (obj.has("showDisclaimer"))
+      settings.showDisclaimer = obj.getBoolean("showDisclaimer");
+    if (obj.has("enableMeasurementsDashboard"))
+      settings.enableMeasurementsDashboard = obj.getBoolean("enableMeasurementsDashboard");
+    if (obj.has("uiVersion"))
+      settings.uiVersion = ShenAIAndroidSDK.UiVersion.values()[obj.getInt("uiVersion")];
+    if (obj.has("frameWidth"))
+      settings.frameWidth = obj.getInt("frameWidth");
+    if (obj.has("frameHeight"))
+      settings.frameHeight = obj.getInt("frameHeight");
+    if (obj.has("rotation"))
+      settings.rotation = obj.getInt("rotation");
+    if (obj.has("offlineProcessing"))
+      settings.offlineProcessing = obj.getBoolean("offlineProcessing");
+    if (obj.has("uiFlowScreens")) {
+      JSONArray array = obj.getJSONArray("uiFlowScreens");
+      settings.uiFlowScreens.clear();
+      for (int i = 0; i < array.length(); ++i) {
+        settings.uiFlowScreens.add(ShenAIAndroidSDK.Screen.values()[array.getInt(i)]);
+      }
+    }
+
+    if (obj.has("risksFactors")) {
+      JSObject factorsObj = obj.getJSObject("risksFactors");
+      settings.risksFactors = jsObjectToRisksFactors(factorsObj);
+    }
+  }
+
+  private ShenAIAndroidSDK.RisksFactors jsObjectToRisksFactors(JSObject obj) throws JSONException {
+    ShenAIAndroidSDK.RisksFactors factors = sdk.new RisksFactors();
+    if (obj == null) return factors;
+
+    if (obj.has("age")) factors.age = Optional.of(obj.getInt("age"));
+    if (obj.has("cholesterol")) factors.cholesterol = Optional.of((float)obj.getDouble("cholesterol"));
+    if (obj.has("cholesterolHdl")) factors.cholesterolHdl = Optional.of((float)obj.getDouble("cholesterolHdl"));
+    if (obj.has("sbp")) factors.sbp = Optional.of((float)obj.getDouble("sbp"));
+    if (obj.has("dbp")) factors.dbp = Optional.of((float)obj.getDouble("dbp"));
+    if (obj.has("isSmoker")) factors.isSmoker = Optional.of(obj.getBoolean("isSmoker"));
+    if (obj.has("hypertensionTreatment")) {
+      int index = obj.getInt("hypertensionTreatment");
+      factors.hypertensionTreatment = Optional.of(ShenAIAndroidSDK.HypertensionTreatment.values()[index]);
+    }
+    if (obj.has("hasDiabetes")) factors.hasDiabetes = Optional.of(obj.getBoolean("hasDiabetes"));
+    if (obj.has("bodyHeight")) factors.bodyHeight = Optional.of((float)obj.getDouble("bodyHeight"));
+    if (obj.has("bodyWeight")) factors.bodyWeight = Optional.of((float)obj.getDouble("bodyWeight"));
+    if (obj.has("waistCircumference")) factors.waistCircumference = Optional.of((float)obj.getDouble("waistCircumference"));
+    if (obj.has("neckCircumference")) factors.neckCircumference = Optional.of((float)obj.getDouble("neckCircumference"));
+    if (obj.has("hipCircumference")) factors.hipCircumference = Optional.of((float)obj.getDouble("hipCircumference"));
+    if (obj.has("gender")) {
+      int index = obj.getInt("gender");
+      factors.gender = Optional.of(ShenAIAndroidSDK.Gender.values()[index]);
+    }
+    if (obj.has("physicalActivity")) {
+      int index = obj.getInt("physicalActivity");
+      factors.physicalActivity = Optional.of(ShenAIAndroidSDK.PhysicalActivity.values()[index]);
+    }
+    if (obj.has("country")) factors.country = obj.getString("country");
+    if (obj.has("race")) {
+      int index = obj.getInt("race");
+      factors.race = Optional.of(ShenAIAndroidSDK.Race.values()[index]);
+    }
+    if (obj.has("vegetableFruitDiet")) factors.vegetableFruitDiet = Optional.of(obj.getBoolean("vegetableFruitDiet"));
+    if (obj.has("historyOfHypertension")) factors.historyOfHypertension = Optional.of(obj.getBoolean("historyOfHypertension"));
+    if (obj.has("historyOfHighGlucose")) factors.historyOfHighGlucose = Optional.of(obj.getBoolean("historyOfHighGlucose"));
+    if (obj.has("fastingGlucose")) factors.fastingGlucose = Optional.of((float)obj.getDouble("fastingGlucose"));
+    if (obj.has("triglyceride")) factors.triglyceride = Optional.of((float)obj.getDouble("triglyceride"));
+    if (obj.has("parentalHypertension")) {
+      int index = obj.getInt("parentalHypertension");
+      factors.parentalHypertension = Optional.of(ShenAIAndroidSDK.ParentalHistory.values()[index]);
+    }
+    if (obj.has("familyDiabetes")) {
+      int index = obj.getInt("familyDiabetes");
+      factors.familyDiabetes = Optional.of(ShenAIAndroidSDK.FamilyHistory.values()[index]);
+    }
+
+    return factors;
+  }
+
+  private JSObject risksFactorsToJSObject(ShenAIAndroidSDK.RisksFactors factors) {
+    JSObject obj = new JSObject();
+    factors.age.ifPresent(v -> obj.put("age", v));
+    factors.cholesterol.ifPresent(v -> obj.put("cholesterol", v));
+    factors.cholesterolHdl.ifPresent(v -> obj.put("cholesterolHdl", v));
+    factors.sbp.ifPresent(v -> obj.put("sbp", v));
+    factors.dbp.ifPresent(v -> obj.put("dbp", v));
+    factors.isSmoker.ifPresent(v -> obj.put("isSmoker", v));
+    factors.hypertensionTreatment.ifPresent(v -> obj.put("hypertensionTreatment", v.ordinal()));
+    factors.hasDiabetes.ifPresent(v -> obj.put("hasDiabetes", v));
+    factors.bodyHeight.ifPresent(v -> obj.put("bodyHeight", v));
+    factors.bodyWeight.ifPresent(v -> obj.put("bodyWeight", v));
+    factors.waistCircumference.ifPresent(v -> obj.put("waistCircumference", v));
+    factors.neckCircumference.ifPresent(v -> obj.put("neckCircumference", v));
+    factors.hipCircumference.ifPresent(v -> obj.put("hipCircumference", v));
+    factors.gender.ifPresent(v -> obj.put("gender", v.ordinal()));
+    factors.physicalActivity.ifPresent(v -> obj.put("physicalActivity", v.ordinal()));
+    if (factors.country != null) obj.put("country", factors.country);
+    factors.race.ifPresent(v -> obj.put("race", v.ordinal()));
+    factors.vegetableFruitDiet.ifPresent(v -> obj.put("vegetableFruitDiet", v));
+    factors.historyOfHypertension.ifPresent(v -> obj.put("historyOfHypertension", v));
+    factors.historyOfHighGlucose.ifPresent(v -> obj.put("historyOfHighGlucose", v));
+    factors.fastingGlucose.ifPresent(v -> obj.put("fastingGlucose", v));
+    factors.triglyceride.ifPresent(v -> obj.put("triglyceride", v));
+    factors.familyDiabetes.ifPresent(v -> obj.put("familyDiabetes", v.ordinal()));
+    factors.parentalHypertension.ifPresent(v -> obj.put("parentalHypertension", v.ordinal()));
+    return obj;
+  }
+
+  private JSObject healthRisksToJSObject(ShenAIAndroidSDK.HealthRisks risks) {
+    JSObject ret = new JSObject();
+    JSObject hard = new JSObject();
+    hard.put("coronaryDeathEventRisk", risks.hardAndFatalEvents.coronaryDeathEventRisk.orElse(null));
+    hard.put("fatalStrokeEventRisk", risks.hardAndFatalEvents.fatalStrokeEventRisk.orElse(null));
+    hard.put("totalCvMortalityRisk", risks.hardAndFatalEvents.totalCVMortalityRisk.orElse(null));
+    hard.put("hardCvEventRisk", risks.hardAndFatalEvents.hardCVEventRisk.orElse(null));
+    ret.put("hardAndFatalEvents", hard);
+
+    JSObject cv = new JSObject();
+    cv.put("overallRisk", risks.cvDiseases.overallRisk.orElse(null));
+    cv.put("coronaryHeartDiseaseRisk", risks.cvDiseases.coronaryHeartDiseaseRisk.orElse(null));
+    cv.put("strokeRisk", risks.cvDiseases.strokeRisk.orElse(null));
+    cv.put("heartFailureRisk", risks.cvDiseases.heartFailureRisk.orElse(null));
+    cv.put("peripheralVascularDiseaseRisk", risks.cvDiseases.peripheralVascularDiseaseRisk.orElse(null));
+    ret.put("cvDiseases", cv);
+
+    JSObject scores = new JSObject();
+    scores.put("ageScore", risks.scores.ageScore.orElse(null));
+    scores.put("sbpScore", risks.scores.sbpScore.orElse(null));
+    scores.put("smokingScore", risks.scores.smokingScore.orElse(null));
+    scores.put("diabetesScore", risks.scores.diabetesScore.orElse(null));
+    scores.put("bmiScore", risks.scores.bmiScore.orElse(null));
+    scores.put("cholesterolScore", risks.scores.cholesterolScore.orElse(null));
+    scores.put("cholesterolHdlScore", risks.scores.cholesterolHdlScore.orElse(null));
+    scores.put("totalScore", risks.scores.totalScore.orElse(null));
+    ret.put("scores", scores);
+
+    ret.put("wellnessScore", risks.wellnessScore.orElse(null));
+    ret.put("vascularAge", risks.vascularAge.orElse(null));
+    ret.put("waistToHeightRatio", risks.waistToHeightRatio.orElse(null));
+    ret.put("bodyFatPercentage", risks.bodyFatPercentage.orElse(null));
+    ret.put("basalMetabolicRate", risks.basalMetabolicRate.orElse(null));
+    ret.put("bodyRoundnessIndex", risks.bodyRoundnessIndex.orElse(null));
+    ret.put("conicityIndex", risks.conicityIndex.orElse(null));
+    ret.put("aBodyShapeIndex", risks.aBodyShapeIndex.orElse(null));
+    ret.put("totalDailyEnergyExpenditure", risks.totalDailyEnergyExpenditure.orElse(null));
+    ret.put("hypertensionRisk", risks.hypertensionRisk.orElse(null));
+    ret.put("diabetesRisk", risks.diabetesRisk.orElse(null));
+    ret.put("nonAlcoholicFattyLiverDiseaseRisk", risks.nonAlcoholicFattyLiverDiseaseRisk.map(Enum::ordinal).orElse(null));
+    return ret;
+  }
+
+  private JSONArray heartbeatsToJSONArray(ShenAIAndroidSDK.Heartbeat[] hbs) {
+    JSONArray arr = new JSONArray();
+    if (hbs != null) {
+      for (ShenAIAndroidSDK.Heartbeat hb : hbs) {
+        JSObject hbObj = new JSObject();
+        hbObj.put("startLocationSec", hb.startLocationSec);
+        hbObj.put("endLocationSec", hb.endLocationSec);
+        hbObj.put("durationMs", hb.durationMs);
+        arr.put(hbObj);
+      }
+    }
+    return arr;
+  }
+
+  private JSObject measurementQualityMetricsToJSObject(ShenAIAndroidSDK.MeasurementQualityMetrics metrics) {
+    if (metrics == null) return null;
+    JSObject obj = new JSObject();
+    obj.put("ppgQualityIndex", metrics.ppgQualityIndex.orElse(null));
+    obj.put("bcgQualityIndex", metrics.bcgQualityIndex.orElse(null));
+    obj.put("breathingQualityIndex", metrics.breathingQualityIndex.orElse(null));
+    obj.put("bloodPressureQualityIndex", metrics.bloodPressureQualityIndex.orElse(null));
+    obj.put("expectedSbpMedianAbsErrorMmhg", metrics.expectedSbpMedianAbsErrorMmhg.orElse(null));
+    obj.put("expectedSbpP80AbsErrorMmhg", metrics.expectedSbpP80AbsErrorMmhg.orElse(null));
+    obj.put("expectedSbpMeanAbsErrorMmhg", metrics.expectedSbpMeanAbsErrorMmhg.orElse(null));
+    obj.put("expectedSbpBalancedMaeMmhg", metrics.expectedSbpBalancedMaeMmhg.orElse(null));
+    obj.put("expectedDbpMedianAbsErrorMmhg", metrics.expectedDbpMedianAbsErrorMmhg.orElse(null));
+    obj.put("expectedDbpP80AbsErrorMmhg", metrics.expectedDbpP80AbsErrorMmhg.orElse(null));
+    obj.put("expectedDbpMeanAbsErrorMmhg", metrics.expectedDbpMeanAbsErrorMmhg.orElse(null));
+    obj.put("expectedDbpBalancedMaeMmhg", metrics.expectedDbpBalancedMaeMmhg.orElse(null));
+    return obj;
+  }
+
+  private JSObject measurementResultsToJSObject(ShenAIAndroidSDK.MeasurementResults r) {
+    JSObject obj = new JSObject();
+    obj.put("heartRateBpm", r.hrBpm);
+    obj.put("averageSignalQuality", r.averageSignalQuality);
+    obj.put("heartbeats", heartbeatsToJSONArray(r.heartbeats));
+    obj.put("breathingRateBpm", r.brBpm.orElse(null));
+    obj.put("hrvLnrmssdMs", r.hrvLnrmssdMs.orElse(null));
+    obj.put("hrvSdnnMs", r.hrvSdnnMs.orElse(null));
+    obj.put("stressIndex", r.stressIndex.orElse(null));
+    obj.put("parasympatheticActivity", r.parasympatheticActivity.orElse(null));
+    obj.put("systolicBloodPressureMmhg", r.systolicBloodPressureMmhg.orElse(null));
+    obj.put("diastolicBloodPressureMmhg", r.diastolicBloodPressureMmhg.orElse(null));
+    obj.put("cardiacWorkloadMmhgPerSec", r.cardiacWorkloadMmhgPerSec.orElse(null));
+    obj.put("ageYears", r.ageYears.orElse(null));
+    obj.put("bmiKgPerM2", r.bmiKgPerM2.orElse(null));
+    obj.put("bmiCategory", r.bmiCategory.map(Enum::ordinal).orElse(null));
+    obj.put("weightKg", r.weightKg.orElse(null));
+    obj.put("heightCm", r.heightCm.orElse(null));
+    obj.put("qualityMetrics", measurementQualityMetricsToJSObject(r.qualityMetrics));
+    return obj;
+  }
+
+  private JSObject measurementResultsWithMetadataToJSObject(ShenAIAndroidSDK.MeasurementResultsWithMetadata md) {
+    JSObject obj = new JSObject();
+    obj.put("measurementResults", measurementResultsToJSObject(md.measurementResults));
+    obj.put("epochTimestamp", md.epochTimestamp);
+    obj.put("isCalibration", md.isCalibration);
+    return obj;
+  }
+
+  // ───────────────────────────────────────────────────── lifecycle glue
+  @Override
+  protected void handleOnResume() {
+    if (shenaiView != null) shenaiView.onResume();
+  }
+  @Override
+  protected void handleOnPause() {
+    if (shenaiView != null) shenaiView.onPause();
+  }
+  @Override
+  public void handleOnDestroy() {
+    if (shenaiView != null || containerView != null) {
+      getActivity().runOnUiThread(() -> {
+        try {
+          getBridge().getWebView().setOnTouchListener(null);
+          getBridge().getWebView().setAlpha(1.0f);
+        } catch (Throwable ignored) {}
+
+        if (containerView != null) {
+          ViewGroup parent = (ViewGroup) containerView.getParent();
+          if (parent != null) parent.removeView(containerView);
+        }
+      });
+      shenaiView = null;
+      containerView = null;
+    }
+    sdk = null;
+  }
+
+}